Engineering
Deep-dive engineering posts on NestJS, Next.js, real-time systems, databases, and production software by Brahim Boumlik.
- ·12 MIN READ
Storing and Serving Files in the Cloud: Azure Blob Storage in Practice
File handling in a microservices environment is harder than it looks — upload limits, streaming, access control, and durability all need to be designed upfront. This covers how we built a scalable document management system on Azure Blob Storage.
- ·22 MIN READ
How Our Services Talk to Each Other: Message Queues Explained
When two services need to communicate without blocking each other, you need a message queue. RabbitMQ decouples our services, handles retries, and bridges our Node.js and Python microservices — here's how it works and why we chose it.
- ·15 MIN READ
Designing Databases for Scale: Isolated Data Per Service
Shared databases are the most common microservices mistake. When every service reads and writes to the same tables, you lose the ability to scale, deploy, and version them independently. Here's the database-per-service pattern and how we implemented it.
- ·12 MIN READ
Real-Time Communication: How WebSockets Power Live Features
HTTP requests are stateless — great for fetching data, not for reacting to events as they happen. WebSockets keep a persistent connection open, which is how we power live matchmaking, notifications, and presence indicators without constant polling.
- ·16 MIN READ
Online Now: Building Real-Time Presence and Notification Systems
Knowing who's online and alerting them instantly changes how people use a product. This covers the full stack for presence tracking and live notifications — from Socket.io events to the Browser Notifications API and push with service workers.
- ·24 MIN READ
Building Slack-Style Chat from Scratch: Architecture and Trade-offs
Chat is deceptively complex — rooms, direct messages, moderation, blocked users, and message persistence all interact in non-obvious ways. This walks through the full implementation we built for a live multiplayer platform and the decisions that shaped it.
- ·10 MIN READ
Technical Debt: How to Identify and Eliminate It Before It Costs You
Technical debt is the interest paid on past shortcuts. Left unchecked, it slows every new feature and drives good engineers out. Here's how to spot it, measure it, and systematically reduce it without halting product delivery.
- ·12 MIN READ
The Blueprints Behind Good Software: Design Patterns Explained
The same problems appear in almost every software project — initialization, dependency management, behavior switching. Design patterns are the battle-tested solutions. Here's how they look in real code, not textbook diagrams.
- ·25 MIN READ
How We Architected a Production SaaS: A Microservices Deep Dive
Building a product strategy platform means handling auth, roadmapping, payments, notifications, and real-time collaboration — all independently scalable. This is the architecture we landed on after several iterations in a production SaaS, the tradeoffs we made, and what we'd reconsider.
- ·12 MIN READ
Managing a Large Codebase at Speed: Turborepo in Production
When a monorepo grows to dozens of packages and CI takes 20 minutes, something has to change. Turborepo's task graph and remote caching cut our pipeline times dramatically — here's the exact configuration we run and the pitfalls we worked around.
- ·12 MIN READ
End-to-End Authentication: Designing a Secure Login System
Authentication done right touches the frontend, backend, database, and infrastructure simultaneously. This walks through the full stack — session flow, JWT validation, user models, and the hardening decisions that make it production-safe.
- ·14 MIN READ
Building an Operating System from Zero: What It Taught Me About Computers
There's no better way to understand how software works than to build the thing it runs on. Starting from a blank bootloader, I implemented interrupt handling, a keyboard driver, and memory paging — entirely from scratch, no frameworks underneath.