T.

The Near Impossible Task of Defining an MVP

By In Technology

We set out with the best intentions: we want to be lean and agile, and we are going to put something out into the world that we are “slightly embarrassed by” and we’re going to pivot and iterate from there. Right? That’s how it’s supposed to work.

But in reality, stakeholders never, ever seem to remember what that agreed MVP was. They fixate on a roadmapping session from six months ago or have a visual design comp stuck in their head that shows three features that were agreed to be post-MVP items.

Why Does This Happen?

  1. Memory is Fallible: We can remember talking about something, and knowing it was important, but not remember that we agreed it was out of scope or budget.
  2. Stakeholder Tactics: Some stakeholders might want to squeeze as much as they can out of development teams. They might agree to a smaller scope initially, hoping developers don’t remember the negotiation, or they might be unethically disingenuous.
  3. Lack of Experience: Stakeholders might not have enough experience in product management or development processes. They see software as infinitely changeable and might not grasp why certain features were deferred.

How Can We Stop It?

  1. Do Everything Waterfall: Agile just might not be the best approach for first-time founders, especially non-technical ones. Having clear visual comps of EVERYTHING can ease them into the fast-paced world of tech businesses, though this has many disadvantages.
  2. Hyper-Organization Mode: Developers and PMs can track every decision meticulously. A “Git for decisions” tool would be ideal, where every choice branches out with roadmaps and budgets, showing stakeholders how their decisions impact the project. Without such a tool, a detailed decision journal could work as a good alternative.
  3. Selective Client Engagement: Developers might choose to avoid working with first-time, non-technical founders. For products like platforms, where the technology is integral, having a technically savvy founder is crucial. For tech-enabled services, like an app to schedule plumbing appointments, the tech isn’t the core value, so non-tech founders might manage better.

What Can We Replace “MVPs” With?

I’m not sure. We have to launch with something, and that should have some level of definition, but I have three ideas:

Idea 1. Time Based MVPs

Maybe MVPs should be time-based, like launching something after a set period, regardless of what we have. Launch dates could drive everything in this way. Imagine a 90 day launch window after design/discovery has been performed. Then you would have weekly sprints, where the stakeholders are hyper engaged for a short period of time. The theory here is that this focus would cut out all the need for the “who said what when” arguments and everyone would only work on what was needed.

Idea 2. The 5-feature Rule

This is something I’m making up (desperately) on the spot. Perhaps the way we should be working to MVP should have some over arching philosophy about what an MVP even is.

  1. Basic User Management: Ensuring the system can handle user registration, login, and basic user profile management.
  2. Payment Handling: If the application involves transactions, it must handle payments from day one. Keep it simple and avoid novel payment systems.
  3. Performance: The application must perform well on its main targeted platform, device, or browser.
  4. Core Value: It should offer one really interesting, killer, or useful feature to the user. That’s it. Just one.
  5. Baseline Analytics: Include basic analytics from day one to track user engagement and system performance.

Idea 3: The Walking Skeleton Approach

Another approach to replace the traditional MVP is the “Walking Skeleton.” This method focuses on creating a fully clickable interface, essentially a complete UI, built with code, before any underlying logic is implemented. Acting as a pre-MVP, the Walking Skeleton allows stakeholders to interact with the prototype, providing a tangible sense of the final product without the complexity of backend functionality. This method helps stakeholders learn agility by iterating on this version, refining the user experience, and understanding the project’s scope more clearly. Once the interface is polished and aligns with the stakeholders’ vision, features can be prioritized and integrated based on what needs to launch first. Building out the application this way could be a lower stakes method for learning collaborative development, but it also doesn’t throw the baby (or code) out with the bath water.

Conclusion

By simplifying the MVP to these core elements, maybe we can mitigate the confusion and ensure everyone is on the same page about what the initial product will deliver. I prefer to end my posts the same way ChatGPT does, with a positive conclusion. But today, I’m less sure I can do that. I’ve read countless books, articles, and posts on how to define an MVP. I’ve helped launch hundreds of tech companies, and I’ve launched a couple of my own as well. So why is so difficult to launch when working with well-intentioned, intelligent, well-funded, people who are going through this process for the first time? I’m going to at least try Time Based MVPs and my new 5-Features rule on my next two projects and see if that helps. Wish me luck.

Previous ArticleNext Article
I help companies turn their technical ideas into reality.

CEO @Sourcetoad and @OnDeck

Founder of Thankscrate and Data and Sons

Author of Herding Cats and Coders

Fan of squash, whiskey, aggressive inline, and temperamental British sports cars.

Leave a Reply

Don’t Fall Into the Trap: Why Startup Software Development Isn’t Like Corporate Development

