This post is a practical guide to merging in Git, covering what it actually does, when to use it, how it compares to rebase, and what to do when things go wrong.

What is a Merge, really? 🤨

In Git, merging is how you take changes from one branch and combine them into another.

git checkout main
git merge feature/login-page

This tells Git: “Take everything from feature/login-page and bring it into main.”

Behind the scenes, Git tries to find a common ancestor of the two branches, figures out the differences, and applies the changes. If nothing conflicts — you're golden.

Types of Merges

1. Fast-Forward Merge

Happens when the branch you're merging into is directly behind the other one. No actual “merge commit” is needed.

# main is behind feature
git checkout main
git merge feature

Result: main just moves its pointer forward. That’s it.

🔍 Tip: You can force Git to not fast-forward and create a merge commit:

git merge --no-ff feature

Useful for preserving the branch history explicitly.

2. Three-Way Merge

If the target branch has diverged, Git creates a merge commit. This is what you usually see in shared repos:

git checkout main
git merge feature
# creates a merge commit

This merge commit has two parents, connecting the branches.

A bit more on three-way merge in detail:

When you do a three-way merge in Git, it means the two branches you're trying to combine, for example, main and feature, have diverged. They’ve both had new commits since their common ancestor.

Git then performs a three-way comparison:

1. The common ancestor commits

2. The latest commit on main

3. The latest commit on feature

It uses these to generate a new commit that brings both branches together. This is the merge commit, and it has two parent commits: one from main, one from feature.

This merge commit acts as a clear record in the Git history that the two lines of development were combined at that point, preserving the full history of both branches. This is especially useful in collaborative projects, where seeing the origin of a feature or bugfix matters later on.

It’s the opposite of a fast-forward merge, which just moves the pointer forward and skips the merge commit because there was no divergence.

Merge 🆚 Rebase

What is Rebase (Really)?

git rebase lets you move the base of your current branch to a new starting point, usually to sync with the latest changes from another branch like main.

Instead of merging and creating a new commit that combines both histories (like git merge), rebase replays your commits one by one on top of the latest changes.

Example

Let’s say your branch history looks like this:

A---B---C  (main)
     \
      D---E---F  (feature)

You run:

git checkout feature
git rebase main

Now Git will:

1. Take your commits D, E, and F

2. “Replay” them on top of C (the latest on main)

Result:

A---B---C---D'---E'---F'  (feature)

Your feature branch is now cleaner and sits on top of main, as if you started from the latest main from the beginning.

Let’s clear this up ——— same goal, different methods:

Why Rebase?

• Keeps history clean and linear

• No extra merge commits

• Makes it look like your work was built on top of the latest code all along

Great for personal branches or PRs you haven’t pushed yet.

Handling Merge Conflicts 🧨

You’ll eventually hit this:

CONFLICT (content): Merge conflict in lib/ui.dart
Automatic merge failed; fix conflicts and commit the result.

Steps:

Git marks conflict areas like this:

<<<<<<< HEAD
code from current branch
=======
code from merging branch
>>>>>>> feature-branch

Manually fix the file.

# Stage it:
git add lib/ui.dart
# Complete the merge:
git commit

! You can also abort a merge entirely:

git merge --abort

Merge Strategy Options

Rarely used, but good to know:

• --strategy=recursive (default)

• --strategy=ours – Favor your branch in conflicts

• --strategy=theirs – Favor incoming branch (use with caution)

Example:

git merge feature --strategy=ours

Merge Workflows in Real Projects

🚀 Feature Branch Flow

• Devs create a feature branch

• Open PRs

• Merge to main (with --no-ff or via GitHub squash/merge)

This keeps main clean and stable.

📦 Release Branch Flow

• Merge main into release-v1.0

• Cherry-pick hotfixes into both main and release-v1.0

Merge vs Squash vs Rebase in PRs

On GitHub, you’ll see:

• Merge Commit: Keeps full branch history

• Squash and Merge: Combines all feature branch commits into one

• Rebase and Merge: Replays commits for linear history

Each has trade-offs. Squashing keeps history clean but loses individual commits. Rebase keeps order but changes hashes.

Merge Mistakes and How to Fix

1. Merged the wrong branch?

git reset HEAD~1

2. Conflict hell?

git merge --abort

Or nuke and pull fresh:

git reset --hard origin/main

3. Stuck in merge with uncommitted changes?

git stash
git merge branch

Here’s a complementary Git Cheat Sheet 🎀

Link 👈 to the original PDF in case these images don’t load.

Final Thoughts

Merging in Git isn’t rocket science…but it gets tricky fast when you're juggling branches, features, hotfixes, and multiple devs.

If you keep these things in mind:

• Know when to merge vs rebase

• Don’t fear merge conflicts, just learn to resolve them

