DEV Community: Karan Singh Gurjar

Building CogniPlan: A Local-First Task Planning System

Karan Singh Gurjar — Fri, 22 May 2026 16:35:53 +0000

Hi everyone,

In my previous post, I introduced myself and shared the major projects I am working on across AI/ML research, Flutter apps, Rust systems, and local-first software.

In this post, I want to go deeper into one of my personal software projects:

CogniPlan — A Local-First Cognitive Task Planning System

CogniPlan is a productivity and planning system I built to help users convert goals into structured execution plans.

Project repository:

https://github.com/karansinghgurjar/Cognitive-Task-Planning-System

The project includes installable builds, including an Android APK and a Windows installation package, so it is not only a concept or prototype. It is something I have actually built, packaged, and pushed publicly.

Why I Built CogniPlan

The idea started from a problem I personally faced.

Most task management apps help you store tasks, but they do not always help you execute them properly.

You can create goals, add tasks, set reminders, and still lose track after a few days.

Some common problems are:

tasks pile up
missed work is not handled properly
goals are disconnected from daily execution
routines are difficult to maintain
progress is not clearly visible
planning becomes separate from actual work
users keep reorganizing instead of executing

I wanted to build something that goes beyond a normal to-do list.

A system that does not only answer:

What do I need to do?

But also helps answer:

How do I actually execute this consistently?

That became the foundation for CogniPlan.

What CogniPlan Does

CogniPlan is designed around structured execution.

It helps organize work into:

goals
milestones
tasks
routines
focus sessions
schedules
progress tracking
missed-task recovery
productivity insights

Instead of treating every task as an isolated item, CogniPlan connects tasks with larger goals and execution timelines.

For example, a user can create a goal like:

Prepare for data engineering interviews

Then break it into milestones like:

SQL revision
Python practice
operating system basics
DBMS concepts
project explanation preparation
mock interview sessions

Each milestone can then have tasks, schedules, and focus sessions attached to it.

This makes the planning process more connected and useful.

Why Local-First Matters

One of the most important design decisions in CogniPlan is that it is local-first.

Productivity data is personal. A user’s goals, routines, tasks, notes, schedules, and progress should not become useless just because the internet is unavailable.

A local-first approach gives the app several benefits:

faster access
offline usage
better privacy
better reliability
less dependency on cloud services
smoother user experience

For this kind of app, I wanted the core experience to work directly on the user’s device.

Cloud sync can be useful later, but the base system should remain reliable even without it.

Tech Stack

CogniPlan is built mainly with:

Flutter
Dart
Riverpod
Isar
Local-first architecture
Cross-platform app structure

Flutter helped me build the UI and target multiple platforms from a single codebase.

Riverpod helped with state management and app structure.

Isar helped with local database storage and offline-first behavior.

The goal was not only to build a working app, but to build it in a way that can grow as the project becomes more advanced.

Main Features

Goal Planning

Users can create larger goals and connect them with milestones and tasks.

This makes the app more structured than a simple task list.

Task Management

Tasks can be created, updated, completed, reset, or reorganized based on the user’s planning needs.

Routines

Recurring work can be managed through routines.

This is useful for daily study, revision, workouts, coding practice, reading, or any repeated activity.

Focus Sessions

Focus sessions help connect planning with actual execution.

Instead of only listing work, the user can track focused time spent on tasks.

Adaptive Scheduling

One of the ideas behind CogniPlan is that planning should adapt when things go wrong.

If a user misses a session or task, the system should help recover the plan instead of simply leaving the user with a broken schedule.

Productivity Insights

The app can show progress and help users understand how consistently they are executing their plans.

This is important because productivity is not only about writing tasks. It is also about seeing whether the system is actually helping.

Packaging the App

One thing I specifically wanted was to make the project more complete than just source code.

So I pushed the project with installable builds:

Android APK
Windows installation package
Source code
Project documentation

This made the project feel closer to a real software product.

Repository:

https://github.com/karansinghgurjar/Cognitive-Task-Planning-System

