diff --git a/src/routes/docs/tutorials/android/step-1/+page.markdoc b/src/routes/docs/tutorials/android/step-1/+page.markdoc
index 17a7350925..0ac423e796 100644
--- a/src/routes/docs/tutorials/android/step-1/+page.markdoc
+++ b/src/routes/docs/tutorials/android/step-1/+page.markdoc
@@ -1,17 +1,26 @@
 ---
 layout: tutorial
-title: Coming soon
+title: Recipewrite - a Recipe sharing app
 description: Learn to build an Android app with no backend code using an Appwrite backend.
 framework: Android
 step: 1
-draft: true
+difficulty: beginner
 ---
 
-Improve the docs, add this guide.
+**Recipewrite**: an android app to share and find all the delicious recipes that left you licking your fingers.
+In this tutorial, you will build Recipewrite with Appwrite, Android and Java.
 
-We still don't have this guide in place, but we do have some great news. 
-The Appwrite docs, just like Appwrite, is completely open sourced.
-This means, anyone can help improve them and add new guides and tutorials. 
+# Concepts {% #concepts %}
+This tutorial will introduce the following concepts:
 
-If you see this page, **we're actively looking for contributions to this page**.
-Follow our contribution guidelines, open a PR to [our Website repo](https://github.com/appwrite/website), and collaborate with our core team to improve this page.
\ No newline at end of file
+1. Setting up your first project
+2. Authentication 
+3. Databases and collections
+4. Database Queries
+5. Pagination
+
+# Prerequisites {% #prerequisites %}
+1. Basic knowledge of Java.
+2. Have [Java](https://www.java.com/en/) and [Android Studio](https://developer.android.com/studio) installed on your computer.
+
+If you are stuck at any point, you can refer to the final code repository of this tutorial [here](https://github.com/letsintegreat/Recipewrite).
\ No newline at end of file
diff --git a/src/routes/docs/tutorials/android/step-2/+page.markdoc b/src/routes/docs/tutorials/android/step-2/+page.markdoc
new file mode 100644
index 0000000000..ef14fc4641
--- /dev/null
+++ b/src/routes/docs/tutorials/android/step-2/+page.markdoc
@@ -0,0 +1,33 @@
+---
+layout: tutorial
+title: Initialize project
+description: Learn to build an Android app with no backend code using an Appwrite backend.
+step: 2
+difficulty: beginner
+---
+
+# Initialize Android Studio project {% #initialize-android-studio-project %}
+
+Open Android Studio and click **New Project** to create a new project. Select **Empty Views Activity**, and click **Next**.
+
+![Empty Activity](/images/docs/tutorials/recipewrite-empty-activity.png)
+
+Name your project **Recipewrite**, select Java language, and minimum SDK would be **23**.
+
+![New Project](/images/docs/tutorials/recipewrite-new-project.png)
+
+# Add dependencies {% #add-dependencies %}
+
+Open `app/build.gradle` file, update `compileSdk` and `targetSdk` to **34**, then find `dependencies` block, and add the Appwrite dependency along with existing ones.
+
+```
+dependencies {
+    implementation 'io.appwrite:sdk-for-android:4.0.0' // Appwrite dependency
+    implementation 'androidx.appcompat:appcompat:1.6.1'
+    implementation 'com.google.android.material:material:1.10.0'
+    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
+    testImplementation 'junit:junit:4.13.2'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
+}
+```
\ No newline at end of file
diff --git a/src/routes/docs/tutorials/android/step-3/+page.markdoc b/src/routes/docs/tutorials/android/step-3/+page.markdoc
new file mode 100644
index 0000000000..d63081d926
--- /dev/null
+++ b/src/routes/docs/tutorials/android/step-3/+page.markdoc
@@ -0,0 +1,68 @@
+---
+layout: tutorial
+title: Setup Appwrite
+description: Learn to build an Android app with no backend code using an Appwrite backend.
+step: 3
+difficulty: beginner
+---
+
+# Create project {% #create-project %}
+
+Head to the [Appwrite Console](https://cloud.appwrite.io/console).
+
+{% only_dark %}
+![Create project screen](/images/docs/quick-starts/dark/create-project.png)
+{% /only_dark %}
+{% only_light %}
+![Create project screen](/images/docs/quick-starts/create-project.png)
+{% /only_light %}
+
+If this is your first time using Appwrite, create an account and create your first project.
+
+Then, under **Add a platform**, add a **Android app**. **Package Name** can be found in app level gradle file. 
+
+{% only_dark %}
+![Add a platform](/images/docs/quick-starts/dark/add-platform.png)
+{% /only_dark %}
+{% only_light %}
+![Add a platform](/images/docs/quick-starts/add-platform.png)
+{% /only_light %}
+
+You can skip the optional steps.
+
+# Connect your app with Appwrite {% #connect-your-app-with-appwrite %}
+
+Create **Appwrite.java** in the same directory that contains **MainActivity.java**, this will handle our app's interaction with Appwrite server. Replace `[project-id]` with your new project's id, which can be found beside your project's name in overview tab.
+
+```java
+public class Appwrite {
+    private static Client client;
+    private static Account account;
+    private static Databases databases;
+
+    private static final String projectID = "[project-id]";
+    private static final String endpoint = "https://cloud.appwrite.io/v1";  // Add local address if you are running Appwrite locally
+
+    public static void init(Context context) {
+        client = new Client(context);
+        client.setEndpoint(endpoint);
+        client.setProject(projectID);
+        client.setSelfSigned(true);
+
+        account = new Account(client);
+        databases = new Databases(client);
+    }
+}
+```
+
+Finally, call this `init` method in `onCreate` method of **MainActivity.java**.
+
+```java
+@Override
+protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.activity_main);
+
+    Appwrite.init(this);
+}
+```
\ No newline at end of file
diff --git a/src/routes/docs/tutorials/android/step-4/+page.markdoc b/src/routes/docs/tutorials/android/step-4/+page.markdoc
new file mode 100644
index 0000000000..a1a5619492
--- /dev/null
+++ b/src/routes/docs/tutorials/android/step-4/+page.markdoc
@@ -0,0 +1,412 @@
+---
+layout: tutorial
+title: Authentication
+description: Learn to build an Android app with no backend code using an Appwrite backend.
+step: 4
+difficulty: beginner
+---
+
+# User Flow {% #user-flow %}
+
+This is the user flow that we are going to achieve in this page.
+
+![user-flow](/images/docs/tutorials/recipewrite-user-flow.png)
+
+Keeping the userflow in mind, let us start by initializing two new empty views activities, **AuthActivity** and **HomeActivity**.
+
+# Appwrite methods {% #appwrite-methods %}
+
+Let us implement some utility methods in **Appwrite.java**.
+
+**onGetAccount**
+
+It will be used in **MainActivity** to check if the user is already logged in or not. `coroutineCallback` is the piece of code that should be run after checking whether or not the user is logged in.
+
+```java
+public static void onGetAccount(CoroutineCallback<User> coroutineCallback) {
+    try {
+        /* Account.get is used to get the currently logged in user. */
+        account.get(coroutineCallback);
+    } catch (Exception e) {
+        e.printStackTrace();
+    }
+}
+```
+
+**onLogin**
+
+This method will take in email and password, and will try to log the user in.
+
+```java
+public static void onLogin(String email, String password, CoroutineCallback<Session> coroutineCallback) {
+    /* Allow the user to login into their account by providing a valid email and password combination. */
+    account.createEmailSession(
+            email,
+            password,
+            coroutineCallback
+    );
+}
+```
+
+**onCreateAccount**
+
+This method will take in email, password and name, and will try to register our new user to the app.
+
+```java
+public static void onCreateAccount(String email, String password, String name, CoroutineCallback<User> coroutineCallback) {
+    try {
+        /* Allow a new user to register a new account */
+        account.create(
+                ID.Companion.unique(),
+                email,
+                password,
+                name,
+                coroutineCallback
+        );
+    } catch (AppwriteException e) {
+        e.printStackTrace();
+    }
+}
+```
+
+**onLogout**
+
+```java
+public static void onLogout(CoroutineCallback<Object> coroutineCallback) {
+    /* Logout the user. Use 'current' as the session ID to logout on this device, use a session ID to logout on another device. */
+    account.deleteSession(
+            "current",
+            coroutineCallback
+    );
+}
+```
+
+# Main Activity {% #main-activity %}
+
+As shown in the userflow, main activity will just check if the user is already logged in or not. It will redirect accordingly.
+
+## **activity_main.xml**
+
+We just need a progress bar here.
+
+```xml
+<ProgressBar
+    android:id="@+id/progressBar"
+    style="?android:attr/progressBarStyle"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    app:layout_constraintBottom_toBottomOf="parent"
+    app:layout_constraintEnd_toEndOf="parent"
+    app:layout_constraintStart_toStartOf="parent"
+    app:layout_constraintTop_toTopOf="parent" />
+```
+
+## **MainActivity.java**
+
+We will reuse our **onGetAccount** method here.
+
+```java
+@Override
+protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO);
+    setContentView(R.layout.activity_main);
+    
+    /* Ensure this is the first time onCreate is called. */
+    /* This will prevent Appwrite to be initialized multiple times */
+    if (savedInstanceState == null) {
+        Appwrite.init(this);
+        Appwrite.onGetAccount(new CoroutineCallback<>((result, error) -> {
+
+            Intent intent;
+
+            if (error != null) {  /* User isn't logged in. */
+                intent = new Intent(this, AuthActivity.class);
+            } else {              /* User is logged in.    */
+                intent = new Intent(this, HomeActivity.class);
+
+                /* This will pass the account name to HomeActivity. */
+                intent.putExtra("name", result.getName());
+            }
+
+            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+
+            /* Launch the activity as per our user flow. */
+            startActivity(intent);
+
+            /* Finish the current activity. */
+            this.finish();
+        }));
+    }
+}
+```
+
+# Auth Activity {% #auth-activity %}
+
+## **activity_login.xml**
+
+We will need five elements here.
+
+- Name field, which will dynamically be shown/hidden from UI as per the current state(Register/Login).
+
+```xml
+<EditText
+    android:id="@+id/name_edit_text"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:hint="Name"
+    android:inputType="textPersonName"
+    app:layout_constraintEnd_toEndOf="parent"
+    app:layout_constraintStart_toStartOf="parent"
+    app:layout_constraintTop_toTopOf="parent" />
+```
+
+- Email field.
+
+```xml
+<EditText
+    android:id="@+id/email_edit_text"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:hint="Email"
+    android:inputType="textEmailAddress"
+    app:layout_constraintEnd_toEndOf="parent"
+    app:layout_constraintStart_toStartOf="parent"
+    app:layout_constraintTop_toTopOf="parent" />
+```
+
+- Password field.
+
+```xml
+<EditText
+    android:id="@+id/password_edit_text"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:hint="Password"
+    android:inputType="textPassword"
+    app:layout_constraintEnd_toEndOf="parent"
+    app:layout_constraintStart_toStartOf="parent"
+    app:layout_constraintTop_toBottomOf="@+id/email_edit_text" />
+```
+
+- Submit button, which will initially be called "Register" and will be renamed dynamically to "Login" as per the current state.
+
+```xml
+<Button
+    android:id="@+id/submit_button"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:text="Register"
+    app:layout_constraintEnd_toEndOf="parent"
+    app:layout_constraintStart_toStartOf="parent"
+    app:layout_constraintTop_toBottomOf="@+id/password_edit_text" />
+```
+
+- State change button, which will change Register state to Login state and vice-versa.
+
+```xml
+<Button
+    android:id="@+id/change_state_button"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:text="LOGIN?"
+    app:layout_constraintEnd_toEndOf="parent"
+    app:layout_constraintStart_toStartOf="parent"
+    app:layout_constraintTop_toBottomOf="@+id/submit_button" />
+```
+
+## **AuthActivity.java**
+
+Now let us write logic of button clicks. There are a couple of ways to implement `OnClickListener` on views. Here we are going to use `View.OnClickListener` interface.
+
+Change the definition of `AuthActivity` to implement `View.OnClickListener` interface.
+
+```java
+public class AuthActivity extends AppCompatActivity implements View.OnClickListener
+```
+
+Declare UI views and state variable within this class.
+
+```java
+EditText nameEditText, emailEditText, passwordEditText;
+Button submitButton, changeStateButton;
+String state = "register";
+```
+
+Initialize these variables in `onCreate` method.
+
+```java
+nameEditText = findViewById(R.id.name_edit_text);
+emailEditText = findViewById(R.id.email_edit_text);
+passwordEditText = findViewById(R.id.password_edit_text);
+submitButton = findViewById(R.id.submit_button);
+changeStateButton = findViewById(R.id.change_state_button);
+```
+
+Set `OnClickListener`s on both the buttons inside `onCreate` method.
+
+```java
+submitButton.setOnClickListener(this);
+changeStateButton.setOnClickListener(this);
+```
+
+Now override the `onClick` method of `LoginActivity` to finally write the click logic.
+
+```java
+@Override
+public void onClick(View view) {
+
+    /* Extract user input */
+    String name = nameEditText.getText().toString();
+    String email = emailEditText.getText().toString();
+    String password = passwordEditText.getText().toString();
+
+    switch ((view.getId())) {
+        case R.id.submit_button:
+            if (Objects.equals(state, "register")) {
+                /* Register if the state is "register". */
+                register(email, password, name);
+            } else {
+                /* Login if the state is "login". */
+                login(email, password);
+            }
+            break;
+
+        case R.id.change_state_button:
+            /* Change register state to login state and vice-versa. */
+            changeState();
+            break;
+    }
+}
+```
+
+Now we are left with implementing these three methods in **AuthActivity**. Let us start with the simplest one `changeState`.
+
+```java
+void changeState() {
+    if (Objects.equals(state, "register")) {
+        /* If state is "register", change it to "login". */
+        state = "login";
+        nameEditText.setVisibility(View.GONE);
+        submitButton.setText("Login");
+        changeStateButton.setText("Register?");
+    } else {
+        /* If state is "login", change it to "register". */
+        state = "register";
+        nameEditText.setVisibility(View.VISIBLE);
+        submitButton.setText("Register");
+        changeStateButton.setText("Login?");
+    }
+}
+```
+
+Now, for the `login` method, we will first call `Appwrite.onLogin`, after successfully logging the user in, we will use `Appwrite.onGetAccount` to get the user's name and pass it on to **HomeActivity**.
+
+```java
+void login(String email, String password) {
+    Appwrite.onLogin(email, password, new CoroutineCallback<>((r, error) -> {
+        if (error != null) {
+            /* Login unsuccessful */
+            error.printStackTrace();
+            return;
+        }
+
+        /* Get current user and redirect to HomeActivity */
+        Appwrite.onGetAccount(new CoroutineCallback<>((result, e) -> {
+
+            Intent intent = new Intent(this, HomeActivity.class);
+
+            /* This will pass the account name to HomeActivity */
+            intent.putExtra("name", result.getName());
+
+            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            startActivity(intent);
+            this.finish();
+        }));
+    }));
+}
+```
+
+Finally, for `register` method, we will first create an account for our new user using `Appwrite.onCreateAccount`, then we will reuse our `login` function to log the user in.
+
+```java
+void register(String email, String password, String name) {
+    Appwrite.onCreateAccount(email, password, name, new CoroutineCallback<>((res, err) -> {
+        if (err != null) {
+            /* Create account unsuccessful */
+            err.printStackTrace();
+            return;
+        }
+
+        /* Log the new user in, and redirect to HomeActivity */
+        login(email, password);
+    }));
+}
+```
+
+This completes the implementation of **AuthActivity**.
+
+# Home Activity {% #home-activity %}
+
+Finally, we want to add a logout button in the app bar of **HomeActivity**.
+
+Let us start by creating a vector asset for logout icon.
+
+Right click on **res** folder, click **New**, click **Vector Asset**.
+
+Choose logout icon in **Clip Art** and then give the asset **logout** name.
+
+![Asset Studio](/images/docs/tutorials/recipewrite-asset-studio.png)
+
+Now, create a new file `res/menu/mymenu.xml`.
+
+```xml
+<menu xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:android="http://schemas.android.com/apk/res/android" >
+    <item
+        android:id="@+id/action_logout"
+        android:icon="@drawable/logout"
+        android:orderInCategory="100"
+        app:showAsAction="always"
+        android:title="Logout" />
+</menu>
+```
+
+Now, override ```onCreateOptionsMenu``` method of ```HomeActivity``` in order to show the above defined icon on the app bar.
+
+```java
+@Override
+public boolean onCreateOptionsMenu(Menu menu) {
+    getMenuInflater().inflate(R.menu.mymenu, menu);
+    return super.onCreateOptionsMenu(menu);
+}
+```
+
+Finally, to write its click logic, override ```onOptionsItemSelected``` method and use our already defined method `Appwrite.onLogout`.
+
+```java
+@Override
+public boolean onOptionsItemSelected(MenuItem item) {
+    int id = item.getItemId();
+
+    if (id == R.id.action_logout) {
+        Appwrite.onLogout(new CoroutineCallback<>((result, error) -> {
+            if (error != null) {
+                /* Logout unsuccessful */
+                error.printStackTrace();
+                return;
+            }
+
+            /* Redirect to LoginActivity if logout successful */
+            Intent intent = new Intent(this, AuthActivity.class);
+            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            startActivity(intent);
+            this.finish();
+        }));
+    }
+
+    return super.onOptionsItemSelected(item);
+}
+```
+
+Kudos! We started from zero and now we have a full fledged authentication system.
\ No newline at end of file
diff --git a/src/routes/docs/tutorials/android/step-5/+page.markdoc b/src/routes/docs/tutorials/android/step-5/+page.markdoc
new file mode 100644
index 0000000000..314122c6b8
--- /dev/null
+++ b/src/routes/docs/tutorials/android/step-5/+page.markdoc
@@ -0,0 +1,323 @@
+---
+layout: tutorial
+title: Database
+description: Learn to build an Android app with no backend code using an Appwrite backend.
+step: 5
+difficulty: beginner
+---
+
+# Create database and collection {% #create-database-and-collection %}
+
+Head to the [Appwrite Console](https://cloud.appwrite.io/console).
+
+In **Databases** tab, click on **Create database**, give it any name and set Database ID to `default`.
+
+Click on **Create collection**, give it any name and set Collection ID to `recipes`.
+
+In **Attributes** tab, create two new attributes.
+
+{% only_dark %}
+![Create project screen](/images/docs/tutorials/dark/recipewrite-collection-attributes.png)
+{% /only_dark %}
+{% only_light %}
+![Create project screen](/images/docs/tutorials/recipewrite-collection-attributes.png)
+{% /only_light %}
+
+| Key         | Type        | Size        | Required    |
+| ----------- | ----------- | ----------- | ----------- |
+| **name**    | String      | 100         | true        |
+| **recipe**  | String      | 1024        | true        |
+
+
+In **Indexes** tab, create a new index. This will be important for search feature of our app.
+
+{% only_dark %}
+![Create project screen](/images/docs/tutorials/dark/recipewrite-collection-indexes.png)
+{% /only_dark %}
+{% only_light %}
+![Create project screen](/images/docs/tutorials/recipewrite-collection-indexes.png)
+{% /only_light %}
+
+| Key              | Type        | Attribute   | ASC/DESC    |
+| ---------------- | ----------- | ----------- | ----------- |
+| **recipe_index** | FullText    | recipe      | ASC         |
+
+
+In **Settings** tab, find **Permissions** heading, add **Any** role and turn on all options, i.e., Create, Read, Update and Delete. You can learn more about Appwrite permissions [here](https://appwrite.io/docs/advanced/platform/permissions).
+
+{% only_dark %}
+![Create project screen](/images/docs/tutorials/dark/recipewrite-collection-permissions.png)
+{% /only_dark %}
+{% only_light %}
+![Create project screen](/images/docs/tutorials/recipewrite-collection-permissions.png)
+{% /only_light %}
+
+# Recipe Model {% #recipe-model %}
+
+Create a new java class, **RecipeModel**. Recipe model will have two string members, **name** and **recipe**.
+
+```java
+public class RecipeModel {
+    public String name;
+    public String recipe;
+
+    public Map<String, String> toJson() {
+        Map<String, String> ret = new HashMap<>();
+        ret.put("name", name);
+        ret.put("recipe", recipe);
+        return ret;
+    }
+
+    public RecipeModel(Map<String, String> data) {
+        this.name = data.get("name");
+        this.recipe = data.get("recipe");
+    }
+
+    public RecipeModel(String name, String recipe) {
+        this.name = name;
+        this.recipe = recipe;
+    }
+
+    @Override
+    public String toString() {
+        return name + " shared:\n" + recipe;
+    }
+}
+```
+
+# Appwrite methods {% #appwrite-methods %}
+
+Now we are going to write database methods in `Appwrite.java`, just like we did in authentication part.
+
+But first let's add `databaseID` and `collectionID` member variables to our `Appwrite` class.
+
+```java
+private static final String databaseID = "default";
+private static final String collectionID = "recipes";
+```
+
+## **onAddRecipe**
+
+This method will be invoked to add a new recipe to the database.
+
+```java
+public static void onAddRecipe(RecipeModel recipeModel, CoroutineCallback coroutineCallback) {
+    try {
+        /* Create a new Document. */
+        databases.createDocument(
+                databaseID,
+                collectionID,
+                ID.Companion.unique(),
+                recipeModel.toJson(),
+                coroutineCallback
+        );
+    } catch (AppwriteException e) {
+        e.printStackTrace();
+    }
+}
+```
+
+## **onListRecipes**
+
+This method will fetch the list of recipes stored in our recipes collection.
+
+```java
+public static void listRecipes(CoroutineCallback<DocumentList> coroutineCallback) {
+    try {
+        /* Get a list of all the user's documents in a given collection. */
+        databases.listDocuments(
+            databaseID,
+            collectionID,
+            coroutineCallback
+        );
+    } catch (AppwriteException e) {
+        e.printStackTrace();
+    }
+}
+```
+
+# Add a recipe {% #add-a-recipe %}
+
+Let us implement the feature to add a finger-licking recipe to our database. We need two pieces of information to create a new recipe model, name of current user and the recipe they want to share.
+
+Remember we passed name of the user to **HomeActivity** in `onGetAccount` method of `Appwrite` class? Let us extract that out.
+
+Declare a string member variable `name` inside **HomeActivity**.
+
+```java
+String name;
+```
+
+Extract name from intent in `onCreate` method.
+
+```java
+name = getIntent().getStringExtra("name");
+```
+
+Now, in order to get user's delicious recipe, let us make a floating action button. Again, use **Vector Asset** to make a new icon. Choose **add** icon in clip art, and then name it `add.xml`.
+
+Add a `FloatingActionButton` to `activity_home.xml`.
+
+```xml
+<com.google.android.material.floatingactionbutton.FloatingActionButton
+    android:id="@+id/floatingActionButton"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:clickable="true"
+    app:layout_constraintBottom_toBottomOf="parent"
+    app:layout_constraintEnd_toEndOf="parent"
+    app:srcCompat="@drawable/add" />
+```
+
+Update definition of **HomeActivity** to implement `View.OnClickListener`.
+
+```java
+public class HomeActivity extends AppCompatActivity implements View.OnClickListener
+```
+
+Declare a `FloatingActionButton` member variable of **HomeActivity**.
+
+```java
+FloatingActionButton fab;
+```
+
+Initialize it in `onCreate` method.
+
+```java
+fab = findViewById(R.id.floatingActionButton);
+fab.setOnClickListener(this);
+```
+
+Now, override `onClick` to write its click logic. We are going to show an `AlertDialog` with a text field to capture user's recipe and then use our Appwrite method to add the new recipe to database.
+
+```java
+@Override
+public void onClick(View view) {
+    switch ((view.getId())) {
+
+        case R.id.floatingActionButton:
+
+            /* Declare the builder */
+            AlertDialog.Builder builder = new AlertDialog.Builder(this);
+
+            /* Set its title */
+            builder.setTitle("Add Recipe");
+
+            /* Create a new text field for recipe */
+            final EditText input = new EditText(this);
+            builder.setView(input);
+
+            /* Add an 'Add' button to the dialog */
+            builder.setPositiveButton("Add", (dialog, which) -> {
+
+                /* Extract user input */
+                String recipe = input.getText().toString();
+
+                /* Create a new recipe model */
+                RecipeModel recipeModel = new RecipeModel(name, recipe);
+
+                /* Add the new recipe to database */
+                Appwrite.onAddRecipe(recipeModel, new CoroutineCallback<>((result, error) -> {
+                    /* Do something on success addition to database */
+                }));
+            });
+
+            /* Add a 'Cancel' button to cancel the dialog */
+            builder.setNegativeButton("Cancel", (dialog, which) -> dialog.cancel());
+
+            /* Finally show the dialog */
+            builder.show();
+            break;
+    }
+}
+```
+
+# List recipes {% #list-recipes %}
+
+Now, let us show all the delicious recipes that we've got stacked in our database.
+
+Add a `ListView` in `activity_home.xml`.
+
+```xml
+<ListView
+    android:id="@+id/list_view"
+    android:layout_width="0dp"
+    android:layout_height="0dp"
+    app:layout_constraintBottom_toBottomOf="parent"
+    app:layout_constraintEnd_toEndOf="parent"
+    app:layout_constraintStart_toStartOf="parent"
+    app:layout_constraintTop_toTopOf="parent" >
+
+</ListView>
+```
+
+Now, in **HomeActivity** class, add the following member variables.
+
+```java
+ListView listView;
+ArrayList<RecipeModel> recipes = new ArrayList<>();
+ArrayAdapter<RecipeModel> arr;
+```
+
+Initialize `listView` and `arr` in `onCreate` method and set `arr` as adapter to `listView`.
+
+```java
+listView = findViewById(R.id.list_view);
+arr = new ArrayAdapter<>(
+    this,
+    R.layout.list_item,
+    recipes
+);
+listView.setAdapter(arr);
+```
+
+Create a new file `res/layout/list_item.xml`.
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+
+<TextView xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@android:id/text1"
+    style="?attr/spinnerDropDownItemStyle"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:ellipsize="marquee"/>
+```
+
+Now finally, let's write a method `reloadList` which will fetch the list of recipes from database, and update the UI.
+
+```java
+private void reloadList() {
+    Appwrite.listRecipes(new CoroutineCallback<>((result, error) -> {
+        if (error != null) {
+            error.printStackTrace();
+            return;
+        }
+
+        /* Clear recipes list first as we have fresh data */
+        recipes.clear();
+        if (result != null) {
+            for (Object document: result.getDocuments()) {
+                /* Extract JSON data from the response */
+                Map<String, String> data = (Map<String, String>) ((Document) document).getData();
+
+                /* Create recipe model from that JSON data */
+                RecipeModel recipe = new RecipeModel(data);
+
+                /* Add that model to our list of recipes */
+                recipes.add(recipe);
+            }
+        }
+
+        /* notify the adapter about the changes in list of recipes */
+        runOnUiThread(() -> arr.notifyDataSetChanged());
+    }));
+}
+```
+
+Call `reloadList`
+
+1. at the end of `onCreate` in order to load the list on startup.
+2. in `onClick`, under the comment `Do something on success addition to database` in order to reload the list once we have added a new recipe.
+
+Phew! We have successfully connected the app to the database, you can see both **add** and **list** in action by this time!
\ No newline at end of file
diff --git a/src/routes/docs/tutorials/android/step-6/+page.markdoc b/src/routes/docs/tutorials/android/step-6/+page.markdoc
new file mode 100644
index 0000000000..d491b77239
--- /dev/null
+++ b/src/routes/docs/tutorials/android/step-6/+page.markdoc
@@ -0,0 +1,116 @@
+---
+layout: tutorial
+title: Database Queries
+description: Learn to build an Android app with no backend code using an Appwrite backend.
+step: 6
+difficulty: beginner
+---
+
+# Introduction {% #introduction %}
+
+Many list endpoints in Appwrite allow you to filter, sort, and paginate results using queries. Appwrite provides a common set of syntax to build queries. Learn more about Appwrite Queries [here](https://appwrite.io/docs/products/databases/queries).
+
+To demonstrate how queries are used in java, we are going to implement **search feature** in our **Recipewrite** app.
+
+# Search feature {% #search-feature %}
+
+Let us show a search icon next to logout icon in app bar of our Home Activity. Again, use **Asset Studio** to add a **search** icon from clip art, then name it `search.xml`.
+
+Add the following icon in `res/layout/mymenu.xml`.
+
+```xml
+<item
+    android:id="@+id/action_search"
+    android:icon="@drawable/search"
+    android:orderInCategory="100"
+    app:showAsAction="always"
+    android:title="Search" />
+```
+
+Introduce a `search` argument in our `listRecipes` method of `Appwrite.java` file. This argument will be an empty string if user doesn't want to perform a search, otherwise it will contain the search query.
+
+```java
+public static void listRecipes(String search, CoroutineCallback<DocumentList> coroutineCallback) {
+
+    ArrayList<String> queries = new ArrayList<>();
+    if (!search.isEmpty()) {
+        /* Perform the search on 'recipe' attribute */
+        queries.add(Query.Companion.search("recipe", search));
+    }
+    
+    try {
+        /* Get a list of all the user's documents in a given collection. */
+        databases.listDocuments(
+            databaseID,
+            collectionID,
+            queries,
+            coroutineCallback
+        );
+    } catch (AppwriteException e) {
+        e.printStackTrace();
+    }
+}
+```
+
+Now, create a new String member variable `search` in **HomeActivity**.
+
+```java
+String search = "";
+```
+
+Pass this argument to **listRecipes** inside **reloadList** method
+
+```java
+Appwrite.listRecipes(search, new CoroutineCallback<>((result, error) -> {
+```
+
+Finally, update the `onOptionsItemSelected` method to write search button's click logic.
+
+```java
+@Override
+public boolean onOptionsItemSelected(MenuItem item) {
+    int id = item.getItemId();
+
+    if (id == R.id.action_logout) {
+        Appwrite.onLogout(this);
+    } else if (id == R.id.action_search) {
+
+        /* Declare an AlertDialog to capture search query from user */
+        AlertDialog.Builder builder = new AlertDialog.Builder(this);
+        builder.setTitle("Search Recipe");
+
+        /* Initialize a new text field to take user input */
+        final EditText input = new EditText(this);
+
+        /* Set its initial value to be the current search query */
+        input.setText(search);
+        builder.setView(input);
+
+        /* Add a 'Search' button to perform the search */
+        builder.setPositiveButton("Search", (dialog, which) -> {
+
+            /* Extract user input */
+            search = input.getText().toString();
+            /* reload the list */
+            reloadList();
+        });
+
+        /* Add a 'Clear' button to remove current search query */
+        builder.setNegativeButton("Clear", (dialog, which) -> {
+            /* reset search to empty string */
+            search = "";
+            /* reload the list */
+            reloadList();
+            /* close the dialog */
+            dialog.cancel();
+        });
+
+        /* Finally show the dialog */
+        builder.show();
+    }
+    
+    return super.onOptionsItemSelected(item);
+}
+```
+
+There you have the search feature in action!
\ No newline at end of file
diff --git a/src/routes/docs/tutorials/android/step-7/+page.markdoc b/src/routes/docs/tutorials/android/step-7/+page.markdoc
new file mode 100644
index 0000000000..6d4647b815
--- /dev/null
+++ b/src/routes/docs/tutorials/android/step-7/+page.markdoc
@@ -0,0 +1,158 @@
+---
+layout: tutorial
+title: Pagination
+description: Learn to build an Android app with no backend code using an Appwrite backend.
+step: 7
+difficulty: beginner
+---
+
+# Introduction {% #introduction %}
+
+As your database grows in size, you'll need to paginate results returned. Pagination improves performance by returning a subset of results that match a query at a time, called a page.
+
+By default, list operations return 25 items per page, which can be changed using the ```Query.limit(25)``` operator. **Beware that large pages can degrade performance**.
+
+After reading a page of documents, pass the last document's ID into the ```Query.cursorAfter(lastId)``` query method to get the next page of documents. Pass the first document's ID into the ```Query.cursorBefore(firstId)``` query method to retrieve the previous page.
+
+Learn more about pagination [here](https://appwrite.io/docs/products/databases/pagination).
+
+# Pagination feature {% #pagination-feature %}
+
+Update the ```listRecipes``` method to take in ```lastDocumentId``` as an argument, and add appropriate query.
+
+```java
+public static void listRecipes(String search, String lastDocumentId, CoroutineCallback<DocumentList> coroutineCallback) {
+    ArrayList<String> queries = new ArrayList<>();
+
+    if (!search.isEmpty()) {
+        /* Perform the search on 'recipe' attribute */
+        queries.add(Query.Companion.search("recipe", search));
+    }
+
+    if(!lastDocumentId.isEmpty()) {
+        /* This retrieves the next page */
+        queries.add(Query.Companion.cursorAfter(lastDocumentId));
+    }
+
+    try {
+        /* Get a list of all the user's documents in a given collection. */
+        databases.listDocuments(
+            databaseID,
+            collectionID,
+            queries,
+            coroutineCallback
+        );
+    } catch (AppwriteException e) {
+        e.printStackTrace();
+    }
+}
+```
+
+Declare the following member variables in ```HomeActivity``` class.
+
+1. **recipesDocuments**: As we will be needing the documentId of the last document we have, let us maintain a list of documents.
+2. **loading**: This will ensure no two ```listRecipes``` operations happen at the same time.
+
+```java
+ArrayList<Document> recipesDocuments = new ArrayList<>();
+Boolean loading = false;
+```
+
+In ```reloadList``` method, set ```loading``` to true and false accordingly, pass an empty string to ```listRecipe``` as ```lastDocumentId``` and update `recipesDocuments` list along with `recipes` list.
+
+```java
+private void reloadList() {
+    loading = true;
+    Appwrite.listRecipes(search, "", new CoroutineCallback<>((result, error) -> {
+        if (error != null) {
+            error.printStackTrace();
+            return;
+        }
+
+        /* Clear recipes list first as we have fresh data */
+        recipes.clear();
+        recipesDocuments.clear();
+        if (result != null) {
+            for (Object document: result.getDocuments()) {
+                /* Extract JSON data from the response */
+                Map<String, String> data = (Map<String, String>) ((Document) document).getData();
+
+                /* Create recipe model from that JSON data */
+                RecipeModel recipe = new RecipeModel(data);
+
+                /* Add that model to our list of recipes */
+                recipes.add(recipe);
+                recipesDocuments.add((Document) document);
+            }
+        }
+
+        /* notify the adapter about the changes in list of recipes */
+        runOnUiThread(() -> arr.notifyDataSetChanged());
+        loading = false;
+    }));
+}
+```
+
+Write a new method ```loadNextPage``` which will pass the documentId of the last document we have in our UI, and append the result to the UI. It will be called every time user scrolls to the bottom of the `ListView`.
+
+```java
+private void loadNextPage() {
+    loading = true;
+    String lastDocumentId = "";
+
+    /* find the documentId of the last document we have on UI */
+    if (!recipesDocuments.isEmpty()) {
+        lastDocumentId = recipesDocuments.get(recipesDocuments.size() - 1).getId();
+    }
+
+    Appwrite.listRecipes(search, lastDocumentId, new CoroutineCallback<>((result, error) -> {
+        if (error != null) {
+            error.printStackTrace();
+            return;
+        }
+
+        if (result != null) {
+            for (Object document: result.getDocuments()) {
+                /* Extract JSON data from the response */
+                Map<String, String> data = (Map<String, String>) ((Document) document).getData();
+
+                /* Create recipe model from that JSON data */
+                RecipeModel recipe = new RecipeModel(data);
+
+                /* Add that model to our list of recipes */
+                recipes.add(recipe);
+                recipesDocuments.add((Document) document);
+            }
+
+            /* notify the adapter about the changes in list of recipes if list is changed */
+            if (result.getTotal() != 0) {
+                runOnUiThread(() -> arr.notifyDataSetChanged());
+            }
+        }
+        loading = false;
+    }));
+}
+```
+
+Now, in order to call ```loadNextPage``` every time user scrolls to the bottom, we will add an ```OnScrollListener``` to the listView in ```onCreate``` method.
+
+```
+listView.setOnScrollListener(new AbsListView.OnScrollListener() {
+    @Override
+    public void onScrollStateChanged(AbsListView absListView, int i) {}
+
+    @Override
+    public void onScroll(AbsListView absListView, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
+        /* Find out the last item which is visible on our UI */
+        int lastInScreen = firstVisibleItem + visibleItemCount;
+
+        if (lastInScreen == totalItemCount) { /* User is looking at the last item of our list, load next page if we aren't already loading. */
+            if (!loading) loadNextPage();
+        }
+    }
+});
+```
+
+Finally, get rid of the ```reloadList``` call from ```onCreate``` method, as our ```OnScrollListener``` will take care of it. 
+
+Tada! That's all, we now have pagination implemented in our app!
\ No newline at end of file
diff --git a/src/routes/docs/tutorials/android/step-8/+page.markdoc b/src/routes/docs/tutorials/android/step-8/+page.markdoc
new file mode 100644
index 0000000000..335f57f5e9
--- /dev/null
+++ b/src/routes/docs/tutorials/android/step-8/+page.markdoc
@@ -0,0 +1,11 @@
+---
+layout: tutorial
+title: Next steps
+description: Learn to build an Android app with no backend code using an Appwrite backend.
+step: 8
+difficulty: beginner
+---
+
+# Test your project {% #test-your-project %}
+
+Run your project with **Run 'app'** button, or hit **Shift+F10** in Android Studio.
\ No newline at end of file
diff --git a/static/images/docs/tutorials/dark/recipewrite-collection-attributes.png b/static/images/docs/tutorials/dark/recipewrite-collection-attributes.png
new file mode 100644
index 0000000000..fd734e3841
Binary files /dev/null and b/static/images/docs/tutorials/dark/recipewrite-collection-attributes.png differ
diff --git a/static/images/docs/tutorials/dark/recipewrite-collection-indexes.png b/static/images/docs/tutorials/dark/recipewrite-collection-indexes.png
new file mode 100644
index 0000000000..18e2e7d979
Binary files /dev/null and b/static/images/docs/tutorials/dark/recipewrite-collection-indexes.png differ
diff --git a/static/images/docs/tutorials/dark/recipewrite-collection-permissions.png b/static/images/docs/tutorials/dark/recipewrite-collection-permissions.png
new file mode 100644
index 0000000000..83cd716833
Binary files /dev/null and b/static/images/docs/tutorials/dark/recipewrite-collection-permissions.png differ
diff --git a/static/images/docs/tutorials/recipewrite-asset-studio.png b/static/images/docs/tutorials/recipewrite-asset-studio.png
new file mode 100644
index 0000000000..31d87c6e0a
Binary files /dev/null and b/static/images/docs/tutorials/recipewrite-asset-studio.png differ
diff --git a/static/images/docs/tutorials/recipewrite-collection-attributes.png b/static/images/docs/tutorials/recipewrite-collection-attributes.png
new file mode 100644
index 0000000000..b97dd7be8d
Binary files /dev/null and b/static/images/docs/tutorials/recipewrite-collection-attributes.png differ
diff --git a/static/images/docs/tutorials/recipewrite-collection-indexes.png b/static/images/docs/tutorials/recipewrite-collection-indexes.png
new file mode 100644
index 0000000000..d16b8607a3
Binary files /dev/null and b/static/images/docs/tutorials/recipewrite-collection-indexes.png differ
diff --git a/static/images/docs/tutorials/recipewrite-collection-permissions.png b/static/images/docs/tutorials/recipewrite-collection-permissions.png
new file mode 100644
index 0000000000..1d95e90919
Binary files /dev/null and b/static/images/docs/tutorials/recipewrite-collection-permissions.png differ
diff --git a/static/images/docs/tutorials/recipewrite-empty-activity.png b/static/images/docs/tutorials/recipewrite-empty-activity.png
new file mode 100644
index 0000000000..4cc245db7b
Binary files /dev/null and b/static/images/docs/tutorials/recipewrite-empty-activity.png differ
diff --git a/static/images/docs/tutorials/recipewrite-new-project.png b/static/images/docs/tutorials/recipewrite-new-project.png
new file mode 100644
index 0000000000..b392b1bf0c
Binary files /dev/null and b/static/images/docs/tutorials/recipewrite-new-project.png differ
diff --git a/static/images/docs/tutorials/recipewrite-user-flow.png b/static/images/docs/tutorials/recipewrite-user-flow.png
new file mode 100644
index 0000000000..501a24d1af
Binary files /dev/null and b/static/images/docs/tutorials/recipewrite-user-flow.png differ