ShipingIt

Learn to ship, not just dream. ShipingIT turns startup and app-building skills into playful missions where you uncover real needs, prototype solutions, test ideas, and launch your first product.

Comment

Inspiration

Ideas are easy.

Shipping is hard.

A student can have an idea for an app in seconds. But then the questions start.

Who actually needs this? What should I build first? Is my idea solving the right problem? How do I test it? And when is it ready to ship?

There are thousands of resources that teach programming, design, and entrepreneurship. But knowing those skills individually is different from knowing how to turn an idea into a real product.

That is the problem we wanted to solve.

ShipingIT is an interactive learning app that teaches students how to go from an idea to something real — by actually building it.

Instead of watching another course about innovation, learners enter a playful world where every lesson moves their own project forward.

Learn it. Build it. Test it. Ship it.

What it does

ShipingIT turns the product-building process into a journey.

Students begin by discovering a problem instead of immediately jumping to a solution. They interview characters, collect clues, identify pain points, separate assumptions from evidence, and decide what is actually worth solving.

Then they move forward.

Insight → Idea → Scope → Design → Prototype → Test → Improve → Ship.

The app includes 8 learning units, 32 core lessons, 97 authored exercises, 24 builder challenges, and six interactive games, designed around one principle:

Every lesson should leave you closer to a real product than when you started.

Ami, ShipingIT's guide, helps learners through the journey. Story chapters introduce concepts in context, while interactive exercises turn them into decisions the learner has to make.

But ShipingIT isn't only a course.

Learners also get a workspace where they can build and experiment with projects such as Lunch Lens, CampusCompass, and StudyBuddy. Each project keeps its own draft, prototype, tests, and notes so learners can iterate without losing earlier work.

Progress earns Sparks, which can unlock customization and additional experiences. Learning becomes progression — but completing a lesson is never the final goal.

Building something is.

Designing learning around doing

One of the most important decisions we made was to avoid turning ShipingIT into a collection of quizzes.

If we wanted to teach product thinking, the product itself needed to encourage product thinking.

So lessons are built around decisions.

Instead of simply explaining user research, ShipingIT asks you to examine evidence.

Instead of defining an MVP, it asks you to decide what belongs in one.

Instead of describing prototypes, it gives you something to build and test.

And instead of telling students that iteration matters, their projects actually change as they learn.

The result sits somewhere between a learning app, a game, and a lightweight product-building environment.

That combination became the core experience of ShipingIT.

Validation

26 students, from high school to university, tried ShipingIT.

  • 17 completed all missions.
  • 11 reported a better understanding of product validation afterward.

I used their feedback to refine the app, then tested the revised version again before finalizing it for my Shipaton 2026 submission.

How we built it

ShipingIT is built as a mobile app using React Native, Expo, and TypeScript.

We used Expo Router for navigation and Zustand with local persistence for progress and project state. Learning logic is separated from the interface so lesson prerequisites, rewards, recovery, and progression can be tested independently from individual screens.

That became especially important because progression is not simply a list of completed lessons.

If a learner changes an important decision earlier in a project, later work may depend on it. ShipingIT has to understand that dependency rather than pretending nothing changed.

We also wanted the app to feel alive.

Original characters, illustrations, motion, haptic feedback, interactions, and small moments of personality are used throughout the experience. Reduced-motion options and alternative interactions were added so those details do not become requirements for using the product.

For accounts and backend services, we use Supabase.

Optional AI assistance is routed through a server-side backend using OpenRouter, keeping model credentials away from the client. AI-generated responses and authored learning content are deliberately distinguished, and AI does not determine lesson completion or rewards.

That was intentional.

AI should help a student think — not do the thinking for them.

Building monetization into the product

We didn't want monetization to appear as an unrelated paywall added at the end of the project.

So we asked a different question:

What should always be free, and what creates enough additional value that someone might choose to pay for it?

The core learning journey remains available after sign-in.

ShipingIT Pro extends the experience with additional helpers, bonus labs, expanded customization, and Project Pack capabilities.

We integrated RevenueCat to manage offerings, localized pricing, entitlements, purchase state, and restore flows. During development, we use RevenueCat's sandbox/Test Store environment so the complete purchase experience can be tested without pretending that development transactions are production revenue.

RevenueCat therefore isn't just an SDK connected to the project.

It defines a real boundary in the product:

Learning how to build should remain accessible. Power tools can support the business around it.

Challenges we ran into

The hardest problems were not the screens.

They were the invisible systems behind them.

Making progress trustworthy

A reward should only be earned once.

A failed save should recover safely.

One project should never overwrite another.

And if an earlier decision changes, dependent work needs to respond correctly.

Those rules sound small individually, but together they determine whether learners can trust the app.

Making learning feel like building

There is a difficult balance between giving students guidance and simply giving them answers.

Too much explanation turns the experience into a textbook.

Too little structure makes a beginner feel lost.

We iterated around short explanations followed quickly by interaction, decision-making, and building.

Connecting real native services

RevenueCat, authentication, local persistence, AI services, haptics, and mobile behavior all work differently from a static prototype.

We learned that successfully compiling an SDK is not the same as proving that the experience works.

So we separated states such as loading, unavailable, sandbox, restored, and successful instead of hiding them behind a perfect demo.

That made ShipingIT less magical internally — and much more reliable.

What we learned

The biggest lesson from building ShipingIT is also the lesson ShipingIT tries to teach:

Shipping changes how you think.

An idea can sound perfect when it exists only in your head.

Once you turn it into screens, interactions, state, edge cases, pricing, and an actual build, the unanswered questions become visible.

We learned to reduce scope.

We learned to design systems instead of isolated screens.

We learned that playful design only matters when the underlying experience is dependable.

We learned that monetization is a product decision, not just a payment screen.

And we learned that sometimes the most important feature is simply making the next step obvious.

ShipingIT became better when we stopped asking:

"How much can we add?"

and started asking:

"What does the learner need to do next?"

What's next

ShipingIT is already a working Android development preview, but this is only the first version of the idea.

Next, we want to put the complete journey in front of more students and observe where they hesitate, what they skip, what they enjoy, and — most importantly — whether they can take what they learn outside ShipingIT and use it to build something of their own.

We want to improve the curriculum from real learner feedback, expand project-building tools, strengthen export capabilities, validate the full native experience across platforms, and eventually let learners take a project from their first insight all the way to something they can actually share with the world.

Because ShipingIT isn't really about teaching students how apps are made.

It's about helping them experience the moment when an idea stops being an idea.

And becomes something real.

Built With

Share this project:

Updates

posted an update —

Validation

26 students, from high school to university, tried ShipingIT.

• 17 completed all missions. • 11 said they understood product validation better afterward.

I used their feedback to refine the app, then tested the revised version again before finalizing it for my Shipaton 2026 submission.

Log in or sign up for Devpost to join the conversation.

Submission history