• Use --no-ff to make merge history explicit

• And always keep your main branch clean and deployable

…you’ll be fine.

Got a Git horror story or a tip? Drop it in the comments.

Happy merging 👊

Thank you

Did you reach the bottom? Thank you for reading!

Feel free to connect with me. 👋

Over the last couple of years, I’ve built several MVPs using Flutter for mobile and React/Next.js for web. And after trying Firebase, Hasura, and even rolling my own Express APIs, I eventually settled into a rhythm with Supabase. ✨

Here’s why.

The Real Need: Fast, Flexible, and Reliable

As a solo dev or small team, I don’t want to spend weeks managing auth flows or spinning up a custom backend just to persist a list of data.

At the same time, I also want:

• Full control over data relationships

• SQL-style querying

• Auth with RLS (Row-Level Security)

• Built-in Realtime (for live lists, chats, etc.)

• A database I can export and query like a grown-up (Postgres)

Supabase hits that sweet spot.

The Stack I Usually Work With

• Frontend (Web): React + Next.js

• Frontend (Mobile): Flutter

• Backend: Supabase (Auth + Postgres + Realtime + Edge Functions)

• Deployment: Vercel (for Web), Play Store/TestFlight (for Flutter)

Let’s look at how Supabase fits into that, with a practical example.

Real Example: A Real-Time List App

Let’s say I’m building a “Live Guest List” web-app.

• Anyone can add their name to a shared list.

• The list updates in real time for all users.

• Items expire after 7 days.

With Supabase, the backend is almost entirely done out-of-the-box.

Backend: Supabase Setup

1. Database Table

We create a guests table in Postgres:

Set a policy to auto-delete rows after 7 days using PostgreSQL's ttl cron or a scheduled function (Supabase supports this).

2. Row-Level Security (RLS)

We enable RLS and create a simple policy:

-- Anyone can insert
create policy "Public insert" on guests
for insert
using (true);

3. Enable Realtime

Turn on "Realtime" for the guests table in the Supabase dashboard — this allows us to listen to any INSERT events and push updates to clients in real time.

Frontend (Next.js) – Live List Display

Let’s walk through how data flows, using a simplified version of my actual MVP.

The core hook is useListData.js, which:

• Fetches the initial list from Supabase

• Subscribes to real-time updates

• Updates the UI accordingly

import { useEffect, useState } from 'react';
import { supabase } from './supabase';

export function useListData() {
  const [list, setList] = useState([]);

  useEffect(() => {
    fetchInitial();

    const sub = supabase
      .channel('public:guests')
      .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'guests' }, (payload) => {
        setList((prev) => [payload.new, ...prev]);
      })
      .subscribe();

    return () => {
      supabase.removeChannel(sub);
    };
  }, []);

  async function fetchInitial() {
    const { data } = await supabase.from('guests').select('*').order('created_at', { ascending: false });
    setList(data);
  }

  return list;
}

In the page.js file (or [id].js in Next’s route), we simply call useListData() and map it to components like NamesList.jsx.

The beauty is: no need to manage sockets yourself. Supabase handles it.

Here’s the full version of my MVPs data flow:

No Firebase Firestore triggers, no polling. Just clean Postgres + WebSocket events.

You can check out its GitHub and live hosted link.

Firebase vs Supabase: In the MVP World

Firebase is great for:

• Fast auth integration

• Push notifications (out-of-the-box with Firebase Messaging)

• Small prototypes that don’t need relational querying

But here’s where it didn’t scale for my use:

• No SQL: Firestore’s querying is shallow. Deep filters or joins get messy fast.

• Pricing surprises: You get billed per read — real-time features spike usage.

• Data modeling: Firestore pushes you into NoSQL patterns, which are harder to maintain if your schema grows.

What Supabase Gets Right

✅ Postgres, not NoSQL
I can design my schema like I would in a production app. Joins, indexes, foreign keys — everything works as expected.

✅ Row-Level Security
Secure your app directly in SQL. No extra backend logic needed.

✅ Realtime Built-In
Turn it on per table. No extra infra or Firebase-style "watchDocument" logic.

✅ One SDK, Multi-Platform
Supabase works equally well in web and mobile. You can even use it from a server or CLI tool.

✅ Edge Functions
Need to send an email or call an external API? Edge functions make it easy — no extra backend server required.

✅ Self-Hosting Option
If I need to move off Supabase for compliance or scaling, I can take the whole stack with me. It’s just Postgres + some open-source tooling.

What Could Be Better

🔸 Built-in Push Notifications
Firebase handles push with FCM. Supabase doesn’t have this out of the box — you’ll need to integrate a service like OneSignal or Firebase Cloud Messaging separately.

