Case study · Zero to one · EdTech
Seven months to live school pilots, for an app that wants kids off their screens
- Company
- DoCurious — K-12 learning platform
- My role
- Co-Founder & Head of Product & UX
- Team
- Founding designer and builder; AI-assisted
- Timeframe
- Dec 2025 – present
- Status
- Live — school pilots running
- Live at
- explore.docurious.com ↗
- Problem
- Kids learn by doing real things, and schools need proof they did them. One product had to serve six audiences, protect kids under 13, and still feel simple.
- What I did
- Led product and UX from the first commit: the product's shape, every journey and state, the design system, and most of the build, through an AI-assisted workflow I designed.
- What happened
- Two schools running live pilots seven months in, on one platform where consent and sharing rules are built into the flows themselves.
An app that tells you to put it down
The first thing a DoCurious user reads is the tagline on the sign-in screen: Get off your screen. Into the world. It's a strange brief for an app. Success looks like a nine-year-old in a backyard measuring the angles in a fence, and the app's job is to be quick about everything around that moment: picking the challenge, proving it happened, and celebrating when someone says yes.
Behind that kid is a crowd. Teachers assign challenges and grade the evidence. Parents approve accounts and decide what gets shared. School administrators run rosters and budgets. Providers write and sell challenges, brand partners sponsor series, and our own staff moderate the lot. Many students are under 13, so federal privacy law (COPPA) shapes every flow they touch.
I held every screen to two questions. How fast does it get the kid back outside? And when they come back, does it prove what they did in a way a teacher will trust and a nine-year-old will be proud of?
Eight roles, one product
Here's who can do what, straight from the product handbook I keep, where every rule cites the code that implements it. Six audiences could have been six apps. Keeping them in one is the decision the rest of this page hangs off.
| Area | User | Parent | Student | Teacher | School admin | Provider | Brand | Staff |
|---|---|---|---|---|---|---|---|---|
| Find and do challenges | Can do it | Can do it | A limited version (kid-safe library) | Can do it | Can do it | Not for them | Not for them | A limited version (preview only) |
| Review and grade work | Not for them | A limited version (see only) | Not for them | A limited version (own classes) | Can do it (whole school) | Not for them | Not for them | Can do it |
| Run classes and assign | Not for them | A limited version (give to own kids) | Not for them | Can do it | Can do it (all classes) | Not for them | Not for them | Can do it (any school) |
| Manage a school | Not for them | Not for them | Not for them | Not for them | Can do it | Not for them | Not for them | Can do it |
| Author challenges | Not for them | Not for them | Not for them | A limited version (Learning Paths) | A limited version (Learning Paths) | Can do it (their own) | A limited version (sponsored series) | Can do it (any) |
| Money | A limited version (buying, switched off for now) | A limited version (buying, switched off for now) | Not for them | A limited version (request purchases) | Can do it (approve purchases) | Can do it (orders and payouts) | Can do it (series and fulfillment) | Can do it (payouts and refunds) |
| Family | Can do it (add or link kids) | Can do it (My Kids) | Not for them | A limited version (message parents) | Can do it (Family Access) | Not for them | Not for them | Not for them |
| Moderation | A limited version (report) | A limited version (report) | A limited version (report) | A limited version (class community) | Can do it (their school) | Not for them | Not for them | Can do it |
Where I sat
Mine: product and UX, end to end. What we build and in what order, the journeys, every state, the design system, the copy standards, and the quality bar. Plus most of the build, through an AI-assisted development workflow I designed and run every day.
Shared: the founding team owns the business and makes the final call on business questions. Outside contributors ship features into the platform, and my review bar, decision log, and design standards are what keep their work feeling like the rest of DoCurious.
How I work, shown on DoCurious
Six habits I'd bring to any team, each with the DoCurious decision that proves it. They're closed so you can pick. Craft is number four, if that's what you came for.
01 Find the job before drawing the screen
One product instead of six portals, and standards tags a teacher can actually use.
Early on, the pull was toward a portal per audience: one for teachers, one for students, one for parents. Each would have been easier to design on its own. Together they'd have been three copies of the same library, drifting apart a little more every sprint. I consolidated three competing discovery surfaces into one role-aware library and folded parents into the main experience. That halved the surface we had to keep coherent.
Learning standards taught the same lesson at a smaller scale. Teachers wanted challenges tagged to standards, and the obvious move was to tag every challenge to individual codes, all 3,000-plus of them. Before committing to that, I read a partner diocese's actual standards documents. Their codes were custom. Their math standards were borrowed from Indiana. Religion had a framework no national standard covers, and they revise one subject a year on a rolling cycle. Individual codes turned out to be a different dialect at every school.
So DoCurious tags at the domain level, about 120 groupings like "Life Science, K–2," the level every framework shares. A teacher maps that to their own codes in seconds, and their gradebook keeps the detail. Going deeper would have meant custom setup for every school we ever signed. This way we set it up once.
The same habit fixed a pilot problem in its first week. A school told us they "couldn't see anything." The data was fine. The onboarding journey had a gap between self-registration and school invites, so their accounts never joined the school. We fixed the journey, and the data showed up on its own.
02 Write the rule, then design the screen
COPPA turned into flows a nine-year-old and a busy parent can both get through.
US law says an online service needs a parent's verifiable permission before it collects anything from a child under 13. A lot of products meet that with a checkbox and a privacy policy. I treated it as a set of journeys, because a kid who hits a wall they don't understand just leaves, and a parent who gets a vague email ignores it.
An under-13 account can start four ways: a kid signing up alone, a parent adding their child, a school inviting a student and asking the parent, or a school giving consent itself. All four end in the same place, so the rest of the product only has to know one thing about a kid's account: approved, or waiting.
The calls that mattered most:
- A waiting kid can still look around. They can browse challenges and see their class. Anything that creates something or records their activity waits for a parent. Locking the whole app would have been simpler to build, and the kid would have bounced before the parent ever opened the email.
- The approval link only works for the account it was sent to, so a forwarded email can't hand consent to someone else. It expires after 48 hours, with one tap to get a fresh one.
- Proving you're an adult costs a family once. It's a one-time 50¢ card check, and every approval after that is one click. When a school has already vouched for the family, there's no card at all.
- Sharing takes three yeses: consent, a parent who has turned sharing on, and that parent's OK on each piece of work. Under-13 work never appears in the public feed.
One rule held across all of it: never fake a legal flow. If a data-export or deletion screen wasn't wired to something real, it came out of the product until it was.
03 Design every state, not just the happy path
Draft, waiting, sent back, approved. Every state designed, and proven against production.
Doing a challenge looks like three screens: start, add proof, submit. The real journey has a lot more states than that, and kids spend most of their time in the in-between ones. Half finished. Missing a reflection. Waiting on a teacher. Sent back with a note.
Each of those got its own design. The progress bar counts what's left in plain words. The reflection box counts words and tells you how many it needs. When a teacher sends work back, the student sees the teacher's own words first, and the assignment list files it under a heading that says Let's fix this one first.
Designing a state is half the job. The other half is knowing it still works next month. I built the Product Atlas, a live map of every role, capability, and state, with screenshot proof captured against production, and opened it to our pilot-school leaders. If we say something works, they can check. Unbuilt states stay on the map on purpose.
The same bar runs through code review. Before they merged, it caught a message meant for one parent that would have gone to every parent, a route that let any teacher archive any class, and a way around a school's seat limit.
04 The details are the product
A title measured to the pixel, and two celebrations timed so a kid actually sees them.
Most of what makes a product feel cared for is too small to put on a roadmap. Two examples from the same week.
The title on the notebook
The teacher's assignment page opens on the challenge photo, with the assignment name in white over it. On "Algebra Story Quest — individual," the first line landed on a sheet of white notebook paper. You could read it if you already knew what it said.
I measured before touching anything. With the text hidden, 72% of the pixels behind the title came in under 3:1 against white, and the worst spot was 1.12:1. The gradient wasn't wrong. It was sized to the whole hero, so short titles sat in the dark band and long ones wrapped up into the clear part. It only broke on long names, which is why nobody had caught it.
Darkening the whole photo would have fixed it, and buried the fastest way a teacher tells assignments apart. I moved the scrim onto the text block instead, so it grows with the title. Worst spot after: 5.26:1.
My first pass made the card 32px taller. I caught it comparing captures and rebuilt the scrim as its own layer. Nobody files a ticket about a card that got a little taller, but every teacher would have felt the page jump.
Moments that answer a kid
When a student turns in work, the app has about two seconds to tell them it landed. The first version fired confetti and navigated away in the same instant, so the burst played over the next page's grey loading placeholders. It also ignored the device's reduced-motion setting.
Now the confirmation says what just happened and who looks next: Turned in! Your teacher will take a look. The confetti plays over the student's own work, and the redirect waits for it. That wait is capped at 2.5 seconds, because browsers pause animation in background tabs and a kid shouldn't get stuck inside a celebration. Then one optional question, "How'd that one feel?", and the answer goes to their teacher.
The badge was harder, because it's earned somewhere else. A teacher approves the work and the server awards the badge while the student is on a different page. The original popup lived on one page and only fired for badges that page had awarded, so after a teacher approval it never showed at all. A reward nobody sees is just a row in a database.
The celebration now lives across the whole app. It checks for unseen badges when the student signs in or moves around, plays once, and marks itself seen when they close it. Three badges at once get one popup and a "+2 more" link instead of three popups in a row. When an admin views the app as a student, it stays quiet, so it doesn't spend the kid's moment. And the motion ends: twelve pieces of confetti fall twice, the medallion glows twice and pulses three times, then everything stops. With reduced motion on, the confetti is gone and the medallion holds still.
05 Build a system other people can ship with
Figma tokens compiled into code, so other people's features still look like DoCurious.
I'm not the only one shipping into DoCurious, so the system has to do the reminding for me. Color, type, and spacing live as design tokens in Figma. A build step compiles them into the CSS variables and theme configs the app runs on, so nobody retypes a hex code. Components live in Storybook with accessibility checks, and there are written copy standards. My favorite rule: buttons say what they literally do. The button that saves a draft says Save draft.
The tokens carry more than color. Type and density come from them, and so does the navigation layout, which is how one page can render as two quite different products.
Contributors get the decisions along with the components. When an outside contributor's pull request quietly made product calls of its own, I held the merge until those calls were written down and agreed, then landed it with a record of what they proposed and what we ratified.
A system is only as good as the places that skip it. The badge popup in section four shipped with a hard-coded blue button, the one blue thing on a green screen, because a single class name went around the tokens. Finding those is part of the job. That one's fixed.
06 Prototype in the real thing
Built in production code with an AI-assisted workflow, behind review gates I don't skip.
I started as a developer, and on DoCurious that's the whole workflow. I don't hand off a Figma file and wait. I design in the product: React and TypeScript on the front end, Express and PostgreSQL behind it, deployed on AWS. Every clip and before-and-after on this page came from the running app, because that's where the decisions got made.
AI agents write a lot of the code. I designed the workflow they work in, and I review every change that merges, including my own. AI makes code cheap. It doesn't make judgment cheap, so the gates are where I spend my attention: unit, integration, and end-to-end suites in CI, and an integrity check that fails any pull request adding a page without mapping its states into the Atlas.
More than 2,000 commits later, a team of roughly one has a product running in two schools, and a map that says exactly which parts of it are proven.
Two schools live in seven months
Two schools were running live pilots seven months after the first commit. Six audiences use one role-aware product. Kids' data is protected by how the flows are built rather than by a policy page, and the Atlas shows which states are proven and which aren't built yet.
What I'd do differently
I'd kill the prototype sooner. DoCurious started as a front end running on mock data, which was the right way to find the product and the wrong thing to let linger. When I audited the staff admin area, 23 of its 61 pages were mock or quietly lying: metrics nobody tracked, a refund button that did nothing. They all came out. The rule now is to wire it to something real or remove it, and I'd set that rule on day one instead of finding out I needed it.