First let’s define what we mean by “Monolith” and “Microservice”. A monolithic architecture is built as one large system and is usually one code-base. A monolith is often deployed all at once, both front and end code together, regardless of what was changed. A microservices architecture however is where an app is built as a suite of small services, each with their own code-base. These services are built around specific capabilities and are usually independently deployable.

Conventional wisdom preaches starting with a monolith. This temptation is especially strong when starting out with a lean team on tight deadlines. But is conventional wisdom always right? My good friend Darby Frey recently kicked off a greenfield project after assuming his new role as Sr. Platform Engineering Lead of Gamut. Despite starting out with monolith at his previous company Belly, he discovered that (in the right circumstances) starting with a monolith isn’t always the best way to go.

At Belly, Darby and his team broke down their monolith into a fairly large microservices architecture. They managed to get it to a good place, but only after months of trials and tribulations migrating to microservices. With this experience fresh in his mind, he approached his new project at Gamut a bit more cautious of microservices:

“I was firmly a member of Team Monolith. [I thought] let’s build a single application and just pull things apart later if we start to feel pain,” he said. While this was a greenfield project, Darby’s team was small, and he had aggressive timelines, so on the surface, a monolith seemed like the obvious choice. “[But with this new project], I was anxious to not repeat the mistakes of the past.”

And with that, he found himself faced with a decision we all struggle with, should we start with a monolith or microservices and how do we decide?

Understanding the Choices

To decide between the two, we should first nail down what exactly we mean by “monolith” and “microservice.”

Zachary Crockett, CTO at Particle told me that “system architectures lie on a spectrum…When discussing microservices, people tend to focus on one end of that spectrum: many tiny applications passing too many messages to each other. At the other end of the spectrum you have a giant monolith doing too many things. For any real system, there are many possible service oriented architectures between those two extremes.”

DEFINING THE MONOLITH

A monolithic application is built as a single, unified unit. Often a monolith consists of three parts: a database, a client-side user interface (consisting of HTML pages and/or JavaScript running in a browser), and a server-side application. The server-side application will handle HTTP requests, execute domain-specific logic, retrieve and update data from the database, and populate the HTML views to be sent to the browser.

In a monolith, server side application logic, front end client side logic, background jobs, etc, are all defined in the same massive code base. The upshot: if developers want to make any changes or updates, they need to build and deploy the entire stack all at once.

Contrary to what you might think, a monolith isn’t a dated architecture that we need to leave in the past. In certain circumstances, a monolith is ideal. Steven Czerwinski, Head of Engineering at Scaylr and former Google employee explained that because his team at Scaylr was small, a unified application was more manageable in comparison to splitting everything up into microservices: “[In the early days of Scaylr] even though we had had these positive experiences of using microservices at Google, we went [for a monolith] route because having one monolithic server means less work for us as two engineers.”

When considering a monolith architecture, your team should consider the following:

Monolith Pros

• Fewer Cross-cutting Concerns: The major advantage of the monolithic architecture is that most apps typically have a large number of cross-cutting concerns, such as logging, rate limiting, and security features such audit trails and DOS protection. When everything is running through the same app, it’s easy to hook up components to those cross-cutting concerns.
• Less Operational Overhead: Having one [large] application means there’s only one application you need to set up logging, monitoring, testing for. It’s also generally less complex to deploy.
• Performance: There can also be performance advantages, since shared-memory access is faster than inter-process communication (IPC).

Monolith Cons

• Tightly Coupled: Monolithic app services tend to get tightly coupled and entangled as the application evolves, making it difficult to isolate services for purposes such as independent scaling or code maintainability.
• Harder To Understand: Monolithic architectures are also much harder to understand, because there may be dependencies, side-effects, and magic which are not obvious when you’re looking at a particular service or controller.

DEFINING MICROSERVICES

There is nothing inherently “micro” about microservices per se. While they tend  to be smaller than the average monolith, they do not have to be tiny. Some are, but size is relative and there’s no standard of unit of measure across organizations.

The microservice architectural style is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API. These services are built around business capabilities and independently deployable by fully automated deployment machinery. There is a bare minimum of centralized management of these services.

When considering microservices, your team should keep in mind:

Microservices Pros

• Better Organization: Microservice architectures are typically better organized, since each microservice has a very specific job, and is not concerned with the jobs of other components.
• Decoupled: Decoupled services are also easier to recompose and reconfigure to serve the purposes of different apps (for example, serving both the web clients and public API). They also allow for fast, independent delivery of individual parts within a larger, integrated system.
• Performance: Under the right circumstances, microservices can also have performance advantages depending on how they’re organized because it’s possible to isolate hot services and scale them independent of the rest of the app.
• Fewer Mistakes: Microservices enable parallel development by establishing a hard-to-cross boundary between different parts of your system. By doing this, you make it hard—or at least harder—to do the wrong thing: Namely, connecting parts that shouldn’t be connected, and coupling too tightly those that need to be connected.