🔸 Docs for Advanced Features
Sometimes edge cases (especially around auth + RLS + Realtime) need digging through GitHub issues to fully understand.

Final Thoughts

Supabase is not just a Firebase alternative — it’s a solid choice in its own right, especially if you come from a SQL background or want more control over your backend.

For MVPs, it removes the need to spin up a server or write repetitive boilerplate just to handle auth or data.

For production apps, it’s robust enough to grow with you — and flexible enough to take with you if you ever need to scale out.

If you're building apps with Flutter or React/Next.js and want a backend that handles real-time data, secure auth, and doesn’t get in your way — Supabase is worth your time.

Thank you

Did you reach the bottom? Thank you for reading!

Feel free to connect with me. 👋

There are three types of shortcuts in Android that can be implemented in Flutter: static, dynamic, and pinned. You can read more about these shortcuts in the Android documentation by clicking here.

In this article, we are going to create pinned shortcuts in Flutter. We will see this example for the use case where we'll launch a different screen if clicked on the pinned shortcut instead of the home screen, which opens by default in the app.

As there is no direct provision for creating pinned shortcuts in Flutter, we are going to use native bridge (platform channels) between Flutter and Android Native to establish two-way communication. I'll not be going in depth on the creation of platform channels for data transfer, but you can see the full approach with code in my previous article here.

Note that I'll be using Kotlin as my native Android language.

Approach

1. Establish a native bridge between Flutter and Android.

2. Send an identifier from Flutter to Android.

3. Create a pinned shortcut using the previous identifier.

4. Send a call back to Flutter if the pinned shortcut is clicked.

5. Inflate a screen using that callback in Flutter.

Steps in detail

Step 0: Project starting point

Before creating any pinned shortcuts, we will essentially create a starting point. Click here for the initial code I will be using. Don't worry if you do not want to fork the repository; its lib folder only has the files main.dart and home.dart.

The main.dart file contains the basic structure of the MaterialApp.

The home.dart files contain the HomeScreen widget, which has a button whose onTap takes users to an AnotherScreen widget with plain text; onLongPress is currently an empty function.

Step 1 & 2: Create platform channels and send an identifier

To determine which screen to open, we will transfer a string using a native bridge that connects Flutter and Android. You can use any type of identifier, such as a string, integer, or bool, based on your use case. Although we only have one screen at the moment, sending distinct identifiers when making distinct pinned shortcuts is crucial to determining what action should happen when a given shortcut is clicked.

We'll be manipulating MainActivity.kt and home.dart files in order to do this.

In MainActivity.kt, we'll write a method channel to receive the information that is passed from Flutter. It is done by overriding the configureFlutterEngine function to receive the data and creating a function to actually use that data to create a pinned shortcut. For now, we'll use the getNativeData function just to return the data we received.

Also, we will create a NativeBridge class in the home.dart file to transfer the data to the Kotlin file. In the onLongPress method call, don't forget to call the getNativeData method to send string data to Android by writing NativeBridge.getNativeData('Another Screen'). Here, "Another Screen" string will act as our identifer.

This causes the console to display a print log statement that reads, "From Native: Another Screen." This indicates that, up until now, everything has been going well.

Click here to get the complete source code up to this point.

Step 2.5: Adding some additional files

There are some other things that you might want to do if something doesn't work. The first is adding dependencies to app/build.gradle.

Another thing you should do is add a png file to the drawable folder in the android/app/src/main/res/ folder so that it can be used as the shortcut's icon. I've used this file.

Step 3 & 4: Create a pinned shortcut

We'll be creating Shortcuts.kt, and changing MainActivity.kt a little bit to create pinned shortcuts.

In Shortcuts.kt, we're doing two things. First is creating an actual shortcut item by passing a shortcut name to setShortLabel, a short description to setLongLabel, and an icon to setIcon, these will be sent to ShortcutInfo.Builder. We'll use the icon image we've put in the drawable/ folder.

The second thing is sending the identifier string back to MainActivity.kt using intent.putExtra, which will be later used to send a callback to Flutter.

After this, we will change the MainActivity.kt to call the setUp function in the Shortcuts.kt. Here, I've changed the method name from getNativeData to sendNativeData and created another getNativeData to reflect a better naming convention from the Flutter perspective.

sendNativeData gets the data that is sent from Flutter and uses it to create pinned shortcuts by first calling the Shortcuts.setUp function and then calling the shortcutPin function for the shortcutManager initialization. getNativeData basically sends the callback to Flutter with the identifier screenNames.

Here I've created screenNames as a mutable list, but you can also create it as a string because, at the end, we're fetching the callback data with the help of screenNames[0].

Because FlutterActivity runs before onCreate, it should also be noted that intent.extras is called in FlutterActivity and not in onCreate. The original data that is associated with that specific pinned shortcut is stored in the intent.extras variable before being saved in the screenNames variable.

