Crawl, Walk, Run: The Case for Building Confidence Before Building Scale
Every ambitious project has the same failure mode: trying to run before proving you can crawl. The Crawl-Walk-Run framework isn't just a phasing strategy — it's a leadership philosophy that treats uncertainty honestly, builds organizational trust through demonstrated results, and creates natural decision points where "stop" is a valid and respected outcome.
2–3 min read
Key Takeaways
- Each phase earns the right to proceed. Crawl proves feasibility. Walk proves value. Run proves scale. No phase assumes the next is guaranteed.
- Decision gates are permission to stop. Planning for "stop" as a valid outcome changes how leadership evaluates risk and how teams approach uncertainty.
- Standalone value at every phase. If it ends after Crawl, you have clarity. After Walk, a working tool. Nothing is wasted.
- The framework sells itself. A three-week proof of concept is easier to approve than a six-month commitment. Let results at each gate make the case for the next phase.
The Problem With Big Plans
Engineering leaders love comprehensive roadmaps. A fully scoped plan with timelines and a clear end state feels responsible. It looks good in a review deck. It's also how most ambitious projects fail.
Not because the plan was wrong — but because it assumed certainty that didn't exist yet. Will the integration actually work? Will the team adopt the tool? Will performance hold at real-world scale? Will leadership still care in three months? A comprehensive upfront plan treats all of these as answered questions. They're assumptions — and every wrong assumption costs more to correct the further in you are.
Why Crawl-Walk-Run Works
Break the project into three phases, each with its own deliverable, success criteria, and decision gate. Each phase earns the right to proceed to the next.
Crawl proves feasibility. Build the smallest possible version that answers the core technical question. The deliverable is evidence, not a product.
Walk proves value. Build the version people can actually use — the integrations, the interface, whatever turns a proof of concept into a daily tool. The deliverable is adoption, not features.
Run proves scale. Add advanced capabilities, cross-system integrations, the reporting leadership wants. The deliverable is organizational impact.
The insight isn't in the phases — it's in what happens between them. The decision gate at the end of each phase is where the real value lives. After Crawl, you ask: did this work? Is the approach viable? If not, you stop. You've spent a few weeks. That's not failure — that's a successful experiment with a negative result.
Most planning frameworks treat "stop" as failure. This framework treats it as a valid outcome planned for from the beginning. You're not asking for approval to build a six-month project. You're asking for approval to spend a few weeks finding out if it's worth building. That's an easier yes.
The framework only works if each phase delivers something real on its own. If Crawl is just "set up infrastructure for Walk," you haven't reduced risk — you've renamed the first month of a waterfall plan. Crawl answers a question. Walk delivers a usable tool. Run expands impact. If the project stops after any phase, the organization is better off than when it started.
How It Changes the Conversation
Approvals: "I want to build X" becomes "I want to spend three weeks finding out if X is viable." Smaller ask, lower risk, explicit commitment to stop if Crawl doesn't work. Gets approved faster.
Scope: When stakeholders want to add features, the framework gives you a natural answer: "That's a Run feature — let's prove Walk first." Not a no — a not yet, backed by structure everyone agreed to.
Accountability: Success criteria at each gate make progress measurable and honest. When something isn't working, the gate surfaces it early — not at the end of a long, expensive build.
Crawl-Walk-Run isn't universal. It's most valuable when uncertainty is high — new technology, unproven demand, organizational skepticism. If you already know the answers, you don't need to crawl first. But in my experience, we know those answers far less often than we think.
Related
Why I Don't Do Technical Interviews for Senior Engineers
By the time someone has a decade of experience on their resume, I already know they can code — and write correct code at that. What I don't know, and what actually determines whether they'll thrive on my team, is whether they're curious, passionate, and wired to build great things. That's what the interview is for.
Read more ArchitectureTaming 50 Million Callbacks with Event-Driven Architecture
A legacy .NET HttpHandler buried inside the customer portal was processing webhook callbacks synchronously — and at 20M+ messages a month, vendor retry storms inflated that to 75 million callbacks with 90-second processing latency. We replaced it with an Azure Function that acknowledges in milliseconds and routes to channel-isolated processors via Service Bus, dropping latency to sub-second and eliminating the retry cascade entirely.
Read more