Travel Review Platform: Moderation, Fraud, and the Recency Problem
Running a travel review platform at scale — review eligibility, fraud detection, ranking that resists gaming, and the moderation workflow that makes it trustworthy.
Engineering articles
for enterprise systems.
Practical writing and lessons from building systems where correctness, reliability, and recovery matter.
78 published articles
Topics
+60 more
CockroachDB from First Principles: The Database That Refuses to Die
Why a global SQL database is really a problem of agreement and time, how Google solved it with TrueTime, GPS, and atomic clocks, and how CockroachDB reaches a practical design on ordinary infrastructure.
How Async and Await Work in C#
A story-led explanation of Tasks, compiler-generated state machines, continuations, threads, I/O completion, exceptions, cancellation, contexts, and practical async design in .NET.
How the ASP.NET Core Runtime Handles a Request
A plain-English walkthrough of how an ASP.NET Core application starts, builds its middleware pipeline, accepts traffic through Kestrel, selects an endpoint, and returns a response.
Replacing Self-Managed Kafka with Azure Event Hubs
An end-to-end migration article covering compatibility, partition mapping, dual running, cutover, rollback, and the operational model after Kafka.
From CockroachDB to Kafka: Change Data Capture with a C# Consumer
A story-led, end-to-end guide to CockroachDB changefeeds, Kafka records, and a practical C# consumer, including offsets, ordering, duplicates, recovery, and production design.
Read Replicas: The Right Answer, the Wrong Moment, and How to Keep Users From Seeing It
Asynchronous replication separates primary commit, standby receipt, durable flush, and replay. Read-your-writes depends on replay; failover loss depends on what reached the promoted standby.
OFFSET Pagination: The Query That Gets Slower the Deeper You Scroll
OFFSET makes the executor process and discard rows before the page, so deep pages grow linearly even with an index. Keyset pagination bounds that work, and a unique tiebreaker makes the cursor unambiguous.
Batching: Turning a Thousand Round Trips Into One
How to remove database round trips without confusing batching, transactions, preparation, concurrency, and bulk-loading behavior in Npgsql and PostgreSQL.
The N+1 in EF Core: Where It Comes From, How to See It, and How to Make It a Test Failure
The N+1 is not a slow query, it is a correct query repeated thousands of times, and because it works in development with ten rows the only reliable defence is a query count assertion in the test suite.
Soft Deletes: Why a Unique Constraint Cannot Span a Column You Can Change
A soft-deleted row still holds its unique value, so the second registration of the same email fails on a constraint nobody expected to fire. The fix is a partial index, and the decision about whether to use one is upstream of that.
JSONB: Winning the Schema Argument by Deferring It
A JSONB column lets you add an attribute without a migration, which is a real win. The mistake is treating that freedom as a licence to put everything in it, and the mature answer is a hybrid.
Connection Pool Sizing: Little's Law, max_connections, and the Multiplication Nobody Budgeted
How many database connections you actually need is arithmetic, not intuition, and the real risk is that your pod count multiplies a per-instance default into more connections than Postgres has.
Foreign Keys: The Index You Forgot and the Lock You Didn't Ask For
How PostgreSQL foreign keys use child-side access paths and parent-row locks, how to audit composite indexes, and how validation differs from enforcement.
ADD COLUMN: The Lock Queue Behind a Metadata-Only Migration
Why a five millisecond metadata change stalled a site for forty minutes, how a queued ACCESS EXCLUSIVE lock blocks every query behind it, and why lock_timeout is the setting that makes a migration safe.
Deadlocks: Two Transactions, Two Orders, and a Permanent Stop
A deadlock needs a cycle in the wait-for graph, which is why consistent lock ordering removes an entire class of incident, and why the database picking a victim is the good outcome.
Isolation Levels: The Table That Does Not Describe Your Database
Why the ANSI isolation table describes symptoms rather than mechanisms, what MVCC changed, and how snapshot isolation still lets two correct transactions corrupt each other.
fsync: The Flush Between a Commit and Stable Storage
How PostgreSQL separates writes, WAL flushes, synchronous commit, hardware truthfulness, and group commit—and where each durability promise can fail.
LSM Compaction: The Background Job That Becomes a Foreground Outage
Why an LSM engine saturates a disk with no user traffic, how write stalls turn a background merge into a latency incident, and why the disk needs headroom a capacity graph will never show.
The RUM Conjecture: Read, Update, and Memory Amplification
The RUM conjecture frames an access method as a trade among read overhead, update overhead, and memory or storage overhead—not as a theorem about range scans.
Covering Indexes: Turning One Random Read Per Row Into Zero
Why a matching index still costs one random read per row, how INCLUDE columns turn that into an index-only scan, and why a stale visibility map quietly puts the heap read back.
Unused Indexes: The Planner Is Reading Statistics You Forgot to Refresh
Sargability, stale statistics, the leftmost prefix rule, correlated columns, and the cost settings that make a planner reject an index it should have chosen.
UUID Primary Keys: Locality, Page Splits, and the Cost You Must Measure
Random UUIDs spread B-tree inserts across leaf pages; time-ordered UUIDs improve locality. The effect differs sharply between InnoDB's clustered table and PostgreSQL's heap.
LFU Cache in O(1): Two Maps, Frequency Buckets, and a Minimum That Resets
A key-to-node map, frequency buckets, and a minFreq pointer that advances on promotion and resets on insertion, plus concurrency and aging limits of exact LFU.
Dynamic Pricing for Travel: The Model Is the Easy Part
Revenue management for travel — demand forecasting, price fences, the difference between dynamic and surge, and why published prices must be honoured.
Seat Selection and Reservation: A Graph Problem Wearing an Airline Uniform
Aircraft seat maps as a constraint problem — legality, preference, family adjacency, and the concurrent reservation race that a seat map is uniquely bad at.
Price Alert System: Notifying People About Prices You Cannot Promise
Price alert infrastructure — polling strategies, trigger thresholds, alert fatigue, and the honesty problem when the price moves after you alert.
Vacation Rental Marketplace: The Calendar Is the Product
Short-term rental platforms at scale — the 365-night calendar, host reliability, dynamic pricing integration, and local regulation as a first-class constraint.
Accommodation Marketplace: Two Sides of a Transaction That Never Meet
Running a two-sided accommodation marketplace — supply onboarding, ranking that serves both sides, payments in a regulated flow, and the disputes problem.
Practical DRY Beyond Code Reuse
Using DRY to keep business knowledge authoritative across rules, contracts, data, operations, and documentation without forcing unrelated code into one abstraction.
Hotel Booking System: Inventory That Is a Physical Room, Not a Database Row
Hotel booking as an overbooking-and-allocation problem — room types, allotments, cancellation policy state, and the race between hold, book, and confirm.
Flight Search System: Caching by Degradation, Not by Answer
Flight search at scale — GDS and aggregator fan-out, result caches that age gracefully, and the itinerary-combinatorics problem that makes searching hard.
Waze-Style Navigation at Scale: Routing Engines, Map Matching, and the Traffic Model
Building navigation at map scale — road-graph routing, map matching from GPS traces, live traffic estimation, and incremental rerouting.
Logistics Package Tracking: The Event Stream Behind a Progress Bar
Package tracking as a scan-event pipeline — status models, exception handling, the ETA problem, and why carrier webhooks are the hard part.
Last-Mile Delivery System: The Problem That Is 80% Small Talk and 20% Optimisation
Last-mile delivery route design, density-based territory planning, failed delivery recovery, and the operational details that dominate the economics.
Driver Dispatch System: Assigning Work When the Vehicle Is Not the Constraint
Freight dispatch with capacity, hours-of-service, and multi-depot realities — the parts of dispatch that a load board does not solve.
Travel Itinerary Planner: Constraint Search Where the User Is the Optimiser
Multi-day itineraries as constraint satisfaction, with travel time, opening hours, reservations, and the user's own trade-offs made explicit.
Ride Matching Algorithm: Batching, Detours, and the Trade-off Every Marketplace Rediscovers
How ride matching actually works — spatial partitioning, ETA matrices, batch windows, and why lowest-detour and shortest-wait pull in opposite directions.
Travel Recommendation Engine: Why the Obvious Approach Fails and What Actually Works
Candidate generation, two-stage ranking, exploration, and the feedback loops that turn a travel recommender into a filter bubble.
Route Optimization Engine: The Problem That Looks Like a Shortest Path and Is Not
Vehicle routing with capacity and time windows, large neighbourhood search, and why an optimal solution computed offline is worthless by morning.
EV Charging Platforms: The Meter Is the Product and the Connector Is the Weakness
OCPP, the five-system transaction, demand charges on connected capacity, idle bays, and why public charging reliability is a hardware problem wearing a software costume.
Micromobility Platforms: The Ride Is a Distributed Transaction
The unlock and ride lifecycle, when a ride actually starts, curb economics, battery swap logistics, and why the payment authorisation is the hardest part of a scooter.
Stream Processing System: Kafka and Flink, and the Watermark You Will Misconfigure
Event time versus processing time, checkpointing and exactly-once state, backpressure, and choosing heap or disk-backed state with an explicit recovery budget.
Fleet Management Systems: The Platform Is Telematics, the Product Is Exceptions
Hours-of-service compliance, driver behaviour scoring as an employment decision, fuel leakage, and why a fleet system's real value sits in the five percent of cases that are not normal.
Long Polling in .NET
Designing a cursor-based long-poll endpoint in ASP.NET Core with bounded waits, replay, replica coordination, overload control, and failure testing.
Batch Processing System: Spark on Kubernetes, and Why Your Jobs Are Slow
Scheduling, shuffle, data skew, dynamic allocation, and the operational patterns that decide whether a 4-hour batch job is a cost centre or an outage risk.
Smart Home Platforms: The Test Is Whether It Works With the Internet Unplugged
Local-first hubs, Matter and Thread, the state machine behind automations, and why a smart home that stops working during an outage is a remote control with extra features.
File Uploads with Swagger and Minimal APIs
Designing a .NET upload boundary that is honest about buffering, quotas, untrusted metadata, scanning, durable storage, retries, and OpenAPI.
ETL Pipeline: The Extract That Fails Silently Is Worse Than the One That Crashes
Incremental extraction, idempotent loads, late-arriving data, backfills, and the data quality checks that decide whether anyone trusts the warehouse.
Connected Vehicle Platforms: A Client That Lives Longer Than Your Backend
The fifteen year fleet problem, what a CAN bus will actually let you log, command safety on an intermittently connected car, and why a connected vehicle has four data subjects and not one.
IoT Analytics Platforms: Hot, Warm, Cold, and the Query That Breaks All Three
Tiered storage for device telemetry, the wide-versus-narrow table decision that changes everything, and why rolling data up is cheaper than querying it raw.
Base Controllers and Shared .NET Concerns
A boundary-first way to decide whether shared API behavior belongs in a base controller, middleware, filters, authorization, or explicit application services.
Smart City Platforms: Designing for a Federation, Not a Product
Why the hard problem in city data is departmental ownership rather than throughput, and what to do about coordinate systems, spatial joins, privacy, and data quality you can defend.
Data Mesh Architecture: Four Principles and the Organisation Chart Hiding Inside Them
Domain ownership, data as a product, the federated plane, and why data mesh is a reorganisation with an API in front of it.
Industrial IoT Platforms: Where the Cloud Stops and the Plant Starts
The IT and OT boundary, the edge, OPC-UA versus Modbus, historians, digital twins, and why a control loop must never depend on a network it does not own.
Parallel Programming in .NET
Choosing and operating bounded parallelism in .NET across CPU work, asynchronous I/O, channels, dependency limits, cancellation, and production measurement.
IoT Device Management: Registry, Configuration, and Firmware at Fleet Scale
Desired state versus reported state, bulk configuration, staged firmware rollouts, and why a two million device fleet is a control plane problem before it is a console problem.
Secure Password Hashing in .NET
Choosing and operating password hashing in .NET with ASP.NET Core Identity, Argon2id or PBKDF2, versioned envelopes, peppers, upgrades, and capacity controls.
Metadata Management: The Catalogue That Nobody Updates Until the Day They Need It
Schema registries, compatibility modes, ownership as data, and why a metadata system without enforced write paths becomes a documentation site.
Solving Time Zone Challenges with EF Core
Modeling instants, local dates, wall-clock schedules, offsets, and time-zone identifiers explicitly across .NET, EF Core, databases, and APIs.
IoT Data Ingestion: The Platform Between a Device and Kafka
Connection counts, QoS, session state, provisioning, and the MQTT to Kafka bridge, written for fleets large enough that the hard problem is connections rather than throughput.
Sensor Data Pipelines: What Happens Between the Device and the Alert
How a high-frequency sensor stream is partitioned, windowed, and turned into an alarm, including the state-size problem that decides whether a stream processor survives contact with real data.
Distributed Tracing: You Cannot Sample 100% and You Cannot Store 100%
Spans, context propagation, head versus tail sampling, and the cardinality decisions that determine whether your tracing bill is a line item or an incident.
How a Time-Series Database Stores Data: A Prometheus-Style Design
A concrete Prometheus-style storage path—head data, WAL, encoded chunks, label indexes, blocks, compaction, and cardinality—plus where other time-series engines differ.
Chaos Engineering Platform: Breaking Things on Purpose Is a Measurement Problem
Steady-state hypotheses, blast radius controls, abort conditions, and the discipline that separates experiments from outages with extra steps.
RabbitMQ Between Microservices
Designing RabbitMQ service boundaries with owned queues, publisher confirms, transactional outbox and inbox records, bounded retries, backpressure, and recovery tests.
Canary Deployment: The Percentage of Your Users Who Find the Bug First
Weighted routing, metric gates that actually mean something, analysis windows versus sample size, and why most canary systems fail at the metric check.
Real-Time GPS Tracking: From Device Ping to Live Map
How a fleet of GPS devices turns location pings into a live map, without losing positions, overwriting history, or melting the database.
Monitoring and Alerting: Why Your Alerts Are Noisy and Your Outages Are Not Caught
Prometheus pull semantics, cardinality, recording rules, alert routing with inhibition, and the difference between a metric that explains an incident and one that pages someone.
Distributed Job Scheduler: A Cron Table That Ten Thousand Services Write To
Leader-elected scheduling, a timing wheel, DAG dependencies, and the exactly-once claim that is actually at-least-once plus idempotency.
Blue-Green Deployment: The Deployment Where Your Rollback Plan Is a DNS TTL
Two identical environments, database migrations that break the contract, and the failure modes that turn a supposedly-safe switchover into an outage.
Health Checks and Heartbeats: Three Different Questions That Look Identical
Liveness, readiness, and heartbeat are not the same test, and conflating them is how a slow dependency restarts your entire fleet.
Multi-Tenant SaaS Architecture: Isolation Tiers and the One You Should Start On
Shared schema, database-per-tenant, schema-per-tenant, and the row-level security middle ground — with the noisy-neighbour maths that picks the tier.
Service Mesh: Every Request Now Goes Through a Proxy, So What Did You Buy
xDS control plane, sidecar versus ambient, mTLS with SPIFFE identity, and the honest reasons a mesh is worth it — and the ones that are not.
Container Orchestration: The Scheduler Is Easy, the Controller Is the Product
Two-phase scheduling, level-triggered reconciliation, the pod lifecycle, and why a Kubernetes-style control loop is the reusable idea underneath every orchestrator.
Secrets Management: The Design Where Decryption Should Be the Rare Event
Envelope encryption, HSM-backed roots, dynamic database credentials, and why the hard part of secrets management is revocation, not storage.
Distributed Lock Service: Why a Lock Is Not Enough and the Token That Fixes It
Fencing tokens, Redlock's pause problem, ZooKeeper's sequential ephemeral nodes, and the honest limits of TTL-based mutual exclusion.
Distributed Configuration Management: The Part Where Everyone Builds a ZooKeeper
Raft, linearizable reads, watch fan-out, and MVCC — how etcd and Consul actually keep fifty thousand services watching config without falling over.
No articles match that filter yet.