For me, this was an important step because a project becomes much stronger when someone can not only read the code, but also install and test the application.

Design Thinking Behind CogniPlan

While building CogniPlan, I tried to think less like I was building just an app screen and more like I was building a workflow system.

Some questions I asked myself were:

What happens when the user misses a task?
How should a goal connect to daily work?
How can routines be useful without becoming annoying?
How can the app reduce planning friction?
How can progress be shown clearly?
How can the app remain useful without internet?
How can the user move from planning to execution quickly?

These questions shaped the direction of the project.

A productivity app should not only look good. It should reduce mental load and make execution easier.

Challenges I Faced

Building CogniPlan taught me that productivity apps are more complex than they look.

Some challenges I faced were:

designing a clean data model
handling goals, tasks, routines, and progress together
avoiding messy state management
managing local database updates safely
keeping the UI simple
thinking through missed-task recovery
making the app useful instead of overloaded
planning for cross-platform support
packaging the app for Android and Windows

One important lesson was that adding more features does not automatically make a productivity app better.

The hard part is deciding what should be included, what should be simplified, and what should not be added yet.

What I Learned

This project helped me improve in several areas:

Flutter app development
local-first architecture
state management
database modeling
product thinking
workflow design
cross-platform planning
user experience design
debugging and project structure
release packaging

It also helped me understand that real software projects require both technical and product-level thinking.

Writing code is only one part of the work.

The bigger challenge is designing something that remains useful, understandable, and reliable.

Why CogniPlan Matters to Me

CogniPlan is personal to me because I built it around problems I actually face.

As a student working on research, software projects, interview preparation, and personal learning, I needed a system that could help me manage execution better.

So this project is not just a portfolio project.

It is also something I want to use and improve for myself.

That makes it more meaningful.

What I Want to Improve Next

Some areas I want to improve in future versions are:

better adaptive scheduling
cleaner analytics
stronger routine handling
sync support
backup and restore
improved desktop experience
better onboarding
smarter planning suggestions
more polished UI/UX

I also want to keep the app practical instead of making it unnecessarily complex.

The main goal is still the same:

Help users plan better and execute consistently.

Final Thoughts

CogniPlan started as a task planning app, but it became much more than that.

It helped me think about how goals, tasks, routines, focus sessions, and schedules can work together as one execution system.

This project also made me stronger as a Flutter developer and helped me understand the value of local-first software.

You can check out the project here:

https://github.com/karansinghgurjar/Cognitive-Task-Planning-System

In future posts, I will share more about the architecture, database design, scheduling logic, and lessons I learned while building it.

Thanks for reading.

If you are interested in Flutter, productivity tools, local-first apps, or personal workflow systems, I would be happy to connect.

Connect With Me

Portfolio: https://karansinghgurjar.github.io/ksg_portfolio/
GitHub: https://github.com/karansinghgurjar
LinkedIn: https://www.linkedin.com/in/karan-singh-gurjar-052b30197/
Twitter/X: https://x.com/karan_gurjar08

Building AI Projects

Karan Singh Gurjar — Mon, 18 May 2026 12:39:04 +0000

Hi everyone, I’m Karan Singh Gurjar, an M.Tech Computer Science Engineering student interested in AI/ML research, software development, and building practical systems that solve real problems.

I recently joined DEV to start documenting my work, sharing my learning process, and connecting with developers, researchers, and builders who are working on meaningful technical projects.

Over the past few years, I have worked on projects across machine learning, research, cross-platform app development, and systems engineering. Some of my major works include SAR to RGB image translation, bird sound classification, CogniPlan, and MeshOS / AetherLink.

1. SAR to RGB Image Translation using Diffusion Models

One of my major research projects is focused on SAR to RGB image translation.

SAR stands for Synthetic Aperture Radar. Unlike normal optical images, SAR images are captured using radar signals. This makes them useful in cloudy weather, low light, and difficult atmospheric conditions. However, SAR images are harder to visually interpret compared to normal RGB images.

The goal of this project is to translate SAR imagery into RGB-like optical images using a transformer-enhanced conditional diffusion model.