Step 5: Inflate another screen

To accommodate two functions, we will now modify the home.dart file. sendNativeData, which will only send string data, and getNativeData, which will receive the callback from Android and have the screen launch code.

Note that onLongPress has been changed to NativeBridge.sendNativeData('Another Screen'), and we'll need to call the NativeBridge.getNativeData(context); function just before the return Scaffold statement to get the callback and do the necessary actions.

Now, if you long press on the button in the app, it will prompt you to create a pinned shortcut with the name "Another Screen" and it'll be placed on the mobile home screen. After you terminate the app, clicking on that shortcut from the home screen will take you to the AnotherScreen.

You now know how to create pinned shortcuts in Flutter. If you require the full source code of the project, you can click here. It also contains an additional feature, which is to send a dynamic image for the shortcut icon from Flutter.

Thank you

Did you reach the bottom? Thank you for reading!

Feel free to connect with me. 👋

We will look at how to create a native bridge between Flutter and Android Native (Kotlin) in this article. I will make this brief and straight to the point.

It should be noted that this bridge will transfer integer data from Flutter to Android and string data from Android to Flutter, but you can use this to transfer other data as well.

Building Native Bridge

One-way communication

1. Build a native bridge in Flutter

   1. Add services.dart import

       import 'package:flutter/services.dart';
      

   2. Add NativeBridge class

       class NativeBridge {
         static const MethodChannel _channel = MethodChannel('com.example/native');
      
         static void getNativeData() async {
           await _channel.invokeMethod('getNativeData').then((value) => print(value));
         }
       }
      

      First, we are going to create a NativeBridge class in which we will write our connection code. The bridge in the native code will be identified by the same name that we are using to create a static MethodChannel. The getNativeData method in our Kotlin file will be called by the static method getNativeData(), which will then print the log statement.

   3. Call getNativeData() method

       NativeBridge.getNativeData();
      

      Call the static method getNativeData() anywhere sensible in your Dart code.

2. Connect it's counterpart in MainActivity.kt

   1. Add necessary imports

       import io.flutter.embedding.engine.FlutterEngine
       import io.flutter.plugin.common.MethodChannel
      

   2. Add this code snippet to MainActivity class

       private val CHANNEL = "com.example/native"
      
           override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
               super.configureFlutterEngine(flutterEngine)
               MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler {
                   call, result ->
                   if (call.method == "getNativeData") {
                       val data = getNativeData()
                       result.success(data)
                   } else {
                       result.notImplemented()
                   }
               }
           }
      
           private fun getNativeData(): String {
               // Implement your native code logic here
               return "Native Data from Android"
           }
      

      The CHANNEL name in this case needs to match the MethodChannel name in our dart file in order to connect the two channels. For the purpose of determining which method to execute, we now write a simple if-check statement and then execute the required method.

3. Final code files for one-way communication between Flutter and Android

   • main.dart

       // ignore_for_file: avoid_print
     
       import 'package:flutter/material.dart';
       import 'package:flutter/services.dart';
     
       void main() => runApp(const MyApp());
     
       class MyApp extends StatelessWidget {
         const MyApp({super.key});
     
         @override
         Widget build(BuildContext context) {
           return MaterialApp(
             title: 'My App',
             theme: ThemeData(
               colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
               useMaterial3: true,
             ),
             home: const HomePage(),
           );
         }
       }
     
       class NativeBridge {
         static const MethodChannel _channel = MethodChannel('com.example/native');
     
         static void getNativeData() async {
           await _channel.invokeMethod('getNativeData').then((value) => print(value));
         }
       }
     
       class HomePage extends StatelessWidget {
         const HomePage({super.key});
     
         @override
         Widget build(BuildContext context) {
           NativeBridge.getNativeData();
     
           return Scaffold(
             appBar: AppBar(
               backgroundColor: Theme.of(context).colorScheme.inversePrimary,
               title: const Text('My App'),
             ),
             body: const Center(
               child: Text('data'),
             ),
           );
         }
       }
     

   • MainActivity.kt

       package com.example.bridge
     
       import io.flutter.embedding.android.FlutterActivity
       import io.flutter.embedding.engine.FlutterEngine
       import io.flutter.plugin.common.MethodChannel
     
       class MainActivity: FlutterActivity() {
           private val CHANNEL = "com.example/native"
     
           override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
               super.configureFlutterEngine(flutterEngine)
               MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler {
                   call, result ->
                   if (call.method == "getNativeData") {
                       val data = getNativeData()
                       result.success(data)
                   } else {
                       result.notImplemented()
                   }
               }
           }
     
           private fun getNativeData(): String {
               // Implement your native code logic here
               return "Native Data from Android"
           }
       }
     

