Hackforge Academy

Explanation

Monolithic architecture is a software design where all major application components are developed and deployed as a single application. Features such as user management, products, orders, payments, and reports can exist inside the same codebase and application process. This architecture is simple to develop, test, and deploy for small applications. However, as the application grows, the codebase can become difficult to maintain, and scaling one feature may require scaling the entire application.

Code:

# Monolithic Python Application

from fastapi import FastAPI

app = FastAPI()

@app.get('/users')
def users():
    return {'service': 'User Management'}

@app.get('/products')
def products():
    return {'service': 'Product Management'}

@app.get('/orders')
def orders():
    return {'service': 'Order Management'}

@app.get('/payments')
def payments():
    return {'service': 'Payment Management'}

# All features are part of one application.
# Run:
# uvicorn main:app --reload

Explanation

Microservices architecture divides an application into multiple small and independent services. Each service focuses on a specific business capability and can be developed, deployed, and scaled independently. For example, an e-commerce application can have separate User, Product, Order, and Payment services. Each service can expose its own API and may have its own database. Python frameworks such as FastAPI and Flask are commonly used to build these services.

Code:

# Microservices Architecture

# user_service.py
from fastapi import FastAPI

app = FastAPI()

@app.get('/users')
def users():
    return {'service': 'User Service'}


# product_service.py
# Runs as a separate application

# order_service.py
# Runs as a separate application

# payment_service.py
# Runs as a separate application

# Each service can be deployed independently.

Explanation

In a monolithic architecture, the complete application is normally packaged and deployed as one unit. If a small change is made to the payment module, the entire application may need to be rebuilt and deployed. In a microservices architecture, only the affected service needs to be deployed. For example, changing the Payment Service does not necessarily require redeploying the User or Product Services. Independent deployment is one of the major advantages of microservices.

Code:

# Monolithic deployment
#
# ecommerce-app
#     |
#     +-- Users
#     +-- Products
#     +-- Orders
#     +-- Payments
#
# Deploy entire application


# Microservices deployment
#
# user-service     -> Container 1
# product-service  -> Container 2
# order-service    -> Container 3
# payment-service  -> Container 4
#
# Deploy services independently

Explanation

Scaling means increasing application resources when traffic or workload increases. In a monolithic application, the entire application is usually scaled even if only one feature requires additional capacity. In microservices, individual services can be scaled independently. For example, if an e-commerce application receives a large number of order requests, the Order Service can be scaled to multiple instances while the User Service remains unchanged. This can improve resource utilization and flexibility.

Code:

# Monolithic scaling
#
#             Load Balancer
#                  |
#       +----------+----------+
#       |          |          |
#   App Server  App Server  App Server
#
# Entire application is scaled.


# Microservices scaling
#
# Product Service -> 1 instance
# User Service    -> 1 instance
# Order Service   -> 3 instances
# Payment Service -> 2 instances
#
# Only high-traffic services are scaled.

Explanation

Monolithic architecture is often a good choice for small applications, startups, prototypes, and systems with a small development team because it is simpler to build and operate. Microservices are more suitable for large and complex applications where different teams need to work independently and individual components need independent deployment or scaling. Microservices also introduce additional complexity such as network communication, service discovery, distributed logging, monitoring, authentication, and data consistency. Therefore, microservices should not be chosen simply because they are popular; the architecture should match the application's actual requirements.

Code:

# Simple decision example

def choose_architecture(
    application_size,
    team_size,
    independent_scaling
):
    if application_size == 'small' and team_size <= 5:
        return 'Monolithic Architecture'

    if independent_scaling:
        return 'Microservices Architecture'

    return 'Start with Monolithic Architecture'


print(choose_architecture('small', 3, False))
print(choose_architecture('large', 20, True))