• 

  homepage ui

• 

  archive

• 

  genie chat

• 

  library

• 

  profile

• 

  v0 and vercel architecture

• 

  dynamo db architecture

Storybook: Interest-Led Learning Adventures for a Million Kids

Storybook is a full-stack learning platform for the Million-scale global app track. It turns a child's interests into interactive, illustrated lessons so learning starts from what already has their attention: dragons, space, dinosaurs, animals, sports, games, mysteries, or whatever they are locked into that week.

The product bet is simple: children do not need less structure. They need lessons that meet them through subjects they already care about. Storybook uses AI to help parents create those lessons, DynamoDB to store child profiles, lessons, progress, schedules, archive publishing, reactions, and assignment metadata, and Vercel/Next.js to ship a responsive app that can scale without a traditional server fleet.

Track: Million-scale global app
AWS database: Amazon DynamoDB
Frontend: Vercel-hosted Next.js
Core idea: turn children's interests into interactive lessons they actually want to finish.

Inspiration

I built Storybook around a problem I have felt directly: people, including me, learn better when the material connects to what they already like. A child who is obsessed with space should not have to leave space behind to learn fractions. A child who loves fantasy should be able to learn reading comprehension through a dragon rescue. A child who likes animals should be able to practice science through a habitat mystery.

That instinct is backed by learning research. Interest Matters: The Importance of Promoting Interest in Education describes interest as a motivational process that energizes learning and supports academic success. RAND's brief on personalized learning and student achievement reports early evidence that personalized learning can improve achievement across different starting levels. Early childhood guidance on interest-based child learning also points to interest as a way to sustain children's engagement with people, materials, and ideas.

Storybook turns that into software: instead of asking every child to adapt to the same worksheet, it adapts the lesson into a story world the child actually wants to enter.

What it does

Storybook helps a parent or educator create personalized lessons for a child. The parent can describe the goal, schedule the lesson, attach assignment material, choose a format, and ask Genie, the parent-facing lesson assistant, to help shape the plan.

The app then creates an interactive lesson session made of structured blocks: story scenes, decisions, multiple-choice questions, fill-in-the-blank prompts, charts, tables, matching activities, math blocks, hints, and completion screens. For story lessons, the system can generate illustrated scene images and attach them to the lesson flow.

Children experience the lesson as an adventure. They read, make choices, answer questions, get feedback, and move through a lesson that feels built for them. Parents can review progress, schedule more lessons, organize a lesson library, and publish good lessons into an Archive where other families can discover, like, favorite, and import them.

Who it serves	What Storybook gives them
Children	Playable lessons built around their interests, with story choices, visuals, feedback, and progress
Parents	A planning assistant, lesson library, schedule, profile controls, and a review step before lessons are saved
Educators	Reusable lesson structures that can adapt the same concept to different learners
Other families	Archive discovery, imports, likes, favorites, and share codes for lessons worth reusing

How we built it

Storybook is built as a Vercel-hosted Next.js application with Amazon DynamoDB as the primary database. The architecture is organized around the lifecycle of a lesson: plan it, generate it, review it, play it, measure progress, and optionally publish it for other families to reuse.

Architecture rule: generation is not the product. The product is the durable learning loop around generation: profile, plan, lesson, interaction, progress, revision, and reuse.

The main architecture decision was to treat lessons as durable structured data, not as one-off generated text. A Storybook lesson is stored as a sequence of typed blocks: scenes, choices, questions, math interactions, charts, hints, and completion states. That lets the app render lessons consistently, track progress at the block level, revise individual parts, and reuse lessons in the Archive without regenerating everything from scratch.

The second architecture decision was to model the app around user-scoped access patterns. DynamoDB stores child profiles, lesson libraries, schedules, progress events, assignment metadata, published Archive lessons, and lightweight social reactions. Those records are the natural shape of the product: a child has many lessons, each lesson has many blocks and progress events, and public lessons can collect imports, likes, favorites, and remix activity. DynamoDB is a good fit because AWS positions it as a fully managed serverless database with low-latency performance at scale, and Storybook's core workload is many small reads and writes across many learners.

The third architecture decision was to separate planning from generation. Genie is the parent-facing assistant that helps turn a rough request into a lesson plan. Behind that, specialist lesson agents build the actual lesson in structured steps. A story lesson, for example, is not just "write a story about fractions." It needs a setup, teaching moments, choices, checks for understanding, optional generated scenes, and a satisfying wrap-up. This separation keeps the parent experience simple while giving the generation system enough structure to produce something the app can actually play.

