Craving the unexpected. And then making it happen
You know the moment when something that lived only in your head is suddenly on a screen in front of you, real enough to click on. We built Launchpad for that moment.
You’ve spent years understanding the problem, and you know the market and the users. What you haven’t had is three unhurried hours in which all of that meets a team of engineers. That is what Launchpad is. You bring your expertise, and at the end there is a prototype that didn’t exist that morning.
What happens when two worlds meet
Launchpad is a working conversation between your domain expertise and our engineering experience. Neither side knows at the start exactly what will come out of it.
You bring the knowledge. We bring the architecture, the feasibility questions, and the ability to build what you’re describing while you’re still describing it. It’s for people who’ve done the thinking and want to see where it leads.
The session runs for three hours in three acts and ends with one prototype. There is also a twist, which we’ll get to.
Act 1: Unpack
We begin by talking. You describe your idea, and together we pull it apart. Every feature you describe becomes a card on the table, and we ask the technical questions as they come up: can this scale, what’s the data model behind that, is this a build-or-buy decision, and where are the integration risks?
Along the way the features get clearer, assumptions come to the surface, and the vague parts of the idea firm up because we’ve gone through them together.
While all of this happens, something else is already taking shape in the background. More on that in act 3.
Act 2: Distill
Your idea is now a stack of feature cards, each one technically vetted. You can’t build all of them at once, so we use three exercises to help you decide what comes first.
Complexity Poker. You get a handful of tokens (think of them as dev-months) and spread them across your features. Often the feature you thought was essential gets two tokens while the “nice-to-have” gets six, and that gap shows you where your priorities really are.
Drop it. You cut the feature you’re attached to, and circle the skull on the ones that don’t make it. What’s left is a leaner product, with a reason behind every cut.
Constraint Rounds. Scenarios like “Your first 100 users only need…” or “You launch in 8 weeks with just…” force you to choose. We note the technical dependencies as you go and point out where cutting one feature affects another, so you can see the architecture behind your choices.
By the end, the messy stack of features has become a prioritized shortlist that we’ve checked technically.
Act 3: The Reveal
This is the part we didn’t tell you about. While you were unpacking your idea and weighing priorities, we were building alongside you and turning each decision into architecture as you made it. The features that survived went onto screens, and the ones you let go were dropped.
Then we turn the screen around and show you your idea as a prototype you can click through, one that looks and feels like a real product.
Something you’ve been carrying around for months, maybe longer, now exists outside your head. You can tap through it, show it to your co-founder, your investors or your team, and say “this is what we’re building.”
From there, we refine it together. We shift layouts, rework flows and add screens for onboarding, live with you, until it feels right.
Why the unexpected works
Three hours with nothing else on the table make it easier to focus. The noise falls away, and the decisions you make tend to be the right ones.
You’re sitting with engineers who can tell you whether something is feasible, what the tradeoffs are, and how they’d approach building it. By the time you leave, you’ve seen them do it.
The exercises are games on purpose. Prioritization frameworks can feel sterile and political. When you’re smiling while letting go of a feature, you make better decisions than you would in a conference room with a whiteboard.
And a prototype does something a requirements document can’t. Once you see your idea take form, technically validated, it stops being abstract.
You leave with a clear sense of what to build, and with a prototype that shows it.