33 posts
FastAPI's Depends() handles per-request wiring. dependency-injector handles everything else — configuration, singletons, factories, and a declarative container that makes your entire object graph visible in one file.
15 min readYour BookStore API now has 200 customers who each want their own data. One missing WHERE clause leaks tenant data and kills the company. Here is how to make cross-tenant data leakage structurally impossible with context propagation, session events, and row-level isolation.
13 min readYour pool_size=5 default just met Black Friday traffic. 200 concurrent requests, 5 connections, 195 coroutines waiting on pool checkout — then timeouts cascade into a full outage. Here is how to configure connection pooling, read replicas, and circuit breakers for production traffic.
14 min readWhen a tenant reports 'my order failed 20 minutes ago,' you need to find that exact request across API logs, database queries, and background tasks within 30 seconds. Here is how to build observability into a multi-tenant Python backend from day one.
11 min readHardcoded config breaks the moment your 200 tenants need different rate limits, feature access, and API keys. Here is a hierarchical configuration system with per-tenant overrides, percentage-based feature rollouts, and encrypted secrets — all hot-reloadable without restarts.
14 min readWithout caching at 1M transactions per day, the database becomes the bottleneck within weeks. But caching in a multi-tenant system is treacherous — one missing tenant prefix in a cache key leaks data between tenants.
13 min readAt 1M transactions per day, you cannot process everything in the request cycle. But background tasks are where tenant context silently disappears — the worker has no request, no middleware, no headers. Here is how to propagate context safely.
15 min readWithout rate limiting, one tenant's bulk import consumes all your database connections and API throughput. Here is how to build tiered, sliding-window rate limiting in Python with Redis — protecting every tenant from every other tenant.
11 min readAt 1M transactions per day, two requests modifying the same inventory record is not an edge case. Here is how to prevent lost updates with optimistic locking, double charges with idempotency keys, and partial failures with the saga pattern.
13 min readA naive ALTER TABLE on a 100M-row table locks it for minutes. Multi-tenant makes it worse: one failed migration across 200 schemas leaves tenants on inconsistent versions. Here is the expand-contract pattern and the tooling to migrate safely.
14 min readWhen order placement triggers inventory, email, webhooks, analytics, and distributor notifications — doing it synchronously makes the endpoint slow and couples everything. Domain events decouple 'what happened' from 'what should happen next.'
13 min readWithout health checks, your load balancer sends traffic to dying instances. Without graceful shutdown, every deploy drops requests. Here is how ShelfWise achieves zero-downtime deployments with proper probes, SIGTERM handling, and connection draining.
11 min readA single tenant data leak can end your SaaS business. SOC 2 and GDPR demand audit trails, scoped access controls, and data isolation verification. Here is how to build RBAC, API key management, and immutable audit logging into ShelfWise.
11 min readA breaking API change that 'only' affects 5% of tenants still breaks real businesses. Without versioning, you can never evolve your API. Here is how to version a multi-tenant FastAPI backend with per-tenant version pinning, deprecation workflows, and contract testing.
12 min readAn N+1 query that takes 50ms with 10 rows takes 5 seconds with 1000. A memory leak that grows 1MB/hour OOMs in 3 days. Here is how to profile, detect, and load test a multi-tenant Python backend before production tells you first.
14 min readTheory without deployment is fiction. This capstone assembles all 22 prior patterns into a deployed, monitored, incident-ready multi-tenant Python backend — from Docker Compose to runbooks to your first production incident.
22 min readAuthentication and authorization are two different problems that most tutorials conflate. Here is the mental model, threat landscape, and FastAPI security toolkit you need before writing a single line of auth code.
9 min readAPI keys are the most misused auth mechanism in production. Here is how to generate, scope, rotate, and rate-limit API keys in FastAPI — with the patterns that separate toy projects from production systems.
9 min readJWTs eliminate session storage but introduce revocation challenges. Here is how to build access tokens, refresh tokens, and token rotation in FastAPI — with the security pitfalls that tutorials never mention.
10 min readPassword hashing is not security — it is one layer. Here is how to build registration, login, session management, and brute-force protection in FastAPI without the mistakes that lead to credential breaches.
12 min readOAuth 2.0 is not authentication — it is authorization. Here are the four grant types, why PKCE is now mandatory, and how to implement the authorization code flow in FastAPI with working code and sequence diagrams.
9 min readOAuth 2.0 does not tell you who the user is. OpenID Connect adds the identity layer. Here is how to implement Google SSO, validate ID tokens, and understand when OIDC beats SAML.
9 min readAuthentication answers who. Authorization answers what. Here are three authorization models — RBAC, ABAC, and ReBAC — implemented as FastAPI dependencies with decision flows, comparison tables, and production patterns.
10 min readEight authentication and authorization methods, one decision tree. Here is the comparison matrix, production combination patterns, and pre-launch security checklist that turns auth knowledge into shipping decisions.
11 min readNot all hashes are created equal. Here is how SHA-256, bcrypt, scrypt, and Argon2id actually work under the hood — the math, the memory, the attacks they resist, and exactly when to use each one.
21 min readMost Python backend projects start clean and become unmaintainable. Here is the folder layout and naming convention that keeps a FastAPI + SQLAlchemy codebase navigable at any size.
7 min readPython's ABC machinery adds inheritance overhead you do not need. Protocols give you structural subtyping — type-safe duck typing with zero coupling between your repository interfaces and implementations.
8 min readWrap your database access behind a clean interface. The Repository pattern decouples business logic from SQLAlchemy, makes testing trivial, and gives you a single place to optimize queries.
8 min readScattered try/except blocks and generic 500 errors signal a system that was not designed. Here is how to define domain exceptions, translate them to HTTP responses, and give your API clients errors they can act on.
7 min readRepositories fetch data. API routes handle HTTP. Business logic belongs in neither. The Service Layer is the missing middle that keeps both clean and testable.
7 min readFastAPI's Depends() is the most underused tool in the framework. Here is how to use it to wire repositories, services, and authentication into your route handlers with no global state and no service locator pattern.
7 min readasyncio.gather() is not always the answer. Here is when to parallelize database calls, when NOT to, and how to avoid the most common SQLAlchemy async session mistakes that cause subtle production bugs.
9 min readUnit tests, integration tests, and API tests — each has a role in a Python backend. Here is a complete testing strategy for a FastAPI + SQLAlchemy project, showing what to test at each layer and how the patterns from this series make testing effortless.
10 min read