In Startups, Technology

So, you’ve left the corporate world, and now it’s time to build your own startup. You’ve probably managed dev teams before, overseen product launches, maybe even helmed some fancy project management tools that made everything run like a well-oiled machine. You’ve done this before, right? Not exactly. When it’s your startup, everything changes—and, as I’ll explain, if you assume it’ll work the same way, you’re heading for a few surprises.

Startup founders often fall into a dangerous trap when starting a software project from scratch: thinking it’ll be just like building software inside an established company. Here’s why it’s not—and some advice on how to navigate the differences.

1. Switching from Product Manager to Teacher

In an established company, a software team already has two things that give them a serious edge: an existing market and a deep understanding of the business. They’re working within a proven model. Developers in that environment know what questions to ask, can fill in gaps intuitively, and likely understand why they’re building what they’re building.

At a startup, however, your devs are going to need a whole lot more context. They’re not working with familiar requirements—they’re working with your vision, which may be abstract at this stage. If your development team doesn’t understand why something matters, it’s a recipe for ambiguity and frustration on both sides.

Advice: Think of yourself less as a product manager and more as a teacher. Your job is to make sure they understand the core problems, not just the features. Teach them why each requirement matters, help them visualize the end-user, and create that shared language for decision-making. It might feel tedious, but it’s essential to avoid future misalignment and expensive rewrites.

2. Beware of Perfectionism — It’s the Budget Killer

In a large company, products with an existing user base often have to be polished. Features need to be rock-solid, invoices have to be perfect, and everything needs an audit trail. Startups, however, have a different goal: get an MVP in the hands of users fast. It’s a classic trap for first-time founders—focusing on “perfection” and “polish” before knowing if the business model even works.

Startup perfectionism is budget poison. It’s shocking how quickly adding “nice-to-have” features can chew through funding, especially if you’re paying a dev team to build things like automated invoicing or churn management before you’ve even proven people want what you’re selling.

Advice: Ruthlessly strip down your MVP. If a feature doesn’t help you validate your market, it goes on the “later” list. Keep the scope laser-focused on what helps you test your business assumptions. Let the non-essential features wait until you know you have customers who’ll use them.

3. Zen and the Art of the Startup Pivot

Building software for a startup means embracing one cold, hard truth: the business model will change. According to research, 93% of successful startups pivot at least once (and often more). Imagine being asked to go out and passionately sell something that you know might not look the same next year—or next month. It takes a level of zen acceptance that your original idea will likely morph, but that’s what keeps you flexible and ready to capture new opportunities.

For founders, that requires a mindset shift. You have to believe in your product, while also knowing you might be building the “wrong thing” in some way. The focus should be on preserving capital and brainpower for what’s next. The game is less about proving you’re right and more about staying adaptable.

Advice: Budget with pivots in mind. Set your burn rate assuming you’ll need to make big changes. Don’t let ego get in the way of listening to the market, and keep enough gas in the tank for at least one big strategic turn.

4. The Hard Work of Being Your Own “Internal Customer”

Here’s another big one. In a corporate environment, you have internal customers—departments or stakeholders with specific goals that align with the overall company mission. For a startup, the only customer you have is you. You don’t have a preexisting feedback loop from various departments, and you don’t have established success metrics. You have to create that from scratch.

Advice: Start by building an internal customer profile based on your target market, then use that to set clear goals and success criteria for your dev team. If you’re focused on, say, usability for early adopters, set KPIs around usability testing and build from there. By acting as your own “internal customer,” you’re setting a clear direction and saving your team from working in a vacuum.

5. Get Ready to Build AND Sell

Corporate software development often has the luxury of a separate, dedicated sales team to deliver the product to the right audience. As a startup founder, you’re both the builder and the seller. That means you’re not just iterating on software—you’re iterating on messaging, product-market fit, pricing, and maybe even distribution models.

Advice: Factor in time for sales-ready iteration in your dev cycle. As you build, keep track of how each release or update affects the user experience. Ask yourself if the changes make your pitch clearer or simpler and how they align with the current market’s needs. Ultimately, this approach will help you bridge the gap between building the product and ensuring it’s market-ready.

Conclusion

Building software as a startup founder requires a whole different toolkit than you may be used to. You’re part-teacher, part-salesperson, part-zen master, and always the chief budget officer. By recognizing the unique mindset shifts and traps of startup software development, you’re positioning yourself—and your team—for the best chance of success. Focus on creating clarity for your team, set ruthless priorities, embrace change, and never lose sight of the fact that the first version is just the beginning. In the startup world, adaptability isn’t just a skill—it’s the entire game.