Design Patterns in Python for Scalable Web Applications

class DBConnection:
    _instance = None
    def __new__(cls):
        if not cls._instance:
            cls._instance = super().__new__(cls)
            print("New DB Connection Created")
        return cls._instance

Example: The companies use Singleton in a multitenant SaaS platform where each tenant requires isolated, lazy-loaded connections to a centralized Redis store. This pattern avoided resource wastage.

3. Factory pattern for clean object creation

This pattern abstracts the creation logic of objects, especially when you deal with polymorphism or dynamic class loading.

class PaymentGateway:
    def process(self): pass

class Razorpay(PaymentGateway):
    def process(self): return "Paid with Razorpay"

class Stripe(PaymentGateway):
    def process(self): return "Paid with Stripe"

def get_gateway(mode):
    return Razorpay() if mode == "INR" else Stripe()

Example: In a cross-border e-commerce portal, the Factory pattern was used to choose different payment gateway classes based on currency. This made it easy to expand to six more markets.

4. Decorator pattern in Flask for middleware logic

Decorators help wrap functionality into routes, for example, authorization, logging and validation.

from functools import wraps

def require_api_key(f):
    @wraps(f)
    def wrapper(*args, **kwargs):
        if 'API-Key' not in request.headers:
            return {"error": "Unauthorized"}, 403
        return f(*args, **kwargs)
    return wrapper

Example: A fintech product added decorators to ensure that sensitive APIs like transfer_funds were accessible only after verifying tokens and logging access attempts.

5. Observer pattern for real-time systems: When the system needs to notify multiple components about events like stock updates, chat messages, or status changes, the Observer pattern is perfect.

class OrderNotifier:
    def __init__(self):
        self.subscribers = []

    def subscribe(self, fn):
        self.subscribers.append(fn)

    def notify(self, order_id):
 for fn in self.subscribers:
            fn(order_id)

Example: An Indian logistics platform used the Observer pattern in Flask + Redis Pub/Sub to push live delivery tracking to users and operations staff across cities.

6. Command pattern for background tasks

Ideal for encapsulating asynchronous jobs like:

• Email notifications
• Report generation
• Third-party data sync

class Command:
    def execute(self): pass

class SendEmail(Command):
    def execute(self):
        print("Email sent.")

Example: As an example, a marketing automation platform implemented the Command pattern and Celery workers to handle bulk email scheduling, scaling well past 50,000 campaigns in a month.

Remember that background tasks mostly involve sensitive user data, tokens, or calls to an external API. If you do not handle them safely, you could leave opportunities for vulnerabilities in your application.

That’s why following robust security measures is crucial. We’ve covered real-world, Python-specific solutions in our blog on Python Security Best Practices for 2025 to help you implement secure, scalable background processing.

Case Study 1: EdTech Platform

• Problem: Repetitive quiz logic, payment integrations, and role-based access made the system slow and complex.
• Solution:
  • Used Factory Pattern to dynamically render different quizzes for students vs. tutors.
  • Decorator Pattern secures routes based on roles.
  • Command Pattern offloaded result generation tasks.
• Result: 45% reduction in code duplication, and new feature development was 30% faster.

Case Study 2: Healthcare SaaS scaling with flask

• Problem: Crashing due to real-time appointment updates, unscalable code.
• Solution:
  • Introduced Observer Pattern to manage appointment update notifications.
  • Refactored logic with Factory Pattern for different doctor/patient workflows.
• Result: System scaled to serve 1 lakh+ users monthly with minimal downtime.