diff --git a/.github/workflows/ci_workflow.yml b/.github/workflows/ci_workflow.yml
new file mode 100644
index 0000000..1cac7b1
--- /dev/null
+++ b/.github/workflows/ci_workflow.yml
@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  # Triggers the workflow on pull request events for the main and devel branch
+  pull_request:
+    branches: [ main, devel ]
+
+  # Allows running this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  # Contains a single job called "ci"
+  ci:
+    runs-on: ubuntu-latest
+    steps:
+      # Checks out repository under $GITHUB_WORKSPACE, so job can access it
+      - uses: actions/checkout@v2
+      - name: Install flake8
+        run: sudo apt install flake8
+      - name: Give executable permissions to the script
+        run: chmod a+x scripts/run_ci.sh
+      - name: Run the ci script in scripts folder
+        run: sh scripts/run_ci.sh
+        shell: bash
diff --git a/README.md b/README.md
index cd12bfe..e6e5c23 100644
--- a/README.md
+++ b/README.md
@@ -3031,8 +3031,38 @@ You can then assign a function to a variables like this `x = my_function` or you
 <details>
 <summary>Write a function to determine if a number is a Palindrome</summary><br><b>
 
+- Code:
+
 ```
+from typing import Union
+
+def isNumberPalindrome(number: Union[int, str]) -> bool:
+    if isinstance(number, int):
+        number = str(number)
+    return number == number[::-1]
+
+print(isNumberPalindrome("12321"))
 ```
+
+- Using Python3.10 that accepts using bitwise operator '|'. 
+
+```
+def isNumberPalindrome(number: int | str) -> bool:
+    if isinstance(number, int):
+        number = str(number)
+    return number == number[::-1]
+
+print(isNumberPalindrome("12321"))
+```
+
+Note: Using slicing to reverse a list could be slower than other options like `reversed` that return an iterator.
+
+- Result:
+
+```
+True
+```
+
 </b></details>
 
 #### Python - OOP
@@ -3239,6 +3269,28 @@ False
 
 <details>
 <summary>What is the __call__ method?</summary><br><b>
+
+It is used to emulate callable objects. It allows a class instance to be called as a function.
+
+- Example code:
+
+```
+class Foo:
+    def __init__(self: object) ->  None:
+        pass
+    def __call__(self: object) -> None:
+        print("Called!")
+
+f = Foo()
+f()
+```
+
+- Result:
+
+```
+Called!
+```
+
 </b></details>
 
 <details>
@@ -3425,6 +3477,24 @@ some_list[:3]
 
 <details>
 <summary>How to insert an item to the beginning of a list? What about two items?</summary><br><b>
+
+- One item:
+
+```
+numbers = [1, 2, 3, 4, 5]
+numbers.insert(0, 0)
+print(numbers)
+```
+
+- Multiple items or list:
+
+```
+numbers_1 = [2, 3, 4, 5]
+numbers_2 = [0, 1]
+numbers_1 = numbers_2 + numbers_1
+print(numbers_1)
+```
+
 </b></details>
 
 <details>
@@ -3632,6 +3702,31 @@ list(zip(nums, letters))
 
 <details>
 <summary>What is List Comprehension? Is it better than a typical loop? Why? Can you demonstrate how to use it?</summary><br><b>
+
+From [Docs](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions): "List comprehensions provide a concise way to create lists. Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence or iterable, or to create a subsequence of those elements that satisfy a certain condition.".
+
+It's better because they're compact, faster and have better readability.
+
+- For loop:
+
+```
+number_lists = [[1, 7, 3, 1], [13, 93, 23, 12], [123, 423, 456, 653, 124]]
+odd_numbers = []
+for number_list in number_lists:
+    for number in number_list:
+        if number % 2 == 0:
+            odd_numbers.append(number)
+print(odd_numbers)
+```
+
+- List comprehesion:
+
+```
+number_lists = [[1, 7, 3, 1], [13, 93, 23, 12], [123, 423, 456, 653, 124]]
+odd_numbers = [number for number_list in number_lists for number in number_list if number % 2 == 0]
+print(odd_numbers)
+```
+
 </b></details>
 
 <details>
@@ -7339,7 +7434,7 @@ Not only this will tell you what is expected from you, it will also provide big
 <details>
 <summary>What does it mean when a database is ACID compliant?</summary><br>
 
-ACID stands for Atomicity, Consistency, Isolation, Durability. In order to be ACID compliant, the database much meet each of the four criteria
+ACID stands for Atomicity, Consistency, Isolation, Durability. In order to be ACID compliant, the database must meet each of the four criteria
 
 **Atomicity** - When a change occurs to the database, it should either succeed or fail as a whole.