The fourth architecture decision was to make sharing part of the data model instead of bolting it on later. The Archive lets a useful lesson become a reusable learning asset. Publishing, importing, liking, favoriting, and share codes are all backed by the same database foundation as the private lesson library, so the app can grow from single-family use into a global catalog of interest-led lessons.

For the H0 stack, Storybook uses Amazon DynamoDB as the required AWS database and Vercel/Next.js for the deployed application layer. Supporting storage is used for uploaded assignments and generated visual assets, while the lesson and product state stay centered in DynamoDB.

Architecture decision	Why it matters for a million-scale learning app
Lessons are structured block data	Lessons can be rendered, edited, replayed, measured, and shared consistently
DynamoDB is the primary database	The workload is many learner-scoped reads and writes across profiles, lessons, progress, schedules, and Archive activity
Planning and generation are separate	Parents get a simple assistant, while specialist agents can produce complete playable lessons behind the scenes
Archive sharing is part of the core model	Great lessons can spread through import, remix, like, favorite, and share flows without redesigning the system later
Vercel hosts the application layer	The frontend and API routes can scale with traffic while DynamoDB handles durable state

Challenges we ran into

The hardest product challenge was keeping personalization structured. It is easy for an AI lesson generator to produce a nice paragraph. It is much harder to produce a playable lesson made of valid blocks, correct choices, images, feedback, and a completion state. Storybook solves this by forcing lesson specialists to call structured tools and validate the draft before the app treats it as a lesson.

The second challenge was data modeling. A million-scale learning app cannot treat every feature as a separate isolated table without thinking through access patterns. Storybook's DynamoDB layer keeps the core entities close to the read patterns the UI needs: profile state, library state, schedules, lesson blocks, archive lessons, archive reactions, and assignment processing.

The third challenge was making sharing safe and useful. The Archive is not just a social feed. Published lessons snapshot sharing settings such as whether imports are allowed, whether generated images are included, and whether progress summaries are included. That lets Storybook support remixing while respecting parent-controlled privacy choices.

Accomplishments that we're proud of

Storybook is more than a demo prompt box. It has a real product surface: parent profiles, child profiles, lesson planning, advanced scheduling, assignment upload support, a lesson studio, a lesson library, playable interactive blocks, generated story scenes, archive publishing, archive import flows, likes, favorites, share codes, and DynamoDB-backed state.

I am especially proud of the separation between planning, creation, review, and publishing. Genie helps plan. Specialist agents build. Lesson Studio lets the parent review and revise. The Archive lets successful lessons become reusable learning assets. That is the shape of a product that can grow from one family to many families without changing its core architecture.

What feels shippable: Storybook already has the loop a real learning product needs: create a lesson, play it, track it, revise it, organize it, and publish the best versions for reuse.

What we learned

The biggest learning was that "personalized learning" needs product discipline. If every lesson is generated differently but cannot be edited, saved, measured, shared, or trusted, it is not a platform. It is just output. Storybook's structure turns generation into reusable educational software.

We also learned that DynamoDB is a strong fit for this kind of product because the access patterns are high-volume, user-scoped, and event-like. AWS describes DynamoDB as a fully managed serverless NoSQL database with single-digit millisecond performance at any scale, which matches the needs of a learning app where each child accumulates many small records over time.

Finally, we learned that the strongest use of AI here is not replacing the parent or teacher. It is removing the blank page. The adult still chooses the goal and approves the lesson, but Storybook handles the heavy lift of turning that goal into something a child wants to play through.

What's next for Storybook

The next step is to turn Storybook from a working product into a learning network. That means stronger progress analytics, classroom groups, multilingual lesson generation, richer teacher controls, safer public Archive discovery, and better recommendation loops based on what actually helps a child finish and understand a lesson.

For scale, the next technical step is to harden the DynamoDB access patterns around global growth: stricter indexes for Archive discovery, more granular progress events, TTL for transient assignment processing state, background processing for uploads, and regional deployment planning for Vercel Functions alongside AWS services.

Next area	Direction
Learning analytics	Mastery trends, skill maps, comprehension history, and parent summaries
Classroom mode	Group lesson assignment while keeping each child's path personalized
Global reach	Localization, translated story generation, and culturally flexible lesson themes
Archive quality	Search, moderation, remix lineage, and public lesson pages
Scale hardening	DynamoDB index tuning, background processing, observability, and regional planning

Public build writeup

I also published a public build story for the H0 Hack the Zero Stack Hackathon: Storybook: What Game of Thrones Taught Me About Learning.

Built With

• typescript