In recent years, I’ve noticed MVPs increasingly being used as an excuse for chaotic code. No clear separation between components? Whatever, it’s the MVP. Your senior developer just left? It’s OK, AI will clean up his code structure.

The problem with these ‘quick’ fixes is the post-release aftermath. What happens when users look for more? How easily can you add new features to your AI-built code? How quickly can you make the repetitive software integrate with other programs?

Chances are: not easily, and not quickly. Launching MVPs as fast as most startups want to launch demands shoddy, illegible structure. Yes, you’ll confirm it’s viable, but vitalizing it into its next iteration takes ages.

A true MVP, however, - an MVP as I know and build - has a sound architecture, and can easily scale into its next version. Contrary to modern misinterpretations, ‘minimum’ isn’t synonymous with fast; it correlates to smart reduction.

Cutting corners: Design & prototyping

The first step to reducing smart is knowing where you can cut back, and where you can’t.

In my experience, prototypes fall into the first category. Low- or high-fidelity wireframe, more than once clients have asked me: “why is everything black and white?” Another common comment is “I gave you pictures, why aren’t they here?”.

By nature, humans are visual beings. As such, with prototypes, stakeholders hone in on the design rather than the functionality. Static wireframes are particularly challenging; clients struggle to understand UX unless they can experience it themselves, alive in real time.

The main takeaway here is: your time is better spent outside of design processes. This is an ideal opportunity for AI to assist you. For example, I often use v0.dev. Input your prompt, and the tool generates UI code, quickly delivering common elements like dashboards, cards, tables, etc.

The AI approach works here because web and mobile apps are built on familiarity. Think of the hamburger menu; almost every UI uses it. Think of Instagram’s and Whatsapp’s bottom navigation bar; there’s a reason the design is practically identical.

The elements AI will generate for you are broadly applicable - about 70% of your app will be made up of these patterns.

That’s not to say you should remove human creativity altogether. Get designers involved where it really matters: working on the 20% that makes your idea unique.

For example, let’s say you’re launching a second-hand selling app like Depop. You want the user content upload to function seamlessly. For that component, ignore AI. Brainstorm with developers, host a 2-week sprint, and test critical user flows. That way, you’re focusing your time and energy on validating what truly makes your app different.

Now that you’re 90% of the way there with your prototype, the only 10% that’s really left is the branding. Again, get your designers involved to create a cohesive, intuitive “look and feel”. The goal is clean, consistent, and functional - not pixel-perfect, but enough that your MVP looks decidingly like your MVP, in your colors and style.

Stick to this 70:20:10 approach, and you’ll drastically speed up your prototyping process. Automate what you can, focus on what really matters, and get your basic design out the door fast.

Dig in your heels where you have to: Development

All that time AI saved on your prototype? Get ready to re-invest it into development.

If users do indeed validate your MVP, they’re going to want the next iteration with new, upgraded features. And the more stable your initial MVP is, the easier you’ll release said next iteration. Your MVP needs a clear, structured architecture - a solid foundation on which to build its next version.

One way to go about this is focusing on development ‘starter packages’. In particular, frontend, backend, and mobile starter packages that already encompass several pre-built components. Common features include:

user management (registration, login, password reset, user invites)
permission management (role-based access control)
basic API architecture and security layers

These elements are present in nearly every modern-day software. Yet, building each one of them well can take weeks of development and testing.

This is where starter packages come in. Instead of re-building each feature over and over, you’re simply inserting the pre-built package into your existing codebase. You’ve also avoided the possible new bugs and security gaps that come with building each component from scratch. Instead, they’re ready-made to be implemented.

This tactic of sticking to the minimum amount of effort, while still ensuring quality, should be your mantra throughout MVP development. This also applies to the number of features implemented. Very often, I’ve seen startups get swept away by the excitement of their new product, and keep building without first completing an MVP’s most basic function: validating if there’s a user need.

What you end up with is an MVP released as full-blown, sophisticated software rather than as a ‘minimum’ product. Contrary to popular belief, your fast tracking app does not need a calorie counter. It only needs to record the time spent while fasting. Then, if users do indeed show interest in the app, you can scale it further.