Here, we have managed to successfully create a one-way connection between Android and Flutter. In this case, a log statement stating "Native Data from Android," which is coming from Android to Flutter, is printed when the app runs.

Two-way communication

• Two-way communication can be achieved by adding a few data type parameters to _channel.invokeMethod and making minor adjustments to getNativeData method. The finished Dart and Kotlin files are below.

  • main.dart

      // ignore_for_file: avoid_print
    
      import 'package:flutter/material.dart';
      import 'package:flutter/services.dart';
    
      void main() => runApp(const MyApp());
    
      class MyApp extends StatelessWidget {
        const MyApp({super.key});
    
        @override
        Widget build(BuildContext context) {
          return MaterialApp(
            title: 'My App',
            theme: ThemeData(
              colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
              useMaterial3: true,
            ),
            home: const HomePage(),
          );
        }
      }
    
      class NativeBridge {
        static const MethodChannel _channel = MethodChannel('com.example/native');
    
        static void getNativeData(int num) async {
          await _channel.invokeMethod('getNativeData', <String, int>{
            "num": num,
          }).then((value) => print(value));
        }
      }
    
      class HomePage extends StatelessWidget {
        const HomePage({super.key});
    
        @override
        Widget build(BuildContext context) {
          int i = 0;
    
          return Scaffold(
            appBar: AppBar(
              backgroundColor: Theme.of(context).colorScheme.inversePrimary,
              title: const Text('My App'),
            ),
            body: Center(
              child: ElevatedButton(
                onPressed: () {
                  NativeBridge.getNativeData(++i);
                },
                child: const Text('Click me'),
              ),
            ),
          );
        }
      }
    

  • MainActivity.kt

      package com.example.bridge
    
      import io.flutter.embedding.android.FlutterActivity
      import io.flutter.embedding.engine.FlutterEngine
      import io.flutter.plugin.common.MethodChannel
    
      class MainActivity: FlutterActivity() {
          private val CHANNEL = "com.example/native"
    
          override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
              super.configureFlutterEngine(flutterEngine)
              MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler {
                  call, result ->
                  if (call.method == "getNativeData") {
                      if (!call.hasArgument("num")) {
                          result.error("MissingArgumentError", "You must provide num parameter", null)
                      }
                      val num: Int = call.argument<Int>("num")!!
                      val data = getNativeData(num)
                      result.success(data)
                  } else {
                      result.notImplemented()
                  }
              }
          }
    
          private fun getNativeData(num: Int): String {
              // Implement your native code logic here
              return "From Native: $num"
          }
      }
    

Here, we have successfully created a two-way communication channel between Flutter and Android. When we click the on-screen button, we send integer data to Android and receive a different string each time (in the form of a log statement).

The complete project source code for the one-way and two-way communication codes is maintained commit-wise; you can view it by clicking this link.

Thank you

Did you reach the bottom? Thank you for reading!

Feel free to connect with me. 👋

As a busy individual constantly juggling multiple responsibilities, I understand the struggle of staying on top of tasks and deadlines. That's why I'm thrilled to share my journey of building Taskaro with you. Hey there! My name is Anant, and in this article, we'll delve into how Taskaro came to be and explore its ins and outs.

Taskaro is built upon the principles of the Eisenhower matrix, with a simple yet powerful purpose — to help individuals like myself reclaim control over their busy lives. In today's fast-paced world, the demands and responsibilities can quickly become overwhelming. Whether you're a student with assignment deadlines, a professional managing numerous projects, or a homemaker handling household chores, Taskaro is designed to be your trusted companion, ensuring you never miss a beat. Taskaro empowers you to effortlessly organize, prioritize, and execute tasks, allowing you to navigate through your responsibilities with ease.

Problem Statement

Have you ever found yourself overwhelmed by a lengthy list of tasks that require completion, each with varying levels of importance, urgency and different deadlines? It can be quite challenging to determine which task to prioritize, resulting in confusion and anxiety. Recognizing the significance of undertaking the right task at the right time cannot be emphasized enough.

This is precisely why this app came into existence and the vision behind it drove its development. In a nutshell, this app can be described as a tool that simplifies the complexities of everyday life.

Existing solutions in the market have their limitations. Traditional to-do lists or basic task management apps often lack a comprehensive approach to organizing tasks. Some existing apps may have a steep learning curve or an overwhelming interface, limiting their accessibility to a wide range of users.

The Application

Working

Taskaro organizes its home screen into four distinct sections: "Do it," "Schedule it," "Delegate it," and "Delete it." As the names imply, tasks placed within each section should be approached accordingly.

Distinguishing itself from typical to-do list applications, Taskaro incorporates a simple yet sophisticated algorithm that assesses task priorities and categorizes them accordingly. This backend functionality enables the application to determine which tasks require immediate attention and which ones can be postponed without compromising overall productivity.