This project involves:

Remote sensing
SAR image understanding
Conditional diffusion models
Transformer-based feature learning
Image-to-image translation
Deep learning-based reconstruction
Evaluation using PSNR, SSIM, LPIPS, and downstream task utility

This has been one of my most challenging projects because it is not only about generating visually good images. The generated output also needs to preserve useful structure and information from the original SAR data.

I recently presented this work at a Springer conference, which made this project an important part of my research journey.

2. Bird Sound Classification Research

Another research project I worked on is bird sound classification.

The goal of this project was to classify bird species using audio data and machine learning techniques. It helped me understand the complete ML workflow more deeply, from preprocessing to feature extraction, model training, evaluation, and result analysis.

This project gave me practical experience with:

Audio signal processing
Feature extraction
Machine learning classification
Dataset preparation
Model evaluation
Research paper writing

The research paper for this project has been published, and it helped me build confidence in turning a technical idea into a complete research contribution.

3. CogniPlan — Cognitive Task Planning System

Apart from research, I also enjoy building real software products.

One of my important software projects is CogniPlan, a cognitive task planning system built to help users convert goals into structured execution plans.

Most task management apps only store tasks. CogniPlan is designed to go deeper.

It focuses on:

Goals
Milestones
Tasks
Routines
Focus sessions
Adaptive scheduling
Missed-task recovery
Productivity insights
Local-first storage

The project is built using Flutter, with a focus on cross-platform support and offline-first usage.

The core idea behind CogniPlan is simple:

A planning system should not just remind you what to do. It should help you execute better.

This project helped me improve my understanding of product thinking, app architecture, local-first design, and user-centered workflow systems.

4. MeshOS / AetherLink — Personal Digital Mesh and Remote Control System

I am also working on MeshOS, a local-first personal digital mesh project.

The goal is to create a system that connects a user’s laptop, phone, files, clipboard, apps, automations, and remote-control workflows into one private command layer.

A part of this work also involves AetherLink, a remote desktop and device control system.

This project explores:

Rust-based host applications
Flutter-based clients
Secure device-to-device communication
Remote screen streaming
Remote input control
File transfer
Clipboard sync
Cross-device workflows
Local-first design

The main idea is to give an individual better control over their own digital environment across devices.

This project is still evolving, but it has already taught me a lot about system design, networking, performance, cross-platform development, and real-time communication.

Why I’m Writing on DEV

I want to use DEV as a place to document my journey honestly.

Not only the final polished results, but also:

what I am building
why I am building it
what problems I face
what technical decisions I make
what mistakes I learn from
how research ideas become real working systems

I believe that sharing the process is just as important as sharing the final project.

My current focus areas are:

AI/ML engineering
Deep learning research
Remote sensing
Flutter app development
Rust systems programming
Local-first software
Cross-platform product development
Building useful tools for real users

What I’ll Be Sharing Next

In upcoming posts, I plan to write about:

How I built CogniPlan
Why I am building MeshOS
My SAR to RGB diffusion research journey
Lessons from training deep learning models on limited hardware
Flutter and local-first app architecture
Rust-based remote desktop systems
My experience with research paper publication and conference presentation
My roadmap as an M.Tech CSE student trying to grow as an AI/ML and software engineer

Connect With Me

I’ll be sharing more updates around AI/ML research, software projects, Flutter, Rust, local-first systems, and my build-in-public journey.

You can find more of my work here:

Portfolio: https://karansinghgurjar.github.io/ksg_portfolio/
GitHub: https://github.com/karansinghgurjar
LinkedIn: https://www.linkedin.com/in/karan-singh-gurjar-052b30197/
Twitter/X: https://x.com/karan_gurjar08

Final Thoughts

I am still learning, building, improving, and experimenting.

My goal is to become stronger not only at writing code, but also at designing systems, solving real problems, and turning ideas into useful products.

I’m excited to start sharing my journey here and learn from the DEV community.

Thanks for reading.

I’d be happy to connect with anyone interested in AI/ML, research, Flutter, Rust, local-first software, or building real-world developer tools.