That being said, your app’s next iteration depends on your users. That calorie counting feature you loved? It’s entirely possible users won’t show any interest. Instead, they want gamification: badges and banners they can win based on the length of their fast.

In other words, you don’t know what users want, not until you release your software. Don’t bloat and embellish your MVP prematurely with user wishes, you, the developer, have come up with. Keep it simple - launch, validate, ask your users’ feedback and only then iterate.

Find a balance between artificial and human intelligence

No matter how talented the developer, how creative, Artificial Intelligence is always the quicker coder. As such, it’s no surprise that so many developers fall back on the effortless task of copy/pasting ChatGPT outputs; the codebase will be finished in nearly half the time than if they had written everything independently.

However, the copy/paste tactic works much better in certain situations than in others. Personally, I liked to turn to Claude for repetitive, predictable tasks. Writing boilerplate code is my most common use case. Generating CRUD components and pagination are other activities AI pulls off seamlessly each time.

However, the moment you begin building something more complex, AI’s capabilities falter. Designing a clear architecture, with classes and functions that other programs can easily import, should be left to human intelligence. Ensuring your software is modular and adheres to microservices architecture can only really be accomplished by a human developer. Scalable and architectural decisions must be made by the human mind. After all, coding is, at its heart, theory-building - not simple source code production.

If you do just copy AI’s code output for these more structural coding decisions, you’ll wind up with no clear architecture and lines of code stuffed with technical debt. The software might function on a surface level, but its codebase will be illegible and convoluted, accompanied by unclear code ownership and onboarding issues. Most likely, you’ll end up having to refactor the entire thing within a year.

The Develo approach: Building MVPs that scale

Having lived through countless launches, today we here at Develo can proudly say we’re battle-tested experts when it comes to MVPs. Project after project and sprint after sprint, we’ve distilled our experience down into a tried-and-tested formula that produces the best possible MVP and delivers the most ROI for our clients.

To start with, we’ve developed ready-to-go frontend, backend, and mobile starters that include all core functionalities. This includes basic API architecture, registration, login, and more. Security layers and permission management are also included. That way, we aren’t re-inventing the wheel with every new codebase; all the components are ready and waiting to be included.

Similarly, when we start building the software, modularity and scalability is our top priority. Handles increasing load, user caching, and asynchronous processing are all non-negotiables. That way, you can retain the bulk of your existing codebase later with the next interaction.

We’ve also found that a general-purpose design system looks best. Our designs are fully tokenized; you’ll find our colors, spacing, and typography defined via design token. We also leverage custom CSS (not Tailwind). This facilitates editing, and provides clearer code for new developers, easing the onboarding process. It also means rebranding, if necessary, shouldn’t be too much of a hassle.

Finally, all work is documented in Storybook - a frontend workshop for building UI components and pages in isolation. With this visual documentation, the entire design process is much cleaner.

Although this approach might not seem as fast as other MVP launches, it’s sturdier, it’s scalable, and it’s stable. Yes, you might spend an extra week or so in the short-term, but in the long-term? You’ll save months of refactoring what would have otherwise likely been Frankenstein code.

Minimum means smarter, not speedier

In 2001, Frank Robinson defined MVP as follows:

“The MVP is the right-sized product for your company and your customer. It is big enough to cause adoption, satisfaction and sales, but not so big as to be bloated and risky. Technically, it is the product with maximum ROI divided by risk.”

An MVP isn’t fast, or small, or chaotic. An MVP accomplishes a small user need - say, for example, tracking a fast - but it does so at the right size. Structurally sound enough to scale, with a clear enough architecture to handle new integrations and features. The fast-tracking capability is only useful insofar as it stands on solid foundations and can grow easily.

Ultimately, in the MVP phase, you’re not concentrating on perfection. Instead, you’re laying the groundwork for direction, while balancing scales of speed and structure. Too much speed, and you get chaos. Too much structure, and you’ll never launch the software.

But - balance the two effectively, and you’ll get your ideal MVP. A right-sized software that answers a user need, and is ready to effortlessly scale into the next iteration.

If you’re planning your first MVP, schedule a chat with us. See how Develo can help you build faster, scale smarter, and launch with confidence.