The Boring Tech Stack for Your MVP

Matt George

Fractional CTO · Founder of Injuria.ai

What tech stack should we use? I get this question from founders more than any other. They expect a long, complex discussion about the merits of Go versus Rust, or whether a GraphQL federation layer is the right choice for their V1. My answer is almost always a letdown for them. It’s short and simple: use Ruby on Rails. Or Django. Or Laravel. Use a boring, full-stack framework that your team can move fast with.

The goal of a Minimum Viable Product is not to build a perfect, infinitely scalable system. The goal is to find product-market fit before you run out of money. Speed is the only feature that matters at this stage. Every decision you make, especially your technology choice, must be optimized for speed of learning. This isn't the time to innovate on your tech stack. It's the time to build your actual product.

Your Only Goal is Speed to Validation

Let's reframe the entire conversation. You are not building the final version of your company’s software. You are building a probe. You're sending it out into the market to see if your core assumptions are true. Does anyone actually have the problem you think they have? Will they pay you to solve it? That’s it.

Your MVP tech stack is just the rocket fuel for that probe. You need the fuel that ignites fastest and burns quickest, not the one that’s most efficient for a trip to Mars. Most early-stage companies don't die from scaling problems. They die from building something nobody wants. They die from being too slow. Choosing a complex, "scalable" architecture from day one is a classic form of premature optimization. It’s like designing a skyscraper’s foundation for a single-family home. You waste time and money building for a future that might never happen.

My Default: The Boring Monolith

So what does a "boring" stack look like? It’s a monolith. A monolith is an application where all the code lives in a single codebase. The user interface, the business logic, the database access, it's all one unit. This has become a dirty word for some, but for an MVP, it's a superpower.

My go-to recommendations are frameworks that embrace this philosophy:

  • Ruby on Rails: My top pick for most B2B and B2C web apps. It has an incredible ecosystem of pre-built components (gems) for almost anything you can imagine, from user authentication to payment processing. Its "convention over configuration" philosophy means you make fewer decisions and just get to building.
  • Django (Python): Another fantastic choice, especially if your product has data science or machine learning components, or if your team already knows Python. It’s slightly less "magical" than Rails, which some developers prefer, but it's equally powerful and comes with a “batteries-included” philosophy[1].
  • Laravel (PHP): PHP has a bad reputation in some circles, but modern PHP is a great language, and Laravel is an expressive, elegant framework with a huge community. It's a very pragmatic choice.

What about JavaScript? For teams that are heavily frontend-focused, a modern JavaScript framework like Next.js or SvelteKit can also work as a monolith. They can handle the backend logic, API routes, and frontend rendering in one project. The key is choosing a framework that tries to solve the whole problem for you, not one that gives you a toolbox and a blank canvas.

A Simple Checklist for Your MVP Stack

If you don't want to just take my word for it, here’s the framework I use to evaluate choices. Notice that "raw performance" and "can it scale to a billion users" are not on this list.

1. Raw Development Speed

How fast can a developer go from a ticket in Jira to a deployed feature? This is a function of the framework's tooling and philosophy. Does it have code generators (scaffolding) to create the boilerplate for a new feature? Does it have a simple, clear way to interact with the database? How long does it take to run your test suite? In Rails, I can scaffold a new resource (like "Projects" or "Invoices") with a database model, controller actions, and basic views in a single command line instruction. This is what speed looks like.

2. Hiring Pool and Community

You are going to need to hire more engineers. How easy will it be? Choosing an obscure or brand-new language means you are fishing in a tiny pond for very expensive fish. Choosing a popular language like JavaScript, Python, or Ruby gives you access to a huge talent pool. The Stack Overflow 2023 Developer Survey[2] shows that languages like JavaScript and Python are known by a massive percentage of developers.

Community is just as important. When your developer gets stuck at 2 AM with a cryptic error message, will they find the answer in a 10-year-old Stack Overflow post? With a mature technology, the answer is almost always yes. With a new one, they might be the first person to ever see that error. That's a terrible place to be when you're trying to ship.

3. Ecosystem and Deployment

A mature framework has a mature ecosystem. This means high-quality, battle-tested libraries for common problems:

  • Authentication: Adding username and password login, or Google/Facebook sign-in.
  • Payments: Integrating with Stripe or Braintree.
  • Background Jobs: Running tasks like sending emails or processing uploads without blocking the user interface.
  • Admin Panels: A pre-built interface for your internal team to manage data.

