Insights on engineering, architecture &amp; leadership.

February 10, 202620 MIN READ

Automating Cloud Infrastructure: From Manual Setup to Code-Driven Deployment

If you can't recreate your infrastructure from scratch in under 30 minutes, you have a single point of failure. Ansible lets you describe exactly what a server should look like and apply it repeatedly, identically, across every environment.

Leadership

How I Lead Engineering Teams: Lessons from Building a Product from 0 to Production

Leadership isn't just about code reviews and sprint planning. It's about context-switching between strategy and execution, protecting engineers from scope creep, and making the hard calls when no one else will. These are the principles I've developed leading teams through full product lifecycles.

February 9, 202615 MIN READ

February 9, 202620 MIN READ

Scaling Applications in the Cloud: Kubernetes and GitOps in Practice

Kubernetes enforces a discipline — every change is declarative, every deployment is auditable, and rollbacks are a single command. Here's how we run K3s clusters with ArgoCD for continuous delivery without manual intervention.

February 9, 202618 MIN READ

How Attackers Break Software: A Security Research Deep Dive

Understanding how vulnerabilities are exploited is the only reliable way to design software that resists them. This covers the mechanics behind common attack techniques — grounded in real controlled-environment CTF research and what each one teaches about defensive engineering.

Leadership

How I Run Projects: From Kickoff to On-Time Delivery

Every late project has the same root cause: unclear ownership and no defined definition of done. Here's the framework I use to scope work, align stakeholders, and ship predictably — regardless of whether the team runs Scrum, Kanban, or a hybrid.

February 7, 202618 MIN READ

February 7, 202620 MIN READ

Shipping Faster with Automated Pipelines: CI/CD with GitHub Actions

Every manual deployment is a deployment that will eventually be forgotten or done wrong. This is the GitHub Actions setup we use to build, test, and ship to Azure on every merge — with caching strategies that make pipelines actually fast.

February 5, 202615 MIN READ

Enforcing Code Standards Across a Multi-Language Team

Code quality in a team isn't about personal preference — it's about reducing review friction and preventing entire classes of bugs. This is the linting and formatting setup we use across TypeScript and Python in a shared monorepo, enforced automatically in CI.

February 5, 202612 MIN READ

Azure Blob Storage with Node.js: Upload, Stream & Manage Files (@azure/storage-blob)

How to use BlobClient and BlockBlobClient to upload, download, generate SAS URLs, and stream files in Azure Blob Storage from Node.js. Covers uploadData, container management, access control, and production file handling patterns.

December 10, 202528 MIN READ

From Code to Container: A Production Docker Guide

Containers are only as good as the build strategy behind them. This covers the multi-stage setup we use to keep production images lean, the Compose orchestration for local development, and the configuration mistakes that bloat images and slow pipelines.

October 15, 202530 MIN READ

Stripe Webhooks, Subscriptions & Billing in NestJS — Production Guide

Implement Stripe Checkout, webhooks, subscription lifecycle, and invoice handling in a NestJS microservices architecture. Includes webhook signature verification, idempotency patterns, and the edge cases nobody warns you about.

RabbitMQ with NestJS and Python: Queues, Exchanges & aio_pika — Full Tutorial

Connect NestJS and Python microservices via RabbitMQ. Covers direct and topic exchanges, routing keys, aio_pika IncomingMessage reply patterns, NestJS ClientProxy transport configuration, and production connection management.

July 1, 202522 MIN READ

February 25, 202530 MIN READ

Shipping AI Features in Production: GPT-4o Inside a Live Platform

We didn't just add a chatbot — we embedded AI into the core prioritization engine at Fygurs. Here's how we designed the prompts, managed async load, and deployed GPT-4o-mini on Azure without adding latency to our critical path.

December 5, 202422 MIN READ

How We Deployed and Scaled on Azure: A Production Playbook

Moving to Azure Container Apps changed how fast we could ship. This is the exact setup we run at Fygurs — container registry, environment-based scaling, and automated deployments triggered by a GitHub push — with the lessons from doing it wrong first.

October 25, 202415 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.

August 25, 202412 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.

August 20, 202422 MIN READ

Securing User Sessions: How Modern Authentication Works

Most auth vulnerabilities aren't in the login form — they're in how tokens are issued, stored, and invalidated. This breaks down access/refresh token flows, blacklisting strategies, and the production edge cases that keep user sessions genuinely secure.

August 10, 202418 MIN READ

Two-Factor Authentication in NestJS: TOTP with otplib & QR Codes

Add 2FA to your NestJS app using otplib. Generate TOTP secrets with authenticator.generateSecret(), validate codes, render QR codes for Google Authenticator, and implement backup codes and account recovery — production-safe.

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.

July 20, 202424 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.

July 15, 202410 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.

June 20, 202412 MIN READ

NestJS Microservices: ClientProxy, Message Patterns & RabbitMQ — Complete Guide

Build NestJS microservices with ClientProxy.send(), replace deprecated toPromise() with firstValueFrom(), and connect services via RabbitMQ transport. Covers request-response vs event patterns, error handling, and production architecture decisions.

May 15, 202425 MIN READ

April 10, 202412 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.

March 22, 202412 MIN READ

Secure Auth in Next.js + NestJS + Prisma: JWT, Refresh Tokens & Guards

Full authentication system: JWT access/refresh tokens, Prisma user storage, NestJS guards, and Next.js session handling. Covers token rotation, blacklisting strategies, route protection, and the hardening decisions that make it production-safe.

March 15, 202415 MIN READ

One Codebase, Multiple Products: How Monorepos Accelerate Teams

Splitting a product into separate repositories feels clean until you need to share types, coordinate releases, or run a single CI pipeline. Monorepos solve this — here's when to make the move and how to structure it so it stays manageable as the team grows.

February 28, 202418 MIN READ

When to Split Your Application: An Architecture Decision Guide

The biggest architectural mistake teams make isn't choosing the wrong pattern — it's choosing too early. Here's the decision framework I use to determine whether a product is ready for microservices, and how to migrate without breaking everything in production.

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.

April 5, 202214 MIN READ