Microservices Cons

• Cross-cutting Concerns Across Each Service: As you’re building a new microservice architecture, you’re likely to discover lots of cross-cutting concerns that you did not anticipate at design time. You’ll either need to incur the overhead of separate modules for each cross-cutting concern (i.e. testing), or encapsulate cross-cutting concerns in another service layer that all traffic gets routed through. Eventually, even monolithic architectures tend to route traffic through an outer service layer for cross-cutting concerns, but with a monolithic architecture, it’s possible to delay the cost of that work until the project is much more mature.
• Higher Operational Overhead: Microservices are frequently deployed on their own virtual machines or containers, causing a proliferation of VM wrangling work. These tasks are frequently automated with container fleet management tools.

Making the Right Decision for Your Organization

Pros and cons can provide a general framework for discussing potential benefits and drawbacks of one architecture over another when you sit down with your team. To effectively apply these general principles, I interviewed dozens of CTOs to create a rubric of considerations for you when you’re deciding what’s best for your organization.

ARE YOU IN FAMILIAR TERRITORY?

Darby and his team at Gamut were able to delve directly into Microservices because he had experience with eCommerce platforms, and his company had a wealth of knowledge concerning the needs and demands of their customers. If he was traveling down an unknown path on the other hand, a monolith may have actually been the safer option.

IS YOUR TEAM PREPARED?

Does your team have experience with microservices? What if you quadruple the size of your team within the next year, are microservices ideal for that situation? Evaluating these dimensions of your team is crucial to the success of your project.

If your team is prepared, starting with microservices is wise as it allows you to get used to the rhythm of developing in a microservice environment, right from the start.

HOW’S YOUR INFRASTRUCTURE?

In reality, you’re going to need cloud-based infrastructure to make microservices work for your project.

“[Previously], you would want to start with a monolith because you wanted to deploy one database server. The idea of having to set up a database server for every single microservice and then scale out was a mammoth task. Only a huge, tech-savvy organization could do that,”  David Strauss, CTO of Pantheon explained to me.  “Whereas today with services like Google Cloud and Amazon AWS, you have many options for deploying tiny things without needing to own the persistence layer for each one.”

EVALUATE THE BUSINESS RISK

You may think microservices is the “right” way to go as a tech-savvy startup with high ambitions. But microservices pose a business risk. David Strauss explained:

“A lot of teams overbuild their project initially; everyone wants to think their startup will be the next unicorn and that they should, therefore, build everything with microservices or some other hyper-scalable infrastructure. But that’s usually wrong, almost all the time.”

He went on to say that, in these cases, the areas that you thought you needed to scale are probably not the parts that will need to scale first, and that results in misplaced effort even for the systems that will need to scale.

CONTEXT MATTERS

The CTOs I talked to had a broad range of experience with both monoliths and microservices. Some confidently began with microservices, while others stuck to a monolith in the beginning and eventually made a transition to microservices as their startups grew. Consider your own context and the following scenarios to help determine which architecture fits your situation.

When To Start With A Monolith

Here are some scenarios that indicate that you should start your next project using monolithic architecture:

• Your Team Is At Founding Stage: Your team is small, between 2-5 members, and is thus unable to tackle a broader and high-overhead microservices architecture.
• You’re Building An Unproven Product or Proof of Concept: Are you building an unproven product in the market? If it’s a new idea, it’s likely going to pivot and evolve over time, so a monolith is ideal to allow for rapid product iteration. Same applies to a proof of concept where your goal is just to learn as much as possible as quickly as possible, even if you end up throwing it away.
• You Have No Microservices Experience: If your team has no prior experience with microservices, unless you can justify taking the risk of learning “on the fly” at such an early stage, it’s likely another sign you should stick to a monolith to start.

When To Start With Microservices

Here are some scenarios that indicate that you should start your next project using microservices:

• You Need Quick, Independent Service Delivery: Microservices allow for fast, independent delivery of individual parts within a larger, integrated system. Note, depending on your team size, it can take time to see service delivery gains versus starting with monolith.
• A Piece of Your Platform Needs to Be Extremely Efficient: If your business is doing intensive processing of petabytes of log volume, you’ll likely want to build that service out in a very efficient language (i.e. C++) while your user dashboard may be built in Ruby on Rails.
• You Plan To Grow Your Team: Starting with microservices gets your team used to developing in separate small services from the beginning, and having teams separated by service boundaries makes it much easier to scale up your team when you need to without introducing exponential complexity.

The monolith isn’t dead and microservices are not best-suited for every context. Avoid the temptation to dive into microservices simply because of their explosion in growth. Instead, use the wisdom of CTOs who came before to carefully consider what architecture makes the most sense for you.