👋 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
-
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. -
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 treats scope, time, and cross-modal connectivity as kernel-level primitives. Update 2026-04-17 (v2 revision): episode-scoped retrieval delivers a perfect-recall multimodal answer in 197 µs at N=1M, 33× faster than FAISS-Flat-GPU on the same hardware — but only 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.