SYNAPSE

• 

• 

• 

Inspiration

The hardest part of managing a busy workload is often not knowing what needs to be done. It is knowing what to do next when everything feels important.

Traditional task lists show what exists. Calendars show when something is due. But when multiple deadlines collide, neither necessarily answers the practical question: Can all of this realistically fit into the time I actually have?

That was the idea behind SYNAPSE.

We wanted to build a workload planner that treats planning as a constraint problem rather than another checklist. Instead of asking users to create a perfect schedule themselves, SYNAPSE takes deadlines, estimated effort, priority, and realistic daily capacity and turns them into an executable seven-day plan.

The goal is simple:

Know what to do next.

What it does

SYNAPSE is a local-first workload planner designed to turn a collection of unfinished work into a realistic plan.

Users can:

• Add tasks with a context, due date, estimated effort, and priority.
• Set how many minutes they realistically have available each day.
• Generate a seven-day schedule automatically.
• Split large tasks across multiple days instead of cramming everything into one session.
• Surface the next task using deadline, priority, and workload pressure.
• See why a particular task deserves attention.
• Identify tasks that are healthy, tight, or overdue relative to available capacity.
• See when part of the workload cannot realistically fit.
• Mark work complete and immediately recalculate the schedule.
• Switch between today's work, planned work, and the complete workload.
• Import and export plans as JSON.
• Keep workload data saved locally in the browser.
• Create a fresh private browser workspace without requiring an account.

The core experience follows a simple loop:

Capture → Understand → Act → Recalculate

SYNAPSE is intentionally focused on reducing the mental effort required to decide what to do next.

How we built it

SYNAPSE is built as a responsive Next.js web application using React, TypeScript, and CSS.

The planning engine is deterministic and runs entirely in the browser. It processes unfinished work using deadline, priority, and estimated effort, then allocates available minutes across the days leading toward each deadline.

The basic planning flow is:

Tasks
↓
Due date + priority + estimated effort
↓
Realistic available minutes
↓
Deadline-ordered allocation
↓
Daily capacity checks
↓
Work split across available days
↓
Seven-day executable plan

A key design decision was making the engine explainable. The same inputs produce the same plan, so users can understand where their schedule comes from rather than receiving an opaque recommendation.

SYNAPSE is also deliberately local-first. Tasks and capacity are stored in browser local storage and namespaced using a random local workspace identifier. The core product does not require an account, external database, or cloud synchronization.

We also implemented JSON import/export, responsive mobile layouts, keyboard-focusable controls, reduced-motion support, and inline status feedback.

AI was used as a development assistant for brainstorming, implementation assistance, debugging, code review, documentation, and iteration. The final product direction, implementation decisions, testing, and claims are the responsibility of the project author. The planning engine itself does not require an AI model or external AI API.

Challenges we ran into

One of the biggest challenges was avoiding the temptation to make the planner appear smarter than it actually was.

It is easy to build an interface that produces a schedule, but a useful planner needs to acknowledge when the requested workload does not fit inside the available time.

We therefore designed SYNAPSE around explicit capacity constraints. When the available time is insufficient, the application keeps the unscheduled pressure visible instead of pretending that everything fits.

Another challenge was deciding what information should influence the next-action recommendation. A task's deadline alone is not enough. A short high-priority task and a large task due tomorrow can require very different decisions.

We addressed this by combining deadline, priority, estimated effort, and workload pressure while keeping the result deterministic and explainable.

We also had to think carefully about privacy. Rather than introducing authentication and a backend simply because many productivity applications have one, we chose a local-first architecture for the current prototype. This reduced infrastructure complexity while giving users private browser-level workspaces.

Accomplishments that we're proud of

We are proud that SYNAPSE solves a focused problem instead of trying to become another enormous productivity platform.

The strongest accomplishment is the transformation from raw workload → realistic capacity → actionable schedule.

We are also proud of the explainability built into the experience. SYNAPSE does not simply surface a task; it can explain why this one deserves attention.

Other accomplishments include:

• A deterministic seven-day scheduling engine.
• Automatic task splitting across available days.
• Explicit visibility into workload that cannot fit.
• Immediate schedule recalculation after completing work.
• Private local browser workspaces without requiring accounts.
• Validated JSON import/export for portable plans.
• Responsive mobile support.
• Keyboard-accessible interactive controls.
• Reduced-motion support.
• A focused interface designed around the next useful action.

Most importantly, the prototype is honest about its boundaries. It does not claim to have cloud accounts, collaboration, calendar integrations, machine-learning predictions, or server-side workload storage when those capabilities are not implemented.

What we learned

We learned that good productivity software is not necessarily about adding more features.

A planner can become less useful when it gives users more information without helping them make a decision.

Building SYNAPSE taught us to think about planning as a constrained system: time is finite, workloads have different costs, and deadlines create pressure.

We also learned the importance of explainability. When software recommends an action, users should be able to understand the reasoning behind it.

Another important lesson was that privacy does not always require a large backend architecture. For this prototype, keeping the core workload local allowed us to create a useful experience without requiring users to create accounts or send their personal workload data to a server.

Finally, we learned to distinguish between what a product could become and what it actually is today. That discipline helped us keep the implementation and competition submission grounded in real functionality.

What's next for SYNAPSE

The current prototype establishes the core workload-to-action engine. The next stage is expanding that engine without losing its simplicity.

Potential future development includes:

• Calendar synchronization.
• Recurring tasks.
• Dependency-aware projects.
• A richer constraint solver.
• Optional authenticated accounts.
• Cloud synchronization.
• More advanced workload balancing.
• Additional planning controls for complex projects.

These are roadmap ideas rather than current capabilities.

The long-term vision is for SYNAPSE to become a planning layer that sits between everything you need to do and the next useful action you should take.

Instead of becoming another place to store tasks, SYNAPSE should become the system that helps turn those tasks into a plan you can realistically execute.

Built With

• css
• localstorage
• next.js
• react
• typescript
• vercel