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
