Slate

• 

  Onboarding

• 

  Replan Feature

• 

  Results!

Inspiration

It started from a much messier problem than the one we ended up solving. We began building a misinformation-checker — something that could take a screenshot or a claim and verify it against real evidence. Somewhere in the middle of debugging a fetch pipeline for the third time, we asked a different question: what's the deadline pressure we're actually feeling right now, building this under a ticking clock, with scholarships, essays, and lab reports all landing in the same week back home?

That was the real inspiration. Every planner we'd ever used sorted by date. But date order lies — three easy things landing the same day isn't a crisis, and two slow, high-stakes things landing three days apart quietly is, and nothing ever told us that. Slate exists to say the thing your calendar won't: not just when something's due, but which ones will actually collide and cost you.

What it does

You paste your mess — a forwarded email, a screenshot, a rambling voice note, whatever shape your deadlines actually arrive in — and Slate doesn't hand back a to-do list. It reasons through it the way a smart, honest older sibling would: how much effort each task actually takes, how much it actually matters, and where two things are quietly going to collide in a way that'll hurt. Then it gives you one plain, opinionated verdict on what to start today.

The result renders as a staged reveal — the verdict appears first, then the timeline builds itself task by task, and when two colliding deadlines both land on screen, the connection between them animates into view. You don't just read the collision. You watch it get caught.

How we built it

The architecture is deliberately simple: one structured AI call does the extraction, effort/stakes estimation, and collision reasoning together in a single pass, returning a strict JSON schema — tasks, collisions, and a verdict. No chained pipeline, no live web fetching, no external dependency that could fail mid-demo. Everything the app knows comes from the text the user gives it.

We went through a few frameworks and providers before landing here, moving fast to find the stack that let us actually ship rather than fight tooling. The current build uses Gemini for the reasoning call with enforced structured output, a lightweight edge function to keep the API key server-side, and a link-based no-login model — every plan gets a permanent, shareable URL instead of an account.

Challenges we ran into

The honest version: we pivoted, hard, more than once. Our first build was a live fact-checking tool with a multi-stage pipeline — search, fetch, evaluate, cross-check — and it taught us the expensive way that every external call you chain together is another point of silent failure. Inputs went missing between pages, routes 404'd from naming drift between "investigate" and "investigation," and processing screens hung forever waiting on calls with no timeout. Rather than keep patching a fragile architecture, we cut it down to the one thing that actually mattered and rebuilt around a single, bounded, reliable call.

Reliability stayed the top priority even after the idea changed — we stress-tested the final pipeline five times in a row with different real inputs before trusting it, and hardened loading states so a slower response never reads as a frozen one.

Accomplishments that we're proud of

We built something that actually reasons, not just formats. The core of Slate isn't a to-do list generator — it's a single AI call that weighs effort against stakes to catch collisions a simple date-sort would miss entirely. Getting that reasoning to come back structured, consistent, and genuinely useful in one pass — not a chain of brittle calls — is the piece we're most proud of.

We had the discipline to pivot instead of patch. Our first build was a much more ambitious live fact-checking tool, and it kept failing in ways that traced back to the architecture itself, not any single bug. Recognizing that and rebuilding around one bounded, reliable call — rather than sinking the rest of our time defending a shaky foundation — was the single best decision we made all weekend.

What we learned

The biggest lesson wasn't technical, though there were plenty of those (timeouts, structured output schemas, the cost of chaining AI calls instead of reasoning in one pass). It's that a smaller, honest scope beats an ambitious, fragile one — every time. The version of this project that tried to do the most broke the most. The version that did one thing, reliably, and let the AI do real reasoning instead of just formatting, is the one that actually works.

What's next for Slate

A re-plan flow where a follow-up constraint ("I can't start until Thursday") re-reasons the verdict live, and eventually, a version that can ingest a full syllabus or semester's worth of deadlines at once rather than one messy paste at a time.

Built With

• ai
• deadlines
• edge-functions
• edtech
• gemini
• generative-ai
• hackathon
• javascript
• json-schema
• llm
• nextjs
• planning
• productivity
• react
• serverless
• studentlife
• studenttools
• studygenerated
• supabase
• task-management
• time-management
• typescript
• ux-design
• webapp