SavePoint

Most tools restore your files. Save Point restores where your thinking left off.

Save Point is an AI re-entry tool for neurodivergent — primarily ADHD — students. You tap once to save your place before an interruption, and when you come back it hands you your thinking, not your tabs: the one next step, where you were, what you'd already decided, and what you were still unsure about.

🔗 Live: https://savepoint-seven.vercel.app 💻 Code: https://github.com/TheWeirdDee/savepoint

Inspiration

This started from something one of us lives with. You're deep in an assignment — a few sources open, you've half-decided something, you know the next sentence you want to write. Then your phone buzzes or someone calls your name, and you're gone. Twenty minutes later you sit back down and the tabs are all still there, but your head is empty. You can't remember why you opened them, what you'd ruled out, or what you were about to do. Rebuilding all of that from cold is so tiring that, a lot of the time, you just don't. The assignment dies right there.

Every tool we found solves the wrong half of this. Tab managers and note apps are good at storing information. None of them restore cognitive context — the reasoning that connected the information. You don't lose your files when you're interrupted. You lose your place in your own thinking. That's the gap Save Point is built for.

The reframe that shaped every decision: this is not a focus problem to fix. It's a cost problem to remove. Save Point never asks you to concentrate harder or get interrupted less. It makes stepping away cheap — so your deep focus becomes something to protect, not apologize for.

What it does

• One-tap save. Type or dictate an optional note — or nothing. No required fields, no "are you sure." The moment you're interrupted is the worst possible time to make an ADHD student fill out a form.
• An AI-reconstructed restore, not a tab dump. On return you get, in order: your next step (one concrete, doable action, the biggest thing on screen), where you were, and one thing it's less sure about — with everything else folded behind "More context."
• It shows its evidence. Each important inference has a collapsed "Why I think this" receipt naming the captured signals it came from (your note, your writing, an open tab). It's not a black box.
• It asks instead of pretending. Every field carries a confidence level that changes the wording — a statement when sure, a question when not. When there's genuinely too little to go on, it asks one orienting question instead of inventing a confident, wrong answer.
• Its memory never outranks yours. If it gets a decision wrong, you correct it in one tap, and that correction is stored and respected in later reconstructions — visible in a "What Save Point remembers" panel you can edit or clear at any time. It never silently builds a profile of you.
• Accessibility that's real, not a checklist. Atkinson Hyperlegible by default, a one-tap Lexend dyslexia mode, three text sizes, relaxed line spacing, and reduced motion — all persisted. No shame language, ever: it never tells you how long you were gone.

How we used AI meaningfully

The AI here is not a chatbot and not a summarizer. On each restore, the model (running on Groq, with Gemini as an automatic fallback) fuses incomplete signals — an optional note, recent writing, selected text, the active page — into the cognitive state most useful for getting back in, and tags every inference with a confidence tier that controls how it speaks.

The rule we cared about most: never invent a decision and present it as fact. A confidently wrong reconstruction is worse than no tool at all, because a student will trust it and act on it. So uncertainty becomes a one-tap question, thin input becomes an orienting question rather than a fabrication, and every inference can be traced back to the evidence that produced it. That combination — evidence receipts + calibrated uncertainty + corrections that outrank the model — is what makes this a memory system you can actually trust, not just a clever prompt.

Designed with, and by, neurodivergent students

This wasn't designed for an abstract user and tested once before submission. The core problem is one of the builders' own daily experience, and that lived experience is what shaped the actual decisions in the code — not just the pitch:

• No shame, ever. No "you were gone 2 hours," no streaks — because being reminded how long you were away doesn't help you restart, it just adds guilt on top of the work.
• Saving can never require a form — the note is optional, because at the moment of interruption, asking someone with ADHD to stop and write a paragraph means they just stop saving.
• Restore leads with one next action, everything else collapsed — because for dyslexia, a dense summary reads like more homework before you've even begun.
• The reading settings exist because one of us needs them to comfortably read the app's own interface — they're tested toggles, not a features-list checkbox.

Designed by a neurodivergent student, from the inside. Save Point wasn't built for an abstract user — its core problem is one of the builder's own daily ADHD experience, and that's what shaped the real decisions in the code: saving never requires a form, because the moment of interruption is the worst time to ask an ADHD student to write a paragraph; restore leads with one next action, because a dense summary reads like more homework; the dyslexia font and reading settings exist because a neurodivergent builder needs them to read the app's own interface. Dyslexia-user testing is underway to pressure-test exactly these choices, and that feedback is shaping what we change next.

How we built it

• Next.js (App Router, TypeScript) on Vercel, styled with Tailwind against a strict low-glare, ND-first design-token palette.
• Supabase (Postgres) for persistence, accessed only through server routes holding the service-role key, with row-level security locked down.
• Groq (llama-3.3-70b-versatile) as the primary reconstruction model with an automatic Gemini fallback, both in JSON mode, behind one provider layer so the rest of the app never knows which answered.
• Custom username/password accounts (bcrypt + JWT, httpOnly cookie for the web app and a Bearer token for the extension), with email-based password reset.
• A companion Manifest V3 Chrome extension as an optional capture sensor, and a bookmarklet fallback for phones and locked-down school Chromebooks where extensions can't run.

We also treated AI failure as a first-class product concern: quota, auth, network, and parse failures are classified distinctly with honest, specific messages, a failed reconstruction is never cached or shown as if it were real, and a demo mode exists so the experience can be shown even if a live key is down.

Challenges we ran into

• Making the AI trustworthy, not just capable. The hard part wasn't getting a reconstruction — it was getting one that admits what it doesn't know. Building the confidence tiers, the evidence receipts, and the correction loop took more care than the reconstruction itself.
• Free-tier AI reliability. We hit dead models, retired model IDs, and quota limits, which pushed us to a two-provider setup with automatic failover and a demo-safe fallback.
• Context contamination. During testing we caught the reconstruction pulling in unrelated context and stale memory — the exact "confidently wrong" failure our thesis promises to avoid. Finding it ourselves, and constraining the model so current evidence outranks old memory, made the trust model real instead of aspirational.
• Restraint. The hardest product discipline was not building — no timers, no gamification, no passive monitoring, no broad learner profile — because each of those would have pulled Save Point into a crowded category and blurred a sharp thesis.

What we learned

That the trustworthy version of an AI memory tool is defined by what it refuses to do: it refuses to fabricate, it refuses to outrank the student's own memory, and it refuses to watch you in the background. And that "designed with neurodivergent users" is most honest when the builders are the users — when a design decision comes from needing it yourself, not imagining someone who might.

What's next

Verified end-to-end testing with more neurodivergent students, a published extension so it works on managed school devices, and a "since your last save" view of how a piece of thinking evolves across sessions.

Built With

• bcrypt
• chrome
• google-gemini
• groq
• javascript
• jwt
• llama
• next.js
• postgresql
• react
• resend
• supabase
• tailwindcss
• typescript
• vercel