There are two popular approaches to application design – monolithic architecture or architecture that relies on microservices. Each has its benefits and drawbacks, and each is suitable for specific projects. In this series, we'll cover the topic extensively and hopefully shine a light on the matter.
Look before you leap. This old saying sums up what you should do in the initial stage of any project – plan, outline, and research. Become familiar with all the context and describe the application's required functionality and available resources you'll need along the way. Strong foundations will help you build a scalable, robust, and extendable service.
The initial stage in the context discovery process contains functional requirements or specifications of what the app should offer to end-users. Elaborate on the following, and you'll get excellent areas to start with:
- End users
- Process of input and output
- Engineering group
Secondly, you should review the resources that will help you with the project's implementation. Start with the following:
- Engineering resources
- Financial resources
- Internal knowledge
With a clear grasp of functional needs and available resources, choosing between monolithic and microservice-based designs may be a lot easier. The engineering team must choose the best application architecture before a company can design a product. As we mentioned, there are two main models – monoliths and microservices. Whatever approach you choose, keep in mind that the goal is to create an app that provides value to consumers and is easily adaptable to new features.
In addition, each architecture encapsulates an application's three primary tires:
- The User Interface is responsible for handling HTTP requests from users and returning a response.
- The programming that delivers a service to users is called business logic.
- The data layer is responsible for the access and storage of data items.
What are monoliths?
In a monolithic architecture, application tiers share the following characteristic:
Diagram showcasing how a booking application is implemented using a monolithic architecture:
- They are part of the same unit
- Everything is managed in a single repository
- They share existing resources (e.g., CPU and memory)
- They are developed in one programming language
- They are released using a single binary