BullMQ handles fire-and-forget jobs. Temporal handles crash-safe, stateful workflows. I picked the wrong one and it cost me a weekend. Here is how I choose.
Three index patterns dominate production query optimization: composite for multi-column filters, covering for index-only scans, partial for small subsets.
Uptime and error rate reveal nothing about agent health. Four metrics that matter, how to trace an agent's reasoning chain, and when to halt a run.
How circuit breaker patterns prevent payment provider outages from cascading into system-wide failures, with per-provider configuration strategies and fallback patterns for fintech systems.
Beyond console.log: the console.table, console.time, console.group, console.trace, and console.count methods that cut debugging time in the browser.
Message brokers cannot guarantee exactly-once delivery. The correct response is idempotent processing with deduplication tables and conditional writes.
Traditional tests break with AI outputs. The strategy I use in production: validate structure, set content boundaries, and test behavior, not exact strings.
Why soft deletes create state ambiguity, break audit trails, and trigger compliance incidents in financial systems, and what to use instead.
Why .env files are not a secrets manager, the configuration vs. secrets split, and three concrete changes I made to stop leaking credentials.
Free-form LLM output breaks in production pipelines. JSON Schema enforcement replaces 200 lines of defensive parsing with a compile-time guarantee on data shape.
An intelligent payment router that weighs cost, latency, and success rates to pick the best provider per transaction, cutting processing fees by 18%.
347 packages in a payment service, 335 of them transitive. Three had critical CVEs. If you are not auditing your dependency tree, you are shipping packages you have never heard of to production.
Why eventual consistency wins for search, CDNs, and analytics, breaks for payments and auth, and how to choose the right consistency model for each component in your system.
The chunking strategy determines retrieval quality in RAG systems. Fixed-size splitting destroys context. Here are four strategies that preserve meaning, plus metadata enrichment and deduplication patterns from production.
Why default timeout values cause cascading failures and duplicate charges in distributed payment systems, and the three timeout values you must configure independently.
When a 40-field form broke Zustand's store model, I switched to Jotai and removed 300 lines of state wiring. Here's when atomic state beats a centralized store.
How expand-contract, shadow tables, and adaptive backfills prevent migration-caused outages in production databases handling thousands of transactions per second.
Bigger context windows don't fix agent reliability. Structured memory, on-demand context loading, and state persistence are the architecture patterns that make autonomous agents work in production.
How to build payment webhook consumers that survive provider retries, missed events, and the 72-hour settlement window without losing financial data.
Framework defaults dump stack traces, credentials, and internal paths in production responses. A practical guide to stripping error payloads before they leave your server.
Vibe coding ships fast and breaks louder. The gap between prompting and engineering is taste, constraint, and knowing what you don't know.
Core Web Vitals, structured data, and crawl budgets. The technical SEO fundamentals most developers ignore — and what they cost in organic traffic.
What happened when I stopped hand-writing code and let AI agents handle implementation. The wins, the failures, and the guardrails you actually need.
Statelessness, caching, CAP theorem, message queues, databases, and API design — not as definitions to memorize, but as trade-offs to reason through. Production lessons from building distributed systems.
Six shifts that separate engineers who build real AI products from those who stay stuck calling APIs. From problem-first thinking to building your own mental operating system.
After years of reaching for Redux on every project, I switched to a three-tool stack that matches the problems I solve. Here is what changed and when Redux still wins.
How a payment reconciliation service went from 14-minute batches to 90 seconds by identifying session bloat, N+1 patterns, and bulk insert overhead in SQLAlchemy.
How to design a payment integration layer with automatic failover, circuit breakers, and idempotent retry that keeps transactions flowing when providers go down.
The GraphQL vs REST debate misses the point. What matters: typed contracts, boundary observability, and consumer-driven design.
How I structure production Flutter apps with Riverpod for state management and clean architecture layers that keep the codebase navigable past 100 screens.
How event sourcing enables real-time fraud detection and full transaction auditing in financial systems, with architecture patterns I've used in production.
Gregor Hohpe's framework for software architecture: risk management over gatekeeping, framing over answers, suitability over correctness, and political capital over authority.
Most teams adopt microservices before they need them. The distributed systems tax compounds fast. Here's when a monolith wins, and when services earn their cost.
The accounting principle behind every payment system. Skip it and you ship bugs that cost real money.
Why discriminated unions are the most practical TypeScript pattern for state, API responses, and form handling, with code examples from real production systems.
How I reduced a FastAPI service Docker image from 1.1GB to 280MB with multi-stage builds, the exact Dockerfile, and production hardening steps.
QRIS unified 30M merchants under one standard. BI-FAST brought real-time settlement to 17,000 islands. Lessons from building payment infrastructure for Indonesia.
A cloud-agnostic breakdown of the Well-Architected Framework: the five pillars, tradeoffs, maturity levels, and how I apply them in production systems.
What solution architects do beyond diagrams: decision records, tradeoff management, and the principles that separate effective architects from theorists.
How FastAPI's function-based dependency injection replaced middleware chains, context managers, and global singletons across my microservices architecture.
The shift from chasing best tools to choosing right tools for the context. How thinking in trade-offs separates senior architects from junior developers.
How I encode repeatable workflows into structured Hermes skill files that run on cron schedules, handle edge cases, and produce consistent results without human involvement.
A practical breakdown of PCI DSS requirements for early-stage fintechs. What you must do, what consultants overcharge for, and how to reach compliance without enterprise budgets.
Most fintech startups bolt on a ledger service after launch. Here's why building it first prevents months of reconciliation pain and phantom money bugs.
Relational databases excel at storing transactions but fail at detecting fraud rings. Here's how Neo4j models money laundering patterns that SQL queries struggle to surface.
Benchmark leaderboards dominate AI discourse. But the capability that ships real software — structured tool use — receives almost none of the attention it deserves.
Why enabling strict mode on every TypeScript project saves more time than it costs, and the production bugs it prevents that never show up in your metrics.
A payment service went dark for 90 seconds. The cause wasn't CPU, memory, or the database. It was pool exhaustion. Here's how to size, tune, and monitor connection pools in production.
The concrete workflow I use with AI coding agents to generate, review, and ship production code — no benchmark theater, real time savings, and what the AI still can't do.
How version-column OCC prevents double-spending and inventory oversell in distributed order processing without the performance penalty of pessimistic locks.
CSS container queries let components adapt to their own size, not the viewport. The shift from viewport-based thinking changes everything about responsive design.
What I learned applying CQRS to a payment processing service. Where it helped, where it got messy, and why you shouldn't start with it.
The real, unvarnished workflow of coding with two AI agents in 2026. No hype, no empty productivity claims — just what works day to day.
Why treating DLQs as incidents instead of designed buffers costs you money. Classification, retry strategy, and the reconciliation feedback loop that financial systems need.
After a decade of frontend work, I settled on five tools that ship and stay stable. No filler, no chasing trends.
How naive reconnection logic took down my production system, and the backoff, jitter, and state machine patterns that fixed it for 12,000 concurrent connections.
Multi-agent LLM systems fail at coordination, not prompting. Three orchestration patterns and state management strategies I use in production agent workflows.
A three-tier progressive KYC pipeline that gives legitimate users instant access while escalating only risky accounts. Built after watching fintech onboarding lose 30% of signups to manual review delays.
When I needed time-series data at scale, I skipped InfluxDB and installed a PostgreSQL extension. Query times dropped 10x and the ops burden vanished.
Why I stopped using DI frameworks in Python and started writing simpler, more testable code with plain constructors and manual wiring.
After seven years of React applications, I stopped using useEffect for data fetching. Here is what I use instead and why the ecosystem moved on.
Three scheduled runs per day. Zero manual effort. Here is how I automated my entire blog pipeline using Hermes cron jobs and the actual architecture behind it.
Flutter's sub-second hot reload ruined other development environments for me. Here is why that expectation is reasonable and what it taught me about developer experience.
Standard HTTP status codes are not enough. A structured error taxonomy with error codes, severity levels, and machine-readable payloads transforms debugging from guesswork into systematic root cause analysis.
After generating thousands of lines of production code with AI, here are the prompting techniques that consistently deliver and the popular advice I stopped following.
A hands-on breakdown of the Saga pattern with choreography and orchestration approaches, based on building a three-service payment flow that must not lose money.
Why Astro's content collections were the best content architecture decision I made, even after migrating to Next.js.
A practical guide to building audit logging systems that satisfy PCI-DSS, SOC 2, and regional banking regulations without over-engineering.
How a single partial index reduced query latency on a 50M-row payments table and what I learned about PostgreSQL query planning along the way.
A nuanced take on AI coding agents — what they're genuinely good at, where they fail, and how senior engineers should adapt their workflow.
Three dependent useEffect chains tangled across a dashboard component. One Zustand store with derived state fixed it. Here is how the refactor went.
Exploring how code knowledge graphs give AI agents structured understanding of large codebases, enabling better navigation, refactoring, and context-aware reasoning.
A deep dive into the Model Context Protocol and how it enables Hermes to build real-time understanding of large codebases through structured tool interfaces.
Lessons learned implementing rate limiting on a high-throughput payment gateway — the algorithms, the edge cases, and the production incidents.
Event-driven doesn't require event sourcing. You can decouple services with lightweight event patterns — no Kafka cluster or distributed systems PhD needed.
RSC doesn't just move rendering to the server. It destroys the 'client vs. server' mental model and replaces it with something sharper.
How multi-stage Docker builds reduce image sizes by 80% for fintech microservices while maintaining security compliance requirements.
Why event-driven patterns are ideal for payment processing — from idempotency to reconciliation to audit trails.
CQRS looks elegant in architecture diagrams. In production, it introduces complexity you didn't plan for. Here's what I learned applying it under real constraints.
Six media query breakpoints, five layout bugs, and one CSS Grid line later, our dashboard just worked. Why auto-fit beats fixed breakpoints.
How shifting repetitive code generation to an autonomous agent compressed my feature delivery from days to hours and freed me to focus on architecture.
Multi-currency transactions break naive reconciliation. I built an engine with threshold-based matching that handles FX rate gaps and rounding without drowning in false positives.
Design patterns that make fintech APIs predictable, versionable, and secure — lessons from building APIs for payment gateways and trading platforms.
A practical playbook for incrementally decomposing a monolith — strangler fig pattern, feature flags, and avoiding the distributed monolith trap.
Duplicate payments from retry logic cost real money and trust. Idempotency keys prevent them, and most payment APIs get the implementation wrong.
Switching from useEffect to async server components rewired my React data fetching. What changed and where client-side patterns still win.
How branded types, opaque types, and exhaustive checking in TypeScript catch entire categories of financial bugs at compile time.
How to build CI/CD pipelines that satisfy both engineering velocity goals and regulatory compliance requirements — not an either/or choice.
Benchmarks do not decide my runtime. Production reliability, ecosystem maturity, and debugging tooling do. Here is where Bun and Node.js stand for backend services.
Payment events that vanish between your database and message broker cost real money. The outbox pattern closes that gap without distributed transactions.
A practical comparison of JSONB and relational models for financial data — not a religious debate, but a guide to choosing the right tool.
A pragmatic security checklist for Node.js payment services — from dependency scanning to runtime protection to incident response.
The reusable GitHub Actions workflows that form the CI foundation across all my projects — linting, testing, building, and deploying.
Beyond unit tests — property-based testing, contract testing, and simulation testing for financial systems where correctness is non-negotiable.
Reflections on the transition from writing code to designing systems — the mindset shifts, the new skills, and what I wish I'd known earlier.
Welcome to my blog. I write about IT, engineering, business, marketing, and daily life as a system architect.
The best way to get a project done faster is to start sooner.