Login/Signup Page
Dashboard
Schedule Creator (You can either type or create it using your voice)
Four Ways to Plan Your Day. Complete All Your Goals. Celebrate with Confetti.
Detailed Task Schedules (Part-1)
Detailed Task Schedules (Part-2)
Google Calender Integration
Dark Mode
Profile Page with Notification Buttons
Profile and Logout
Logged-out Window

RoutineWise

Inspiration

RoutineWise was born out of a shared frustration—one that many of us quietly carry every day. Whether it was forgetting tasks despite to-do lists, feeling overwhelmed by rigid routines, or watching plans fall apart after just one unexpected event, the existing productivity tools always seemed to assume we were machines. But we're not.

This project began as a way to build something for ourselves—for people like us—who often find it hard to stick to fixed plans. As students, professionals, and creatives managing not just workloads but mental health, we needed a planner that didn’t just tell us what to do, but understood how we do it.

While RoutineWise was originally designed with the daily struggles of neurodivergent individuals in mind—those who often face fluctuating focus, cognitive overload, or decision fatigue—it quickly became clear that the need for a flexible, adaptive scheduler extends far beyond that audience. Even neurotypical individuals face unpredictable days, shifting priorities, and mental fatigue. RoutineWise offers structure with compassion, helping anyone navigate their day more intentionally.

We imagined a system that could generate multiple daily plan options based on personal goals, check-in patterns, and natural exceptions—while still feeling lightweight and easy to use. A system that feels less like a productivity drill sergeant and more like a thoughtful assistant who knows when to push and when to pause.

What it does

RoutineWise is a web application that generates intelligent, adaptive daily plans tailored to the user’s behavioral patterns, goals, and constraints. The core features include:

Natural language input for user goals (e.g., "2 hours of piano practice", "class from 4:30–7:10pm")
AI-generated plans that include fixed events, flexible routines, and logical ordering
Multiple variants of the plan—such as front-loaded, evenly spread, or minimal-breaks
Context-aware adjustments like moving breakfast or breaks
Fallback rule-based system in case of AI failure
Task analytics and profile data

How we built it

Parsing Natural Language Goals

To convert messy, natural language input like "Work on ML project and attend class from 2–4pm" into structured data, we use Gemini to extract two arrays:

Goals: tasks with flexible timing
Exceptions: events with fixed start times and durations

const prompt = \`
You are an intelligent AI day planner. Your job is to generate a thoughtful, well-structured daily schedule between ${startOfDay} and ${endOfDay}.
User message:
"\${text}"
\`;

const res = await ai.models.generateContent({ model, contents: prompt });
const json = stripFences(res.text);
const parsed = JSON.parse(json);

return {
  goals: parsed.goals || [],
  exceptions: parsed.exceptions || []
};

Duration Estimation

Here, we estimate the time each task might take using either:

Historical averages from the user's past behavior
Or LLM-powered semantic similarity (e.g., “Study Python” ≈ “Study Java”)
This helps us generate plans with realistic time blocks.

const prompt = \`
You are an intelligent AI day planner. Your job is to generate a thoughtful, well-structured daily schedule between ${startOfDay} and ${endOfDay}.
New Tasks: \${JSON.stringify(taskNames)}
Historical Task Durations: \${JSON.stringify(avgTaskTimes)}
\`;

const res = await ai.models.generateContent({ model, contents: prompt });
const json = stripFences(res.text);
const parsed = JSON.parse(json);
return parsed;

Prompt Builder for Gemini

This function constructs the master prompt that we send to Gemini to generate a complete day plan.
It includes:

Strategy (e.g., "Front-loaded", "Even spread")
Estimated durations
Time exceptions to avoid
User-defined goals
Instructions on structuring the plan

return \`
You are an intelligent AI day planner...
Strategy: \${strategy}

User-defined Goals:
\${goalsStr}

Estimated Durations:
\${JSON.stringify(mergedDurations)}

Time Exceptions:
\${exceptionsStr}
... (truncated for clarity)
\`.trim();

Rule-Based Scheduler

If the AI model fails to generate a response, we fall back to this deterministic scheduler.
It:

Prioritizes fixed events (like classes or meetings)
Inserts user goals around those time blocks
Avoids overlap and creates a sensible flow through the day

function scheduleDay({ goals, exceptions, startOfDay }) {
  const startMinutes = hhmmToMin(startOfDay);
  const fixed = [];

  for (const ex of exceptions) {
    fixed.push({ name: ex.name, start: hhmmToMin(ex.start), duration: ex.duration });
  }

  const remaining = goals.filter(g => !fixed.some(f => f.name === g.name));
  const tasks = [];

  let cursor = startMinutes;
  for (const goal of remaining) {
    tasks.push({ task: goal.name, time: minToHhmm(cursor), duration: goal.duration });
    cursor += goal.duration;
  }

  return tasks;
}

Task Classification with Gemini Flash

For analytics and personalization, we assign each task a high-level category such as:
reading, coding, planning, writing, etc.
This classification is done using Gemini Flash and later used in pattern tracking.

const prompt = \`
Identify a broad task category...
Task: "\${taskName}"
Category:
\`;

const result = await model.generateContent({
  contents: [{ role: "user", parts: [{ text: prompt }] }]
});

const category = result.response?.candidates?.[0]?.content?.parts?.[0]?.text?.trim().toLowerCase();