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
7 mo
from first commit to live school pilots
6
audiences in one role-aware product
20
canonical user journeys, documented & shipped
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.

What each DoCurious role can do, by product area
Area UserParentStudentTeacherSchool adminProviderBrandStaff
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
Can do it A limited version Not for them From the DoCurious product handbook. On a computer, hover a dot for the specifics.

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.

The challenge library as a teacher sees it: academic standards frameworks, standard-code chips, assign-to-class actions
The library as a teacher sees it: standards frameworks and assign-to-class.
The challenge library as a student sees it: simpler filters, assignments, continue actions
The same library as a student: fewer filters, and a way back into work in progress.

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.
Approved challenge with a 'Share your achievement' card: a parent approves before this goes on the public showcase, with an 'Ask a parent to approve sharing' button
Vera is 11, and her parent hasn't turned sharing on. So the button asks a parent.
Approved challenge on the public showcase, with a 'How your name shows' toggle between 'Show my name' and 'Anonymous'
Ari is 9, and has a parent's OK. Now the choice is hers: her name, or anonymous. Demo data.

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.

A student's assignments page with two challenges marked 'Needs revision', each showing the teacher's note and a Revise button
Two pieces of work sent back. The teacher's note sits on the card, so the fix starts right here. Demo data.
Progress bar at 0% reading '1 thing left to turn it in', with Leave for now, Draft saved, and Submit challenge
Working: what's left, in words.
Reflection box with the prompt 'Tell us about it' and a counter reading '0 words · at least 5 needed'
Not ready yet: the reflection says exactly what it needs.
Yellow notice reading 'Your teacher asked for changes' with the teacher's note
Sent back: the teacher's words, first thing on the page.

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 Product Capability Atlas in Mission Control: eight roles with proven-state progress bars, and one capability's flow beside its state-coverage list, each state marked proven, partial, or not built
The Product Atlas: every role, capability, and state, with the proof behind it.

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.

Before and after of the assignment hero. Before: 72% of pixels behind the title under 3:1, worst spot 1.12:1. After: none under 3:1, worst spot 5.26:1, same hero height.
Demo data. Contrast sampled behind the title with the text hidden.

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.

Wynn resubmits after a teacher's note. Demo data, recorded from a local build.

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.

'New badge unlocked: Team Player' popup on a student's home page, shown still because reduced motion is on
Casey's teacher approved her work while she was away. Demo data, recorded from a local build.
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.

My Assignments page in the Trailhead theme: green sidebar navigation on a warm cream background
Trailhead, the theme that ships.
The same My Assignments page in the Field Journal theme: a dark top navigation bar instead of a sidebar, with different type and spacing
Field Journal, one of seven presets built from the same tokens. Same page, same components. Demo data.

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.

CI log from the Atlas integrity check failing a pull request because a new admin page had no Atlas entry
The gate in action. A new admin page shipped without an Atlas entry, so CI failed the pull request until the page was mapped. Real log, trimmed.

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.

← All case studies