SQL to LINQ LEFT JOIN Masterclass: EF Core 10 and Modern Data Access
Discover the revolutionary LeftJoin operator introduced in EF Core 10: relief from GroupJoin complexity, mental model compatibility between SQL and LINQ…
C# in Production (C#)
Posts about csharp
How Does a CQRS (Command Query Responsibility Segregation) Pipeline Work? Anatomy of Command and Query Flows
What is a CQRS request pipeline? How does an HTTP request travel through Controller, MediatR, pipeline behaviors, a handler, Outbox, and a read model?
From CRUD (Create, Read, Update, Delete) to CQRS (Command Query Responsibility Segregation): The Problem Is Not Code, It Is the Model
What is CQRS, what is the difference between CRUD and CQRS, and when should CQRS be used? A guide to why one model stops being enough in larger systems.
CQRS (Command Query Responsibility Segregation) in Distributed Systems: Events, Brokers, and Projections
How does CQRS work in distributed systems? A practical guide to domain events, message brokers, projections, Outbox, idempotency, and eventual consistency.
CQRS (Command Query Responsibility Segregation) in Production: Consistency, Failure, and Recovery
How does CQRS stay safe in production? Consistency lag, duplicate events, reordering, projection recovery, retries, DLQs, and Saga strategies.
DDD- Designing Software Around the Business, Not the Database
What is Domain-Driven Design? A guide to the limits of data-driven design, the power of ubiquitous language, and when DDD is a worthwhile investment.
DDD in Code: Entity, Value Object, and Aggregate
How do DDD tactical patterns work? Explore Value Objects, Entities, Aggregates, Domain Services, Application Services, and Repository boundaries through a…
How Does DDD Work in Large Systems?
How does DDD scale in large systems? A decision guide to Bounded Contexts, Context Mapping, Conway's Law, modular monoliths, microservice boundaries, and…
DDD in Production: Distributed Systems and Modernization Strategies
How does DDD survive production change? A guide to Event Storming, Saga, Transactional Outbox, Anti-Corruption Layers, and Strangler Fig modernization.
From Layers to Features: Why Did Vertical Slice Emerge?
Why does layered architecture slow change as a system grows? An architectural guide to Vertical Slice as a decision about feature ownership, behaviour…
How Does a Vertical Slice Work from the Inside?
A technical guide to the inner flow of a Vertical Slice: request, validation, handler, aggregate, outbox, projection, idempotency, performance, tests, and…
Why Payment Systems Are Distributed Systems
A payment is never one service's job: basket, stock, provider gateway, and ledger all have to agree. Here's why the synchronous chain breaks down.
Payment State Machine Design: Checkout vs. Payment Lifecycles
Payment.Succeeded does not mean Checkout.Completed. If you don't separate checkout and payment lifecycles, two truths collide in production.
Why Payment Capture Is Easy but Finalization Is Hard
The PSP taking the money is one step. Finishing the order is a saga that needs stock, finance, notifications, and cleanup to all succeed.
Immutable Payment Snapshot Design: Freezing the Cart at Intent Time
Re-reading the live basket during payment leaves amount and currency undecided. Without a snapshot frozen at intent time, finalization can't be trusted.
Idempotency Beyond API (Application Programming Interface) Requests: A Layered Defense
Idempotency isn't one header. It's a defense stack that has to be built separately across five layers, from the API key down to the step marker.
Webhook Reliability in Payment Systems
Webhooks repeat, disappear, arrive out of order, and show up late. Verify the signature, ACK fast, and never run the heavy work synchronously.
The Outbox/Inbox Pattern in Payment Systems
If a database write and an event publish aren't in the same transaction, one can vanish or duplicate. Outbox publishes; inbox dedups on the consumer.
Payment Evidence vs. Payment State
Evidence is what the PSP told you. State is what you decided. Conflate the two, and recovery leaves you unsure which one to trust.
Provider Abstraction Without Leaking SDKs
How the provider gateway owns the PSP SDK while the checkout orchestrator only ever sees a semantic interface — and why card and wallet flows share a…
Semantic Events Over Raw Provider Payloads
Should the webhook the provider gateway receives reach downstream consumers under the PSP's own event name, or as a semantic event like…
Payment Failure Taxonomy
A timeout, a 429, a 5xx, a business decline, and an infrastructure fault are not the same failure. Each category needs its own retry policy.
Retry Algorithms for Payment Workers
Exponential backoff, jitter, caps, the difference between retry and defer, and circuit breakers — turning the previous part's taxonomy into working code.
DB-Backed Jobs With Leases
Acquiring a lease with a conditional UPDATE, the stuck-job watcher that rescues abandoned work, and why a broker's Nack alone isn't enough.
Building a Payment Reconciliation Worker
How sweepers heal drift: the PSP says succeeded while the local record says expired, and how aged FinalizePending records get resolved.
Healing Paid-But-Unordered Payments
An incident playbook: the customer was charged but no order exists; the multi-intent cart problem; and why dedup must be cleaned up carefully.
Why Eventual Consistency Beats Distributed Transactions
Building a 2PC across the PSP, the order, and finance is a trap. Saga plus reconciliation is the real answer this eight-part arc has been building toward.
Optimistic Concurrency Under Webhooks
When a webhook and a synchronous response touch the same payment at once, how do a version token and a lease resolve the race — and why can a stale read…
Payment Observability and Correlation
How to correlate every log, metric, and trace by payment id — and why a step event log plus deferred finalize metrics save operations.
Payment Recovery Pipeline and Runbooks
Automation first: the reconciliation worker and recovery pipeline. When uniqueness walls block replay, evidence-driven human runbooks take over.
Effectively-Once Processing in Payments
Exactly-once messaging is a lie. How defense in depth — idempotency, dedup, outbox, and reconciliation — produces an effectively-once business outcome.
Designing a Production Payment Engine
The synthesis of a 22-part series: an architectural checklist for a production payment engine built around a checkout orchestrator and provider gateway.
What Fintech Companies Actually Hire For
Career perspective: fintech companies aren't looking for Stripe SDK skills — they want failure thinking, reconciliation, idempotency, and evidence-driven…