The app relies on two inputs from users to prioritize tasks: Urgency and Importance. When entering a task, users indicate whether it is urgent and/or important. Based on this information, Taskaro assigns a priority to the task accordingly.

On the technical side, Taskaro is built using Java and developed in Android Studio by leveraging Firebase as its backend infrastructure.

Features and Functionality

Login/Signup: Users can log in or sign up on the app, ensuring the security of their data on the online server, which they can retrieve whenever they wish.

Task Prioritization: One of Taskaro's key features is its task prioritization functionality. When a user enters multiple tasks into the app, Taskaro automatically categorizes them into four distinct groups based on different priorities. This is achieved through colour coding and prompt headings. By doing so, Taskaro encourages users to focus on tasks that are both urgent and important, while leaving tasks that are neither urgent nor important to be addressed later or possibly deleted.

Note Taking: Taskaro offers a simple and minimalist note-taking feature. Users can conveniently enter and store notes within the same application system as their tasks. The notes feature allows users to add, edit, and delete notes as needed, providing a practical way to keep important information alongside their tasks.

User Profile: Taskaro includes a user profile screen, where users can easily personalize their accounts. Users can set a profile photo and make changes to their names if they were initially entered incorrectly. The profile screen also provides the option to log out of the app. If desired, users can delete their profiles, resulting in the deletion of their data, tasks, and notes from the app.

User Interface & Experience

The app starts with onboarding screens to familiarize the user with its purpose. Subsequently, users are prompted to either login or sign up using their email address.

Upon successful login, users can explore every section of the app through the bottom navigation bar. The bar comprises the home screen, notes screen, and user profile screen.

The bottom navbar also includes a floating action button. Clicking it on the home screen creates a new task, while on the notes screen, it creates a new note.

The home screen organizes tasks into different sections, each colour-coded for easier browsing and workflow.

The notes and user profile screens consist of a minimalistic and soothing appearance.

Taskaro incorporates Material 3 design components, utilizes the Inter font family, and maintains a side margin of 20dp throughout the app.

The app's front end is created using Figma, taking into consideration various UI principles and UX laws to enhance user navigation. Click here 👈 to view app screens on Figma.

Any feedback on the app would be greatly appreciated! 🙏

How to Use the App

1. Taskaro is only available for Android devices and can be downloaded either from GitHub or by clicking here👈 for a direct download.

2. To begin using the app, simply sign up.

3. Once signed in, you will be directed to the home screen, where you can create a task by clicking on the plus button.

4. Explore the app through the bottom navigation bar. 🚀

Benefits

By utilizing this app and adhering to the task order provided, you can tackle the tasks that have a significant impact on your overall productivity and life. As the saying goes, "Eat the biggest frog first 🐸", prioritize the larger tasks that require the most effort at the start of your day. Taskaro is designed to assist you in accomplishing precisely that.

If you follow the recommended task sequence within different sections, your day will become more productive and efficient. Tasks marked for deletion can be completed towards the end of the list, or they can be eliminated 🚮, as they will have minimal to no impact on your productivity.

Resources

Here are some resources that I utilized:

• Material Design

• DrawKit

• Freepik

• icons8

Future Updates

Roadmap for the upcoming features and improvement:

1. Notifications: Implement a notification system to alert users about their pending tasks.

2. Edit task: Allow users to make edits to their tasks even after saving them.

3. Google login: Enable users to conveniently sign up and log in using their Google accounts.

4. Offline data storage: Implement offline data storage capability, allowing users to access and sync their data when an internet connection is unavailable.

5. Data encryption: Enhance security by encrypting user data stored in the online cloud storage.

6. Enhanced UI/UX: Improve the app's user interface and experience to ensure easy navigation and a seamless user journey.

7. Analytics screen: Provide users with an analytics screen where they can gain insights into their task patterns, time allocation, and other relevant metrics.

My ultimate vision for the app is to transform it into one of the most accessible open-source task prioritization tools, widely used by students, professionals, and individuals from diverse backgrounds.

I highly value your feedback and encourage you to share your thoughts in the comments section or on the GitHub page. Your feedback will help improve the app further.

Also, I greatly appreciate any contributions made to enhance the usability of the app. You can contribute in various ways:

• Open issues: Identify and report any bugs, suggest improvements, or request changes by creating new issues on GitHub.

• README pages: Contribute by creating informative README pages on topics such as contributions, licenses, or any other relevant areas. You can also enhance existing README pages to provide better documentation.

• Bug fixes and UI enhancements: Help improve the app by fixing bugs, enhancing the user interface, or integrating suggested changes.

• Translation: Contribute by translating the app into different languages, making it more accessible to users worldwide.

