[photon] prepr

Prep for every part of the SWE Interview

Comment

Inspiration

Most interview prep stops at LeetCode. A real SWE loop has coding, system design, behavioral questions and a deep dive on your resume, and more companies now run AI-assisted coding rounds too. The bigger problem is forgetting. You grind a sliding-window problem on Sunday, and by Thursday you can't remember why it worked. Spaced repetition fixes forgetting, but flashcard apps rely on you opening them, and nobody does. We asked what would happen if your prep came to you, in the one app you already check a hundred times a day: iMessage.

What it does

Prepr is spaced-repetition prep for the whole SWE interview.

  • iMessage flashcards: Prepr texts you a short DSA question right before you'd forget it. You answer in one sentence and an LLM gives you Socratic feedback. Then you rate yourself with a tapback: ❤️ effortless, 👍 hesitant, 👎 guessed. That tapback feeds the SM-2 algorithm and decides when the card comes back. You never have to open an app.
  • Card-flip IDE: 84 problems, including all of the Blind 75. Each one takes three flips: name the invariant, dodge the edge-case trap, then code it against hidden tests in Python, JavaScript, TypeScript, Java, C++ or Go.
  • The sync loop: if you struggle in the IDE, Prepr marks that pattern (say, Bitmask DP) as a weak spot. The next morning your phone buzzes with a ☕ briefing and a drill on exactly that pattern.
  • Prepr Bot (AI-assisted rounds): a Cursor-style assistant inside every problem. It suggests changes as diffs you can review, and it can edit just the lines you select. It also sometimes slips in a subtle bug on purpose. At the end it scores how well you used AI: framing, prompting, verifying, catching its mistakes, and owning the code.
  • Resume grill: upload your resume and defend every line against a skeptical interviewer. Each claim gets a verdict: held up, shaky or cracked.
  • Behavioral: answer out loud and watch a live STAR checklist, filler-word highlighting and pace, then get an Engineering Manager's scores and a follow-up question.
  • System design: draw your architecture on a whiteboard while an AI interviewer reads the diagram. It calls out things like a cache that isn't connected to anything, then scores you on six dimensions.
  • Mock onsite: a timed loop of coding, behavioral and resume grill that ends in a hiring-committee packet: hire or no hire, and what would change the decision.
  • Weekly report card over text and as a shareable PNG, plus an Expo mobile app that uses the same data.

How we built it

  • Monorepo with npm workspaces, built around a shared TypeScript core (@synapse/core): the SM-2 scheduler, tapback mapping, content (110 micro-cards, 84 problems, 16 behavioral questions), grading, the code judge, and a SQLite store.
  • iMessage agent on Photon's spectrum-ts. It routes incoming texts and reactions to a study controller and runs a scheduler that respects active hours, daily text limits and morning briefings.
  • Web app on Next.js 16 (App Router). The code editor is Monaco. Python runs in the browser through Pyodide in a Web Worker, while Java, C++ and Go compile on the server. Speech uses the Web Speech API, and the system design board is custom-built.
  • One SQLite file (WAL mode) shared by the agent and the web app, so a tapback on your phone and a review in the browser update the same schedule.
  • LLMs: Meta Muse is the main model, with Groq and OpenAI as fallbacks. Every call has a timeout and falls back to a deterministic heuristic, so the whole app works with no API keys.
  • Mobile app in Expo / React Native, talking to the same API.
  • Heavy testing with Vitest. Every answer key must grade "correct" against its own key points. Every problem needs 5+ tests and passing reference solutions. Tests never touch the network.

Challenges we ran into

  • Tapbacks are messy. iPhones send an emoji reaction, while non-Apple phones relay text like Loved "…". People also change their reaction afterward. We had to normalize all of these, ignore tapbacks on old messages, and let a changed rating within 10 minutes re-grade the card as if the first rating never happened.
  • Demoing spaced repetition in 3 minutes. "Come back in 4 days" is hard to show on stage. We added a time scale where one SRS day equals one minute, and injected the clock everywhere so the scheduler stays deterministic and testable.
  • Not leaking answers. Answer keys and reference solutions for 84 problems live in shared code. We had to make sure they never ended up in the browser bundle or in an API response before the user answered, and we added tests to enforce it.
  • Running untrusted code in six languages: browser-side for Python and JavaScript, and a server judge for compiled languages that's off by default in production.
  • Prompt injection. Users can type anything as an answer, so all answers are fenced off and the model is told to ignore instructions inside them.
  • Slow or flaky LLMs. Reasoning models can take 10+ seconds, so we built retries, a chain of fallback providers, and heuristic graders so the demo never gets stuck.
  • Tooling surprises: Next 16 renamed middleware to proxy and made params async, npm scripts run under cmd.exe on Windows, and one Photon project can only feed one running agent.

Accomplishments that we're proud of

  • The full loop works end to end: struggle in the IDE, and the next morning your phone drills that exact weak spot.
  • The whole Blind 75 is playable in six languages, with tested reference solutions, including problems that need real tree, linked-list and graph nodes.
  • An AI-assisted interview trainer that grades how you work with AI, including whether you catch a bug it planted.
  • A tapback is enough to rate a card. Rating a card takes one tap, with no app to open.
  • It works fully offline with zero API keys, thanks to heuristic fallbacks for every AI feature.
  • It covers every part of the interview loop (coding, design, behavioral, resume, and a mock onsite) on web, iMessage and mobile, all sharing one schedule.

What we learned

  • Meeting users where they already are beats building one more app. Asking for a tapback gets far more engagement than asking someone to open a flashcard app.
  • SM-2 is simple on paper, but the edge cases (early reviews, lapses, changed ratings, active-hours timeouts) are where the real work is.
  • Every LLM feature needs a non-LLM backup. Designing for failure first made the product more reliable and made the demo less stressful.
  • Injecting time everywhere makes time-based systems testable. Virtual clocks made our scheduler tests deterministic.
  • How to build a browser code judge on Pyodide in Web Workers, and how to keep a large shared codebase from leaking secrets into the client bundle.

What's next for prepr

  • Accounts and hosted deployment (it's currently single-user and local), with a sandboxed code judge in the cloud.
  • Company-specific tracks (for example, Meta- or Google-style loops) and more content beyond the Blind 75 and NeetCode 150.
  • Voice mock interviews over a phone call, and group-chat study streaks with friends.
  • Adaptive difficulty that uses your mock-packet and report-card trends to decide what to text you next.
  • Peer mock interviews, where two Prepr users interview each other and the AI writes up the committee packet.
Share this project:

Updates

Submission history