Writing about development and technology.
Everything I hit while converting from Pages Router to App Router — migration strategy, Server Component gotchas, data fetching rewrites, and honest before/after performance numbers.
CSP is the last line of defense that stops XSS scripts from executing even if injected. Directive syntax, nonce approach, Next.js config, and a safe rollout strategy — all covered.
From injection and broken auth to XSS and the newest threats — OWASP Top 10 broken down with real code examples and practical mitigations for each vulnerability.
Why REST still dominates, what GraphQL actually solves, and when gRPC really shines. A practical breakdown of all three API protocols with real code and decision criteria.
Backends split into microservices, but frontends stay as one giant monolith. Micro frontends solve that — here's what they fix, how composition works, and when it's actually worth it.
Every developer knows the feeling: fired up about an idea, then watching the repository collect dust. Here's the mindset and practical strategies that actually get projects across the finish line.
Monorepos eventually hit a build time wall. Here's how Turborepo's task graph and caching solve the problem, shown through a real Next.js monorepo setup.
Why does Figma feel fast in the browser? Dig into what WebAssembly actually is, and walk through the full workflow of building a Rust WASM module and calling it from JavaScript.
Hit the limits of media queries when building responsive components? Here's how @container solves the problem, broken down with real card component examples.
Can CSS animations alone make page transitions feel native? See how a single document.startViewTransition() call transforms your UX.
Kubernetes looks overwhelming at first glance. This post breaks down what Pods, ReplicaSets, Deployments, Services, Ingress, ConfigMaps, and Secrets actually do and how they connect — with practical YAML examples and local dev setup.
Developer journals are more than notes. Recording what you learned, where you got stuck, and why you made certain decisions measurably accelerates growth. Here's how to write them, what tools to use, and how to turn them into blog posts.
There are several ways to ship a new version without downtime. This post covers how rolling updates, blue-green, and canary deployments work, their trade-offs, and basic Kubernetes implementations.
How do you find where requests slow down in a microservices system? Learn how OpenTelemetry ties logs, metrics, and traces together to pinpoint bottlenecks with real code examples.
Incidents will happen. What matters is how fast you recover and what you learn. From severity levels and incident roles to blameless postmortems and action items that actually get done.
Separating deployment from release means you can roll back anything, anytime. A comparison of LaunchDarkly and Unleash, how to integrate their SDKs in React/Next.js, and how to keep flag debt under control.
Why clicking through the AWS console is a recipe for pain, and how declaring infrastructure as code with Terraform changes everything. Practical VPC + EC2 + RDS example included.
Converting words and sentences into numeric vectors lets you do math on meaning. From cosine similarity and ANN algorithms to the OpenAI embeddings API, here's everything you need to know.
Shipping an AI feature and calling it good because it 'seems to work' is not a quality strategy. This post covers types of LLM evals, key metrics, building evaluation datasets, eval tools like promptfoo and Braintrust, and integrating evals into CI.
AI coding tools are now part of daily development. This post honestly examines what skills are becoming more valuable, what's becoming less critical, and how to stay relevant in a world where the AI writes the code.