• Feature integration: Implement any of the above-mentioned features in the app.

• GitHub page maintenance: You can also assist in maintaining the GitHub page, keeping it up to date with the latest information and improvements.

Any other contributions you may have in mind are welcome. Your support and contributions are highly valued and will contribute to making the app even better.

My Journey

Problems I Faced

1. Overwhelmed with Complexities and Lack of Knowledge: Having a background solely in development and lacking knowledge in designing and managing an extensive app, I was uncertain where to start. To overcome this, I adopted a systematic approach, breaking down the process into manageable tasks and focusing on one component at a time. I actively sought resources such as online tutorials, developer forums, and documentation. I also reached out to experienced professionals on platforms like Twitter and Discord.

2. Integrating Features: My goal was to provide a modern and intuitive user interface by implementing the latest design principles, such as Material Design 3. However, integrating these design elements and ensuring a seamless user experience presented their own set of challenges. Additionally, incorporating functionalities like a runnable class for recurring tasks or background services for notifications required careful implementation and thorough testing. Through experimentation, iteration, and testing, I successfully integrated some of these features, while others are still pending.

3. Managing My Team: While developing Taskaro, I also encountered the challenge of managing a small team of developers. Coordinating efforts, assigning tasks, and ensuring effective communication were vital to maintaining productivity and achieving project milestones. Regular team meetings, progress tracking, and open channels of communication helped with this.

4. Managing Deadlines: Balancing multiple responsibilities and ensuring the timely completion of tasks posed a significant challenge. To manage deadlines effectively, I employed project management techniques, such as creating a detailed timeline, breaking down tasks into smaller subtasks with their respective deadlines, and regularly monitoring progress. Tools like Todoist and Slack helped me achieve this.

5. GitHub Workflow: Developing Taskaro involved implementing an efficient GitHub workflow with a team and effectively managing the source code, both of which were crucial. Initially, I encountered difficulties in establishing a clear workflow. But I started learning and adopting best practices, seeking guidance from experienced individuals. This enabled me to effectively manage the expanding codebase. I also implemented coding standards and started with regular code reviews to ensure code quality and consistency.

My Learnings

1. Searching for Solutions: One of the most valuable lessons I learned during my development journey was how to effectively find solutions. I faced numerous challenges that demanded my ability to seek answers. Here are some approaches that proved helpful:

   1. Online Resources: I found great value in seeking developer forums, coding communities, and technical documentation to find solutions. Websites such as Stack Overflow, GitHub, and official documentation were very useful.

   2. Online Tutorials: I greatly benefited from online tutorials and different YouTube videos when dealing with complex issues and bugs.

2. Debugging Techniques: When faced with errors or unexpected behaviour during the app development process, I employed the following methods to identify and resolve issues:

   1. Logging: To track the execution flow and pinpoint potential problems, I strategically inserted log statements at crucial points in the code. By analyzing the logs, I was able to narrow down the source of the problem.

   2. Divide and Conquer: When dealing with complex issues, I broke down the problem into smaller, manageable parts and isolated the specific issue. This method helped me narrow down and focus on the problem at hand.

3. Collaboration and Communication: This played a vital role in the development of Taskaro. I scheduled regular meetings with the development team to discuss progress, challenges, and next steps. These meetings provided a platform for exchanging ideas, clarifying requirements, and aligning our efforts.

4. UI/UX development: Creating an intuitive and visually appealing user interface (UI) was my key focus. Here are some practices I followed for UI/UX development:

   1. User Research: I conducted user research to understand the preferences, colour theory, and pain points of the audience. This research informed the design decisions, ensuring the UI met user expectations.

   2. Consistency and Simplicity: I aimed for a consistent and simple UI design throughout Taskaro. By using a cohesive colour palette, typography, and layout, I created a visually harmonious experience.

5. How to Seek Help: You'll not get help if you don't ask for it, and there is no shame in doing so. I learned the following best practices when seeking assistance:

   1. Research First: Before asking for help, I made sure to conduct thorough research on the issue. By showing that I had already attempted to find a solution, I increased the likelihood of receiving help and avoided duplicating efforts.

   2. Be Specific and Clear: When asking for help, I provided detailed information about the problem, including error messages, relevant code snippets, and steps to reproduce the issue. Clear communication helped others understand the problem and provide targeted assistance.

   3. Show Respect: When seeking help on online forums or communities, I followed the guidelines and rules of the community. I maintained a respectful attitude, displayed patience, and expressed gratitude for any support I received.

My Future Goals

One of the goals is to keep enhancing this app and making it even more useful.

Here are some other future goals:

• Develop additional Android apps incorporating various technologies.

• Learn JavaScript and create web apps.

• Expand understanding of team management and explore related areas.

