đź‘‹ Hello world.
I’m a cloud engineer and developer passionate about building scalable Cloud and AI infrastructure. I enjoy working with modern technologies to create efficient, production-ready solutions.
This blog is where I share my experiences and learnings in software architecture, distributed systems, and engineering leadership.
🕹️ Learned to code on a Commodore, and I’ve basically been hitting RUN ever since.
Read the blog or play a game :)
Recent Blog Posts
-
Cognitora: A Datacenter-Scale, Open-Source LLM Inference Orchestrator (NVIDIA Dynamo Alternative)
Inference engines like vLLM, SGLang, and TensorRT-LLM are excellent at saturating one node. They are not, by themselves, a multi-node serving system. Cognitora is a Rust-only orchestration layer shipped as six static binaries—no Python control plane, no Kubernetes-only runtime—that turns those engines into a KV-aware, disaggregated, energy-conscious cluster. This post walks through the architecture, the routing model, and how it stacks up against NVIDIA Dynamo, Ray Serve, KServe, Triton, and the vLLM Production Stack (updated for the v0.3.0 release). -
s0-cli: A Self-Optimizing Security Scanner via Meta-Harness
Most security tools encode their heuristics in scattered config files or undocumented engineer intuition. s0-cli encodes them in a versioned single-file Python agent that gets automatically rewritten by an outer optimization loop, scored against a labeled benchmark with a held-out test split. On openai/gpt-4o-mini the LLM triage layer cuts false positives by 30% on held-out tasks (10 → 7) without dropping a single true positive — held-out F1 climbs from 0.50 to 0.59 while keeping recall at 1.00. v0.3.x adds a novelty-hunting harness for unknown vuln classes, a supply-chain composite scanner, MCP integration for Claude/Cursor, and standalone binaries. -
MARS: Episode-Scoped GPU Retrieval for Real-Time Embodied AI
A child's ball rolls into the road. Vision sees only the ball — but 600 ms ago, microphones captured children's voices from that direction. MARS (Memory for Autonomous Real-time Systems) treats scope, time, and cross-modal connectivity as kernel-level primitives and delivers a perfect-recall multimodal answer in 197 µs at N=1M, 33× faster than FAISS-Flat-GPU on the same hardware — when the application can supply an episode handle. -
Agentic AI Systems: Multi-Agent Architectures
Design multi-agent AI systems: agent coordination, communication patterns, task decomposition, and architectural patterns for complex agent systems. -
WebSocket vs SSE vs Long Polling: Choosing the Right Protocol
Compare real-time protocols: WebSocket, Server-Sent Events, and Long Polling. Learn when to use each, trade-offs, and implementation patterns. -
Databricks for Data Engineers: Getting Started
Get started with Databricks: notebooks, Spark, data pipelines, Delta Lake, and how Databricks enables data engineering at scale. -
Container Orchestration at the Edge: New Paradigms
Orchestrate containers at the edge: edge Kubernetes, lightweight runtimes, distributed orchestration, and new paradigms for edge container management. -
Cloudflare D1: SQLite at the Edge
Use Cloudflare D1 for edge databases: SQLite at the edge, global replication, query patterns, and how D1 enables low-latency database access. -
Generative AI Engineering: Best Practices
Engineering practices for generative AI: prompt engineering, RAG patterns, evaluation, monitoring, and best practices for production AI systems. -
Building AI Coding Assistants: Technical Deep Dive
Build AI coding assistants: code generation, context management, tool integration, code analysis, and technical patterns for production coding assistants. -
Hono: Fast Web Framework for Edge
Build fast edge applications with Hono: lightweight framework, Cloudflare Workers support, middleware, and performance benefits over Express. -
AI Agents: Architecture and Design Patterns
Design AI agent systems: agent patterns, tool use, memory management, planning, and architectural patterns for building production AI agents. -
SolidJS: A Reactive UI Framework
Build reactive UIs with SolidJS: fine-grained reactivity, performance benefits, component patterns, and how SolidJS compares to React. -
Cloudflare Durable Objects: Stateful Edge Computing
Explore Cloudflare Durable Objects, a revolutionary approach to stateful computing at the edge. Learn how to build real-time collaborative applications with globally distributed state. -
Refactoring Complex Systems: A Systematic Approach
Refactor complex systems systematically: assessment, planning, incremental changes, testing strategies, and how to safely refactor production systems. -
AI-Powered Code Execution: Security Considerations
Secure AI-powered code execution: sandboxing, resource limits, input validation, and security patterns for safely executing AI-generated code. -
Consul: Service Discovery and Configuration
Service discovery with HashiCorp Consul: service mesh, DNS integration, health checking, and how Consul enables dynamic infrastructure. -
Go for System Programming: Building High-Performance Services
Build high-performance system services with Go: goroutines, channels, HTTP servers, database connections, and patterns for building scalable backend services. -
Cloudflare R2: S3-Compatible Object Storage
Use Cloudflare R2 for object storage: S3-compatible API, zero egress fees, global distribution, and migration from S3 to R2. -
Kata Containers: Secure Container Runtime
Use Kata Containers for secure container runtime: VM-level isolation, OCI compatibility, Kubernetes integration, and when to use Kata for enhanced security. -
Building a Vector Database: HNSW Algorithm Explained
Build a vector database with HNSW: hierarchical graph structure, search algorithm, implementation details, and how HNSW enables fast similarity search. -
Nomad: Simple and Flexible Orchestration
Orchestrate workloads with HashiCorp Nomad: job scheduling, multi-cloud deployment, container and VM support, and when to choose Nomad over Kubernetes. -
Firecracker: Secure and Fast microVMs
Explore Firecracker: lightweight microVMs, fast boot times, security isolation, and how Firecracker powers AWS Lambda and other serverless platforms. -
Vector Databases: The Foundation of AI Applications
Understand vector databases: embeddings, similarity search, indexing algorithms, and how vector databases power AI applications like RAG and semantic search. -
Introduction to Rust for Backend Developers
Learn Rust for backend development: ownership, borrowing, async/await, web frameworks, and how Rust's safety and performance benefit backend systems. -
Cloudflare Workers: Serverless at the Edge
Build serverless applications with Cloudflare Workers: edge computing, global distribution, Durable Objects, and how to deploy JavaScript at the edge. -
AWS Solutions Architect: Key Lessons from Certification
Lessons learned from AWS Solutions Architect certification: key concepts, common patterns, exam strategies, and practical knowledge for building on AWS. -
Managing Technical Debt: Strategies and Practices
Manage technical debt effectively: identification, prioritization, repayment strategies, and how to balance new features with maintenance work. -
Monolith-First Strategy: When It Makes Sense
Start with a monolith: when monolith-first makes sense, benefits of starting simple, and migration strategies when you need to scale to microservices. -
API Design: From REST to GraphQL to gRPC
Compare API design approaches: REST, GraphQL, and gRPC. Learn when to use each, design patterns, and how to choose the right API style for your use case. -
AWS Step Functions: Orchestrating Serverless Workflows
Orchestrate serverless workflows with AWS Step Functions: state machines, error handling, parallel execution, and building complex business processes. -
React Server Components: A New Paradigm
Build with React Server Components: server-side rendering, zero bundle size, direct database access, and how RSC changes React application architecture. -
Platform Engineering: Building Internal Developer Platforms
Build internal developer platforms (IDP): self-service infrastructure, developer portals, golden paths, and how to enable developer productivity through platform engineering. -
Multi-Tenant Architecture: Isolation Strategies
Design multi-tenant systems: shared database, separate databases, hybrid approaches, and security strategies for isolating tenant data in SaaS applications. -
TypeScript 5.0: New Features and Improvements
Explore TypeScript 5.0 new features: decorators, const type parameters, improved performance, and migration guide for upgrading to TypeScript 5. -
OpenTofu in Production: Migration from Terraform
Migrate from Terraform to OpenTofu in production: step-by-step guide, compatibility testing, state migration, and lessons learned from real-world migration. -
AWS Lambda Cold Starts: Optimization Strategies
Optimize AWS Lambda cold starts: provisioned concurrency, SnapStart, initialization optimization, and strategies to reduce cold start latency in serverless applications. -
Bun: The Fast All-in-One JavaScript Runtime
Explore Bun: fast JavaScript runtime, bundler, test runner, and package manager. Learn installation, API compatibility, performance benefits, and when to use Bun. -
Leading Architectural Reviews: A Practical Guide
Lead effective architectural reviews: preparation, facilitation, feedback, and follow-up. Learn how to conduct reviews that improve architecture and align teams. -
Strangler Fig Pattern: Refactoring Legacy Systems
Migrate legacy systems using the Strangler Fig pattern: gradually replace old system with new, route traffic incrementally, and minimize risk during migration. -
Building Documentation Systems: From Zero to Hero
Build comprehensive documentation systems: API docs, architecture docs, runbooks, and developer guides. Learn tools, processes, and best practices for maintainable documentation. -
Service Mesh: Istio vs Linkerd
Compare service mesh solutions: Istio vs Linkerd. Learn about traffic management, security, observability, and when to use each service mesh. -
Hexagonal Architecture (Ports and Adapters)
Implement hexagonal architecture: ports, adapters, domain isolation, and how to build testable, maintainable applications with clear boundaries. -
OpenTofu: Open Source Alternative to Terraform
Migrate to OpenTofu: Terraform-compatible open source alternative. Learn installation, migration, and differences from Terraform. -
PostgreSQL Partitioning: Managing Large Tables
Partition large PostgreSQL tables: range partitioning, list partitioning, hash partitioning, and strategies for managing billions of rows efficiently. -
Building Resilient Systems: Timeout, Retry, and Fallback
Build resilient systems with timeout, retry, and fallback patterns. Learn how to handle failures gracefully and maintain system availability. -
Backend for Frontend (BFF) Pattern
Implement the Backend for Frontend pattern: dedicated API layers for each client, aggregation, transformation, and when to use BFF in microservices architectures. -
System Design Interview: Designing a URL Shortener
Design a URL shortener like bit.ly: requirements, capacity estimation, API design, database schema, encoding algorithm, and scaling strategies. -
Remix: Full Stack Web Framework for React
Build full-stack web applications with Remix: data loading, mutations, forms, nested routing, and server-side rendering patterns for modern web apps. -
C4 Model: Visualizing Software Architecture
Document software architecture with the C4 model: context, containers, components, and code diagrams. Learn how to create clear, maintainable architecture documentation. -
Architectural Decision Records: Documenting Key Decisions
Document architectural decisions with ADRs. Learn the ADR format, when to create them, and how to maintain a decision log for your team. -
API Versioning Strategies: Best Practices
Implement API versioning: URL versioning, header versioning, semantic versioning, and migration strategies for maintaining backward compatibility. -
Monorepo Strategies: Nx, Turborepo, and Lerna
Manage monorepos with Nx, Turborepo, and Lerna. Learn workspace management, task orchestration, dependency management, and scaling strategies for large codebases. -
Building Serverless Applications with AWS CDK
Build serverless applications with AWS CDK: Lambda functions, API Gateway, DynamoDB, S3, and infrastructure as code patterns for serverless architectures. -
PostgreSQL Performance Tuning: Advanced Techniques
Optimize PostgreSQL performance: query optimization, index strategies, connection pooling, configuration tuning, and monitoring for high-performance databases. -
Kubernetes Network Policies: Security Best Practices
Secure Kubernetes clusters with network policies. Learn how to restrict pod-to-pod communication, implement default deny policies, and enforce network segmentation. -
Building CLI Tools with Node.js
Build command-line tools with Node.js: argument parsing, interactive prompts, colors, progress bars, and best practices for creating professional CLI applications. -
TypeScript Advanced Types: A Deep Dive
Master TypeScript advanced types: conditional types, mapped types, template literal types, utility types, and type-level programming patterns. -
Event Sourcing: Implementation Patterns
Implement event sourcing patterns: event store, aggregates, projections, snapshots, and how to build event-sourced systems with CQRS. -
Deno: A Secure Runtime for JavaScript and TypeScript
Learn Deno: secure by default, built-in TypeScript, modern JavaScript runtime. Build web servers, CLI tools, and applications with Deno's security model and standard library. -
gRPC Streaming: Bidirectional Communication Patterns
Implement gRPC streaming patterns: unary, server-side, client-side, and bidirectional streaming. Learn when to use each pattern and production best practices. -
Advanced Kubernetes: Custom Resources and Operators
Extend Kubernetes with Custom Resource Definitions (CRDs) and operators. Learn how to create custom resources, build operators, and automate Kubernetes operations. -
Building Engineering Organizations from Zero
Lessons learned from building engineering organizations from scratch: hiring, culture, processes, tooling, and scaling technical teams effectively. -
Saga Pattern for Distributed Transactions
Implement the Saga pattern for distributed transactions in microservices. Learn orchestration vs choreography, compensation, and handling failures across services. -
Building a Design System for React Applications
Create a design system for React applications: component library, tokens, documentation, and best practices for building consistent UIs. -
Redis Data Structures: Beyond Key-Value
Master Redis data structures: strings, lists, sets, sorted sets, hashes, and streams. Learn when to use each structure and practical patterns. -
Microservices Communication: Synchronous vs Asynchronous
Compare synchronous and asynchronous communication in microservices: REST, gRPC, message queues, event-driven patterns, and when to use each approach. -
PostgreSQL Full-Text Search: Implementation Guide
Implement full-text search in PostgreSQL using tsvector, tsquery, GIN indexes, and ranking. Learn how to build fast, relevant search functionality. -
Domain-Driven Design: Tactical Patterns
Learn DDD tactical patterns: entities, value objects, aggregates, domain services, repositories, and how to implement them in code. -
Managing Remote Engineering Teams: Technical Practices
Technical practices for managing remote engineering teams: async communication, code reviews, documentation, tooling, and building effective remote engineering culture. -
WebSocket Architecture for Real-Time Applications
Design real-time applications with WebSockets. Learn connection management, scaling strategies, message patterns, and production architectures for chat, notifications, and live updates. -
GitHub Actions: Automating Your Workflow
Automate CI/CD workflows with GitHub Actions. Learn workflows, jobs, steps, actions, and how to build, test, and deploy applications automatically. -
Building Mobile Apps with Flutter: A Practical Guide
Build cross-platform mobile apps with Flutter. Learn widgets, state management, navigation, API integration, and deployment for iOS and Android. -
Domain-Driven Design: Strategic Patterns
Learn Domain-Driven Design strategic patterns: bounded contexts, context mapping, shared kernel, and how to model complex domains effectively. -
Exit Strategy: Technical Lessons from Scaling a SaaS to Exit
Technical lessons learned from scaling a SaaS platform to acquisition. Covering architecture decisions, scaling challenges, team building, and what we'd do differently. -
Kubernetes Ingress Controllers: NGINX vs Traefik
Compare Kubernetes ingress controllers: NGINX Ingress vs Traefik. Learn configuration, SSL/TLS, load balancing, and when to use each controller. -
Message Queue Patterns: Fan-out, Priority Queues, and Dead Letter Queues
Implement advanced message queue patterns: fan-out, priority queues, dead letter queues, and message ordering. Learn production patterns for reliable message processing. -
PostgreSQL vs DynamoDB: Use Cases and Trade-offs
Compare PostgreSQL and DynamoDB: when to use each, performance characteristics, cost considerations, and migration strategies. Learn the trade-offs between SQL and NoSQL. -
Distributed Tracing with Jaeger and OpenTelemetry
Implement distributed tracing in microservices using Jaeger and OpenTelemetry. Learn about spans, traces, context propagation, and production patterns. -
React Hooks: A Complete Guide
Master React Hooks: useState, useEffect, useContext, useReducer, custom hooks, and performance optimization. Learn how to build modern React applications with hooks. -
Building a Multi-Region AWS Architecture
Design multi-region AWS architectures for high availability and disaster recovery. Learn about Route 53, CloudFront, RDS Multi-AZ, S3 cross-region replication, and failover strategies. -
Database Connection Pooling: Best Practices
Optimize database connections with connection pooling. Learn pool sizing, connection lifecycle, monitoring, and production patterns for PostgreSQL, MySQL, and MongoDB. -
gRPC: High-Performance RPC Framework
Build high-performance microservices with gRPC. Learn protocol buffers, streaming, error handling, and production patterns for inter-service communication. -
AWS Cost Optimization: Strategies for Reducing Cloud Spending
Reduce AWS costs through right-sizing, reserved instances, spot instances, storage optimization, and monitoring. Learn practical strategies to cut cloud spending by 30-50%. -
Observability in Microservices: Prometheus and Grafana
Implement observability in microservices using Prometheus for metrics collection and Grafana for visualization. Learn about metrics, alerts, and dashboards. -
Infrastructure as Code with Terraform: Getting Started
Learn Infrastructure as Code with Terraform. Create, manage, and version your cloud infrastructure using declarative configuration files. -
Scaling to 20M Users: Architecture Lessons Learned
Lessons learned from scaling a platform to 20 million users. Covering database optimization, caching strategies, microservices architecture, and infrastructure decisions. -
Building a GraphQL API with Node.js and TypeScript
Build a production-ready GraphQL API using Node.js, TypeScript, Apollo Server, and code generation. Learn type-safe resolvers, schema design, and best practices. -
API Gateway Patterns: Rate Limiting, Caching, and Authentication
Implement API gateway patterns for rate limiting, caching, authentication, and request routing. Learn how to build a production-ready API gateway with Kong, AWS API Gateway, or custom solutions. -
Kubernetes StatefulSets: Managing Stateful Applications
Deploy stateful applications in Kubernetes using StatefulSets. Learn about ordered deployment, stable network identities, persistent storage, and managing databases in Kubernetes. -
GitLab CI/CD: Automating Your Deployment Pipeline
Set up GitLab CI/CD pipelines for automated testing, building, and deployment. Learn pipeline configuration, stages, jobs, and deployment strategies. -
Distributed Systems Patterns: Circuit Breaker and Retry Logic
Implement resilience patterns in distributed systems: circuit breakers, retry logic, bulkheads, and timeouts. Learn how to handle failures gracefully in microservices. -
Implementing GraphQL Subscriptions for Real-Time Updates
Build real-time features with GraphQL subscriptions using WebSockets, covering Apollo Server subscriptions, client setup, and production patterns for chat, notifications, and live data. -
React Native for Cross-Platform Mobile Development
Building cross-platform mobile apps with React Native, covering setup, navigation, native modules, performance optimization, and deployment strategies. -
DynamoDB Data Modeling: Patterns and Best Practices
Learn DynamoDB data modeling patterns including single-table design, access patterns, GSIs, and how to model relational data in a NoSQL database. -
Building Event-Driven Microservices with AWS SNS and SQS
Architect event-driven microservices using AWS SNS and SQS for pub/sub messaging, covering topics, queues, dead-letter queues, and real-world patterns. -
GraphQL vs REST: A Comprehensive Comparison
Comparing GraphQL and REST APIs: when to use each, performance implications, developer experience, and real-world tradeoffs from building both in production. -
Getting Started with Kubernetes: Pods, Services, and Deployments
Introduction to Kubernetes fundamentals: pods, services, deployments, and basic operations. Learn how to deploy and manage containerized applications in Kubernetes. -
Serverless Pros and Cons: When to Go Serverless
Honest analysis of serverless computing: benefits, drawbacks, and when it makes sense. Real-world experience from building serverless applications in production. -
MongoDB Schema Design Patterns
MongoDB schema design patterns for common use cases, including embedding vs referencing, one-to-many relationships, and denormalization strategies. -
Social Media API Integration: Best Practices
Integrating with social media APIs including Facebook, Twitter, Instagram, and LinkedIn. Covering OAuth flows, rate limits, webhooks, and error handling. -
TypeScript in Production: Lessons Learned
Real-world lessons from using TypeScript in production, covering type safety, build configurations, migration strategies, and common pitfalls to avoid. -
High-Traffic System Design: Scaling to Millions of Users
Design patterns and strategies for building systems that handle millions of users, covering load balancing, caching, database scaling, and CDN integration. -
Redis Pub/Sub for Real-Time Applications
Building real-time features using Redis Pub/Sub, including chat applications, live notifications, and collaborative features with WebSocket integration. -
CQRS Pattern in Node.js: Separating Reads and Writes
Implementing Command Query Responsibility Segregation (CQRS) in Node.js applications, separating read and write models for better scalability and performance. -
Node.js Event Loop Deep Dive
Understanding Node.js event loop internals, phases, timers, and how asynchronous operations work under the hood for better performance optimization. -
Building Serverless APIs with AWS Lambda and API Gateway
Complete guide to building production-ready REST APIs using AWS Lambda and API Gateway, including authentication, error handling, and deployment strategies. -
Migrating from Monolith to Microservices: A Practical Approach
Lessons learned from migrating a monolithic application to microservices, including the Strangler Fig pattern, service boundaries, and avoiding common pitfalls. -
React Component Patterns: Composition vs Inheritance
Explore React component composition patterns, higher-order components, render props, and when to use each approach. Learn how to build reusable, maintainable React components. -
Introduction to AWS Lambda: Serverless Computing
Learn how AWS Lambda enables you to run code without managing servers. This guide covers Lambda fundamentals, use cases, and best practices for building serverless applications. -
Building a Queue Worker System with Beanstalk
Implement a robust queue worker system using Beanstalkd, covering job queuing, worker processes, priority handling, and monitoring for reliable background job processing. -
Docker Compose for Local Development Environments
Set up complete local development environments with Docker Compose, including multi-service applications, database seeding, hot reloading, and team collaboration workflows. -
Implementing Rate Limiting: Patterns and Best Practices
Learn how to implement effective rate limiting strategies using Redis, covering token bucket, sliding window, and distributed rate limiting patterns for production APIs. -
MySQL vs PostgreSQL: Choosing the Right Database
A comprehensive comparison of MySQL and PostgreSQL, covering performance, features, use cases, and migration considerations to help you choose the right database for your project. -
Event-Driven Architecture with RabbitMQ
Building scalable event-driven systems with RabbitMQ, covering exchanges, queues, routing patterns, and real-world examples for decoupled microservices communication. -
AWS S3: Beyond Simple Storage
Advanced S3 usage patterns including lifecycle policies, event notifications, static website hosting, CDN integration, and security best practices for production applications. -
Scaling Multi-Tenant SaaS Applications
Architectural patterns and practical strategies for scaling multi-tenant SaaS applications, covering database design, tenant isolation, and performance optimization. -
Redis as a Session Store: Patterns and Best Practices
Learn how to use Redis for session storage in distributed applications, including configuration, security patterns, and performance optimization for high-traffic systems. -
Docker for PHP Applications: A Complete Guide
Learn how to containerize PHP applications with Docker, including nginx, PHP-FPM, MySQL setup, and development workflows for modern PHP projects. -
PostgreSQL Query Optimization: A Practical Guide
Learn how to identify and fix slow PostgreSQL queries using EXPLAIN, indexes, and query planning techniques. Real-world examples and performance improvements. -
Building RESTful APIs with Laravel 5: Best Practices
A comprehensive guide to building production-ready RESTful APIs using Laravel 5, covering resource controllers, API authentication, versioning, and response formatting.