Reinventing any of these wheels is a waste of your precious time. Rails has Devise, Sidekiq, and ActiveAdmin. Django has its own built-in admin and a rich ecosystem of packages. These libraries save you weeks or even months of development.

Finally, how easy is it to get your app onto the internet? Modern Platform-as-a-Service (PaaS) providers like Render[3] or Fly.io are built for these monolithic frameworks. You can often connect your GitHub repository, and they handle the rest. You can have a production environment running in under 15 minutes.

The Traps Most Founders Fall Into

I see early teams make the same few mistakes over and over. They are usually driven by fear or by an engineer’s desire to play with new toys.

The "Scalability" Bogeyman

"But will it scale?" Yes. It will. Basecamp, Shopify, GitHub, and Airbnb all started as Ruby on Rails monoliths. They scaled to massive businesses before they had to break things apart. Your first server on Render or Heroku can probably handle your first 10,000 active users without breaking a sweat. When you hit that limit, you can click a button to get a bigger server (this is called vertical scaling) for a couple hundred dollars a month. This will likely get you to 100,000 users. Scaling is a rich-person's problem. You should be so lucky to have it.

Microservices Myopia

Microservices are the idea of breaking your application into many small, independent services that talk to each other over a network. It is a valid architectural pattern for large organizations with many teams that need to work independently. For a startup with 2 to 5 engineers, it is absolute poison.

It introduces staggering operational complexity. You now have to worry about service discovery, distributed logging, network latency, and data consistency across services. It's like trying to conduct an orchestra when you only have three musicians. Worse, at the MVP stage, you don’t even know what your service boundaries should be because you don't fully understand your business domain yet. You will guess wrong, and the cost of refactoring a distributed system is astronomical compared to refactoring a monolith. As a wise man said, you should start with a monolith[4] and only extract services once you feel the pain.

Chasing the New Hotness

Your first engineer might be brilliant. They also might be bored. They might come to you with a proposal to build your MVP in a cool new language like Zig or a niche framework they just read about on Hacker News. Say no.

Using unproven technology for your core product is a huge risk. The documentation will be sparse, the libraries will be buggy or nonexistent, and you will have a team of one who knows how it works. What happens when they go on vacation, or worse, quit? You're left with an unmaintainable system and a business that's dead in the water. Let your engineers experiment on internal tools or side projects, not on the thing that makes you money.

When This Advice Is Wrong

No advice is universal. There are a few situations where choosing a boring monolith is not the right answer.

  • Your Team Are All Experts in Something Else: The only thing better than a framework optimized for speed is a team of experts who are already fast. If your founding engineers are all senior Java developers with 10 years of experience building apps with Spring Boot, let them use Spring Boot. The "use what you know" rule trumps the "use a monolith" rule if the expertise is deep and relevant. The goal is speed, and an expert team will be fast with their tools of choice.
  • Your Core Problem is Highly Specialized: If your product's core value proposition is, for example, real-time collaboration in a 3D space, a high-frequency trading algorithm, or a massive data processing pipeline, then a general-purpose web framework isn't the whole story. You'll need specialized tech (maybe Go for concurrency, C++ or Rust for performance, Python for machine learning) for that specific piece. But even then, I would strongly advise building the user management, billing, and marketing pages as a separate, boring monolith that talks to your specialized service.
  • You Are Building a Purely Native App: This article is focused on web applications. If you're building a mobile app that needs deep integration with the operating system (like background location tracking or complex camera interactions), you'll be looking at Swift/Kotlin for native development, or maybe React Native/Flutter for cross-platform. The principles of choosing mature ecosystems still apply, but the specific technology choices are different.

Your Stack Is Not Your Product

Let me be clear. Your technology stack is a business decision, not just a technical one. And at the start, every business decision must be optimized for one thing: learning what your customers want as quickly as possible.

Choose boring, productive technology. Choose a monolith like Rails, Django, or Laravel. Focus on the huge ecosystem of libraries and the large talent pool. Deploy it on a simple platform like Render. Resist the urge to over-engineer. Resist the siren song of scalability and shiny new frameworks.

Your tech stack is a tool. It's a means to an end. The product is what you build with it. Go build it. You can and will change the technology later, once you have a business that’s worth the effort.

Sources (4)
  1. Django Project
  2. Stack Overflow 2023 Developer Survey
  3. Render PaaS
  4. Martin Fowler on MonolithFirst

Recommended reading