From Alpha to Beta: What 75 Days of Building a Startup Sim Taught Us About Teaching Startups

TL;DR: In 75 days we went from first commit to beta on Forward, our startup simulation game. We shipped Day 1, built too much before testing with users, discovered nobody understood the product, ripped up the onboarding, and rebuilt it as a guided experience. Every mistake we made is a lesson the game tries to teach. The irony wasn't lost on us.

Note: This post covers the period when Forward was still called Runway. We've kept the original name throughout for authenticity.

There's something ironic about building a product that teaches entrepreneurship. Every lesson we try to teach our players — about shipping fast, listening to users, knowing when to pivot — we had to learn ourselves. In real time. With real stakes.

On October 24, 2025, we pushed our first commit. 75 days later, we flipped the switch on our beta. This is the story of what happened in between — and what it taught us about building, breaking, and rebuilding something from scratch.

Day 1: Just Ship It

The very first day of Runway tells you everything about how we work. We pushed 10 commits in a single morning. The first was the Flutter app itself. The second was trying to deploy it. The next eight were fixing everything that broke.

Vercel build limits. Deprecated flags. Compilation errors. Missing configs. We just kept pushing.

By lunchtime, we had a live app. It was rough. It barely worked. But it existed in the world, and that mattered more than polish. If Runway teaches one thing, it's this: the gap between "idea" and "something real" is smaller than you think — and you should close it as fast as possible.

Week One: The Scaffolding

That first week was pure construction. We built a welcome screen, a messaging system with AI characters, and the beginnings of a game loop. Players could create a startup, chat with an AI mentor, and... that was about it.

It was enough to see the shape of what we were building. An AI investor named after a real archetype. A chat interface that felt like texting a friend. A dashboard that showed you how fast your money was disappearing.

We weren't building features. We were building a feeling — the low-grade anxiety of watching your runway shrink while trying to figure out what to build next. If you've ever founded a company, you know that feeling. We wanted everyone else to know it too.

November: The Month That Changed Everything

If October was about scaffolding, November was about building the actual house. In 30 days, we pushed 116 commits. That's not a typo.

We built the customer discovery system — a full pipeline from first conversation to paying customer. We built a team management system with skills and assignments. We built a decision engine that generates realistic dilemmas, processes consequences, and updates your game state. We built a world generator that creates unique NPCs, market conditions, and starting scenarios for every new game.

We also built something we didn't plan to build: a comprehensive error handling system. Because when real people started using Runway, real things started breaking.

The Refactoring That Had to Happen

Midway through November, we stopped adding features and looked at what we'd built. The diagnosis wasn't pretty:

Customer data was stored in memory. Close the app, lose your work.
13 database tables were using raw, untyped maps. No compile-time safety at all.
Errors were being silently swallowed. Users would see a blank screen and have no idea why.

We spent a focused sprint fixing all of it. Created proper data models for every table. Added real error messages with retry buttons. Integrated Sentry for crash monitoring. Removed 2,176 lines of dead code.

It was the least glamorous week of the entire project. No new features. No visible progress. Just the kind of infrastructure work that makes everything else possible.

This is another lesson we try to teach in Runway: sometimes the most important work doesn't look like progress. Paying down tech debt, fixing your foundation, slowing down to speed up later. It's not exciting. It's essential.

The Advance-Round Overhaul

The advance-round function is the heart of the game. It's the engine that processes everything when a player ends their month: team assignments resolve, financial calculations run, customers churn or convert, and AI generates narrative for what happened.

When we audited it, we found 20 bugs. Race conditions in customer churn. Revenue being counted twice. Founder salaries missing from burn calculations. Market penalties that were written in the code but never actually applied.

We fixed all 20. Added circuit breakers for AI calls. Made everything idempotent so retries are safe. Cut narrative generation time by 4x through parallelization.

The lesson: your core loop has to be rock solid. Everything else is built on top of it. If the foundation has cracks, every feature you add amplifies those cracks.