• Produce more technical blog posts.

Conclusion

In conclusion, Taskaro is the result of my journey to address the challenges of managing tasks and deadlines in today's fast-paced world. It is a tool designed to simplify the complexities of everyday life, helping users prioritize tasks and maximize their productivity.

Through the development process, I faced various challenges, however, I learned valuable lessons along the way, including the importance of seeking solutions, effective collaboration and communication.

I greatly value your feedback and contributions to enhance the app further.

Thank you

Did you reach the bottom? Thank you for reading!

Feel free to connect with me. 👋

In this article, we will explore how to build a CRUD (Create, Read, Update, Delete) application using MongoDB and Python. We will start by discussing what a CRUD application is and why it is useful. Then, we will look at the technologies we will be using to build our application, namely MongoDB and Python. After that, we will dive into the step-by-step process of building our CRUD application.

Understanding CRUD Applications

A CRUD application is a type of software application that allows users to perform four basic operations on a dataset: create, read, update, and delete. These four operations correspond to the acronym CRUD.

CRUD applications are useful because they allow users to easily manipulate and interact with data. They are commonly used in web applications, content management systems, and other data-driven software.

Technologies Used

In this tutorial, we will be using two technologies to build our CRUD application: MongoDB and Python.

MongoDB is a popular NoSQL database that is well-suited for storing and managing large amounts of unstructured or semi-structured data. It is known for its ease of use and scalability.

Python is a popular programming language that is often used for web development, data analysis, and scientific computing. It is easy to learn and has a large and active community.

Setting Up the Environment

Before we start building our CRUD application, we need to set up our environment. This involves installing and configuring MongoDB and Python.

Installing MongoDB

To install MongoDB, follow these steps:

1. Go to the MongoDB website and download the appropriate version for your operating system.

2. Follow the installation instructions provided by MongoDB.

Installing Python

To install Python, follow these steps:

1. Go to the Python website and download the appropriate version for your operating system.

2. Follow the installation instructions provided by Python.

Building the CRUD Application

Now that our environment is set up, we can start building our CRUD application. We will be using Python and the PyMongo library to interact with MongoDB.

Creating a Connection to MongoDB

To start, we need to create a connection to our MongoDB instance. We can do this using the following code:

from pymongo import MongoClient

client = MongoClient('localhost', 27017)
db = client['mydatabase']

This code creates a connection to a MongoDB instance running on the local machine on port 27017. It also creates a database called "mydatabase".

Creating the Data Model

Next, we need to define the data model for our application. In this example, we will be creating a simple data model for storing information about books.

book = {
    'title': 'The Great Gatsby',
    'author': 'F. Scott Fitzgerald',
    'published_date': '1925-04-10'
}

This code defines a dictionary that represents a book. It has three fields: title, author, and published_date.

Inserting Data into MongoDB

Now that we have defined our data model, we can insert some data into MongoDB. We can do this using the following code:

result = db.books.insert_one(book)
print(result.inserted_id)

This code inserts a single book into the "books" collection in our MongoDB database. It then prints the ID of the inserted document.

Retrieving Data from MongoDB

Next, we can retrieve data from MongoDB using the following code:

result = db.books.find_one({'title': 'The Great Gatsby'})
print(result)

This code retrieves the first document from the "books" collection where the title field matches "The Great Gatsby". It then prints the result to the console.

Updating Data in MongoDB

To update data in MongoDB, we can use the update_one() method. For example, to update the published date of a book, we can use the following code:

query = {'title': 'The Great Gatsby'}
new_values = {'$set': {'published_date': '1925-04-11'}}
result = db.books.update_one(query, new_values)
print(result.modified_count)

This code updates the published date of the book with the title "The Great Gatsby" to "1925-04-11". It then prints the number of documents that were modified (which should be 1 in this case).

Deleting Data from MongoDB

To delete data from MongoDB, we can use the delete_one() method. For example, to delete a book from the "books" collection, we can use the following code:

result = db.books.delete_one({'title': 'The Great Gatsby'})
print(result.deleted_count)

This code deletes the first document from the "books" collection where the title field matches "The Great Gatsby". It then prints the number of documents that were deleted (which should be 1 in this case).

Conclusion

In this article, we have explored how to build a CRUD application using MongoDB and Python. We started by discussing what a CRUD application is and why it is useful. Then, we looked at the technologies we would be using to build our application, namely MongoDB and Python. We then walked through the step-by-step process of building a CRUD application, including creating a connection to MongoDB, defining a data model, and inserting, retrieving, updating, and deleting data.

By following this tutorial, you should now have a good understanding of how to build a CRUD application using MongoDB and Python.

Thank you

Did you reach the bottom? Thank you for reading!

👋 Hello again! Feel free to connect with me here: Anant's socials