The Humbling: Nobody Knew What to Do

By the end of November, Runway was feature-complete. We had customer discovery, product development, team management, financial tracking, AI conversations, a decision system, energy mechanics, skill trees. Everything a founder needs to run their startup.

So we put it in front of people.

And they were lost.

Not because the features were broken. Because there were too many of them. New players would open the app, see five tabs with dozens of options, and freeze. They didn't know where to start. They didn't understand why they should talk to customers before building product. They made random decisions and got confused when things went wrong.

We had built a sandbox and handed it to people who needed a guided path.

This was our biggest lesson. Not a technical one — a product one. The same lesson we teach in Runway's customer discovery module: build for your user's reality, not your assumption of their reality.

We had assumed players would figure it out. They didn't. We needed to rethink the entire first experience.

December: Story Mode

December was Story Mode month. We redesigned the first three rounds of the game from scratch.

Instead of dropping players into a sandbox, we created what we call "Founder Moves" — a vertical stack of cards that guide you step by step through your first decisions. Pick your target customers. Choose what assumptions to test. Decide whether to build product or talk to people first. Review your finances. Advance the round.

Each card does one thing. Each thing teaches one concept. By the end of three guided rounds, players understand the core loop: discover, validate, build, sell. Then the sandbox opens up.

Building Story Mode forced us to articulate what we actually believe about entrepreneurship education. We had to decide: what's the first thing a founder should do? What's the most important concept to teach? What order do things go in?

Our answer: customers first. Always. Before you write a line of code, before you design a logo, before you hire anyone — go talk to the people you think you're building for. Story Mode makes that the literal first step.

The Venture Journey

While building Story Mode, we also rethought how the main game interface works. The old design had five tabs: Overview, Customers, Product, Team, Finance. Functional, but fragmented. Your startup journey felt like switching between spreadsheets.

We replaced it with a single vertical timeline. Every action — a customer conversation, a product decision, a new hire — becomes a card on your journey. You scroll through your startup's history like a feed. Each round is a chapter.

We were inspired by Duolingo's lesson structure: clear progress, visual momentum, one thing at a time. The cards make it obvious what you've done, what's happening now, and what comes next.

January: The Last Mile

January was about polish. We built a proper design system — consistent colors, typography, spacing, components. We created a marketing website. We added a beta access code to the welcome screen.

That beta gate was the last commit before this post. One small feature that represents a big shift: we're no longer building for ourselves. We're building for the people who'll use this to learn.

What We Learned (The Meta Version)

Here's what's funny about this whole journey: we experienced exactly what Runway is designed to teach.

We shipped before we were ready — and that was right. Our Day 1 deploy was held together with duct tape, but it forced us to confront real problems immediately.

We built too much before talking to users — and that was wrong. If we'd put a rough version in front of people in October instead of November, we'd have discovered the onboarding problem a month earlier.

We had to pay down tech debt — because moving fast creates mess, and mess eventually slows you down more than the speed gained.

We pivoted our approach — from sandbox-first to guided-first. Not because the sandbox was bad, but because we were wrong about what users needed first.

We focused on the core loop — and the 20-bug audit of our advance-round function was more valuable than any single feature we built.

Every one of these lessons is something Runway tries to teach. We just happened to learn them the hard way, by building the thing that teaches them.

What's Next

We're in beta now. A small group of players and educators are testing Forward (we've since renamed it from Runway), and every session teaches us something new. The feedback loop is tight: someone gets confused, we watch where they got stuck, we improve the flow.

We're not done. The game needs more depth in later rounds. The AI characters need better memory. The financial model needs more nuance. And we have an entire skill assessment system designed but not yet built.

But the foundation is solid. The core loop works. And the first-time experience finally does what it should: it makes you feel like a founder.

If you're curious, we're accepting beta users now. No experience required — just curiosity and the willingness to make some decisions and see what happens.

That's really all entrepreneurship is, anyway.