<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"><channel><title>Katabench engineering blog</title><description>Practical field notes on C#, .NET performance, EF Core, software architecture, security, testing, and deliberate practice.</description><link>https://katabench.com/</link><language>en-us</language><item><title>Database deadlocks: find the cycle and retry the transaction</title><link>https://katabench.com/blog/database-deadlocks</link><guid isPermaLink="true">https://katabench.com/blog/database-deadlocks</guid><description>Diagnose database deadlocks with a two-session example. Fix inconsistent lock ordering, keep transactions short, and retry the complete operation safely.</description><pubDate>Tue, 06 Oct 2026 00:00:00 GMT</pubDate><category>Databases &amp; EF Core</category><author>The Katabench team</author></item><item><title>TimeProvider testing in C#: stop waiting for the clock</title><link>https://katabench.com/blog/timeprovider-testing-csharp</link><guid isPermaLink="true">https://katabench.com/blog/timeprovider-testing-csharp</guid><description>Make TimeProvider testing in C# deterministic. Check expiry and delays with FakeTimeProvider, distinguish elapsed time, and avoid asynchronous clock races.</description><pubDate>Mon, 05 Oct 2026 00:00:00 GMT</pubDate><category>Testing &amp; Refactoring</category><author>The Katabench team</author></item><item><title>Dead-Letter Queues: Diagnose Failures and Replay Safely</title><link>https://katabench.com/blog/dead-letter-queue</link><guid isPermaLink="true">https://katabench.com/blog/dead-letter-queue</guid><description>Use a dead-letter queue to isolate poison messages, diagnose failed deliveries, and replay repaired work without duplicating effects or hiding lost jobs.</description><pubDate>Sun, 04 Oct 2026 00:00:00 GMT</pubDate><category>System Design</category><author>The Katabench team</author></item><item><title>HttpClient lifetime: socket exhaustion and stale DNS</title><link>https://katabench.com/blog/httpclient-lifetime-socket-exhaustion</link><guid isPermaLink="true">https://katabench.com/blog/httpclient-lifetime-socket-exhaustion</guid><description>Fix HttpClient lifetime mistakes by separating clients, handlers, and connections. Learn connection reuse, DNS refresh, and response ownership in .NET.</description><pubDate>Sat, 03 Oct 2026 00:00:00 GMT</pubDate><category>.NET Performance</category><author>The Katabench team</author></item><item><title>A code review checklist for production changes</title><link>https://katabench.com/blog/code-review-checklist</link><guid isPermaLink="true">https://katabench.com/blog/code-review-checklist</guid><description>Use a code review checklist that starts with production risk. Follow a stock reservation change through correctness, rollout safety, tests, and feedback.</description><pubDate>Wed, 30 Sep 2026 00:00:00 GMT</pubDate><category>Engineering Practice</category><author>The Katabench team</author></item><item><title>API Backward Compatibility During a Rolling Deployment</title><link>https://katabench.com/blog/api-backward-compatibility</link><guid isPermaLink="true">https://katabench.com/blog/api-backward-compatibility</guid><description>Preserve API backward compatibility while old clients and servers coexist. Design additive contracts, safe defaults, and tests for staged HTTP rollouts.</description><pubDate>Tue, 29 Sep 2026 00:00:00 GMT</pubDate><category>Architecture &amp; Design</category><author>The Katabench team</author></item><item><title>SQL EXISTS vs IN: get membership and NULLs right</title><link>https://katabench.com/blog/sql-exists-vs-in</link><guid isPermaLink="true">https://katabench.com/blog/sql-exists-vs-in</guid><description>Compare SQL EXISTS vs IN with worked examples, the NOT IN NULL trap, semi joins, and a query-plan method that tests performance without folklore.</description><pubDate>Sun, 27 Sep 2026 00:00:00 GMT</pubDate><category>Databases &amp; EF Core</category><author>The Katabench team</author></item><item><title>Property-based testing in C#: invariants that find bugs</title><link>https://katabench.com/blog/property-based-testing-csharp</link><guid isPermaLink="true">https://katabench.com/blog/property-based-testing-csharp</guid><description>Use property-based testing in C# to check invariants with FsCheck, generate valid inputs, shrink failing cases, and turn discoveries into regression tests.</description><pubDate>Sat, 26 Sep 2026 00:00:00 GMT</pubDate><category>Testing &amp; Refactoring</category><author>The Katabench team</author></item><item><title>Resource-Based Authorization in ASP.NET Core</title><link>https://katabench.com/blog/resource-based-authorization-aspnet-core</link><guid isPermaLink="true">https://katabench.com/blog/resource-based-authorization-aspnet-core</guid><description>Use resource-based authorization in ASP.NET Core to stop IDOR: check ownership, enforce tenant boundaries, and test access before returning private data.</description><pubDate>Thu, 24 Sep 2026 00:00:00 GMT</pubDate><category>Security &amp; Reliability</category><author>The Katabench team</author></item><item><title>IAsyncEnumerable in .NET: stream without hiding the cost</title><link>https://katabench.com/blog/iasyncenumerable-streaming-dotnet</link><guid isPermaLink="true">https://katabench.com/blog/iasyncenumerable-streaming-dotnet</guid><description>Use IAsyncEnumerable in .NET to process results as they arrive. Compare buffering, propagate cancellation, and keep resources alive until enumeration ends.</description><pubDate>Wed, 23 Sep 2026 00:00:00 GMT</pubDate><category>.NET Performance</category><author>The Katabench team</author></item><item><title>Design a file storage service: uploads, scans, downloads</title><link>https://katabench.com/blog/design-a-file-storage-service</link><guid isPermaLink="true">https://katabench.com/blog/design-a-file-storage-service</guid><description>Design a file storage service where bytes never pass through the API: scoped signed uploads, a metadata state machine, an async scan queue, and edge downloads.</description><pubDate>Mon, 21 Sep 2026 00:00:00 GMT</pubDate><category>System Design</category><author>The Katabench team</author></item><item><title>Design a real-time chat system: WebSockets and presence</title><link>https://katabench.com/blog/design-a-realtime-chat-system</link><guid isPermaLink="true">https://katabench.com/blog/design-a-realtime-chat-system</guid><description>Design a real-time chat system around long-lived connections: a gateway tier, a session registry, pub/sub fan-out, per-conversation sequences, and presence.</description><pubDate>Mon, 21 Sep 2026 00:00:00 GMT</pubDate><category>System Design</category><author>The Katabench team</author></item><item><title>Design a web crawler: frontier, politeness, and dedup</title><link>https://katabench.com/blog/design-a-web-crawler</link><guid isPermaLink="true">https://katabench.com/blog/design-a-web-crawler</guid><description>Design a web crawler as a scheduling problem: a URL frontier, per-host politeness, a fetch/parse checkpoint, dedup at scale, and recrawl by change rate.</description><pubDate>Mon, 21 Sep 2026 00:00:00 GMT</pubDate><category>System Design</category><author>The Katabench team</author></item><item><title>Distributed tracing in .NET with OpenTelemetry</title><link>https://katabench.com/blog/distributed-tracing-opentelemetry-dotnet</link><guid isPermaLink="true">https://katabench.com/blog/distributed-tracing-opentelemetry-dotnet</guid><description>Timeout in service C, silence in A and B: context never propagated. How traceparent, ActivitySource, and OpenTelemetry turn three logs into one trace.</description><pubDate>Mon, 21 Sep 2026 00:00:00 GMT</pubDate><category>Architecture &amp; Design</category><author>The Katabench team</author></item><item><title>Mass assignment in ASP.NET Core: over-posting explained</title><link>https://katabench.com/blog/mass-assignment-aspnet-core</link><guid isPermaLink="true">https://katabench.com/blog/mass-assignment-aspnet-core</guid><description>Mass assignment in ASP.NET Core: the binder sets any property a request names, so extra JSON flips IsAdmin. Why validation misses it and the allowlist fix.</description><pubDate>Mon, 21 Sep 2026 00:00:00 GMT</pubDate><category>Security &amp; Reliability</category><author>The Katabench team</author></item><item><title>Mocks vs stubs vs fakes: choosing a test double in C#</title><link>https://katabench.com/blog/mocks-stubs-fakes-csharp</link><guid isPermaLink="true">https://katabench.com/blog/mocks-stubs-fakes-csharp</guid><description>Mocks vs stubs vs fakes in C#: what each test double can detect, why interaction-heavy mocks go red on every refactor, and when a hand-written fake wins.</description><pubDate>Mon, 21 Sep 2026 00:00:00 GMT</pubDate><category>Testing &amp; Refactoring</category><author>The Katabench team</author></item><item><title>Partial, covering, and expression indexes in PostgreSQL</title><link>https://katabench.com/blog/partial-covering-expression-indexes-postgresql</link><guid isPermaLink="true">https://katabench.com/blog/partial-covering-expression-indexes-postgresql</guid><description>Three PostgreSQL index shapes that end three recurring full scans: partial for the hot subset, INCLUDE for index-only scans, expression for lower(email).</description><pubDate>Mon, 21 Sep 2026 00:00:00 GMT</pubDate><category>Databases &amp; EF Core</category><author>The Katabench team</author></item><item><title>Saga pattern in .NET: compensating transactions, not 2PC</title><link>https://katabench.com/blog/saga-pattern-compensating-transactions-dotnet</link><guid isPermaLink="true">https://katabench.com/blog/saga-pattern-compensating-transactions-dotnet</guid><description>Split checkout across services and rollback stops existing. Build a .NET saga: persisted orchestrator steps, compensations, a pivot, and idempotent retries.</description><pubDate>Mon, 21 Sep 2026 00:00:00 GMT</pubDate><category>Architecture &amp; Design</category><author>The Katabench team</author></item><item><title>SQL window functions: running totals, ranks, top-N</title><link>https://katabench.com/blog/sql-window-functions</link><guid isPermaLink="true">https://katabench.com/blog/sql-window-functions</guid><description>Window functions compute across related rows without collapsing them: OVER anatomy, ranking ties, the running-total frame trap, top-N per group, and LAG.</description><pubDate>Mon, 21 Sep 2026 00:00:00 GMT</pubDate><category>Databases &amp; EF Core</category><author>The Katabench team</author></item><item><title>System.Threading.Channels: bounded pipelines in .NET</title><link>https://katabench.com/blog/system-threading-channels-dotnet</link><guid isPermaLink="true">https://katabench.com/blog/system-threading-channels-dotnet</guid><description>System.Threading.Channels in .NET: why a bounded channel beats an unbounded queue, which BoundedChannelFullMode fits, and a consumer that drains safely.</description><pubDate>Mon, 21 Sep 2026 00:00:00 GMT</pubDate><category>.NET Performance</category><author>The Katabench team</author></item><item><title>Back-of-the-envelope capacity estimation for system design</title><link>https://katabench.com/blog/back-of-the-envelope-capacity-estimation</link><guid isPermaLink="true">https://katabench.com/blog/back-of-the-envelope-capacity-estimation</guid><description>Back of the envelope estimation for system design: turn daily active users into QPS, bandwidth, storage, and pool sizes, then find what saturates first.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>System Design</category><author>The Katabench team</author></item><item><title>BenchmarkDotNet: measuring C# performance without fooling yourself</title><link>https://katabench.com/blog/benchmarkdotnet-measure-csharp-performance</link><guid isPermaLink="true">https://katabench.com/blog/benchmarkdotnet-measure-csharp-performance</guid><description>BenchmarkDotNet measures C# performance without the lies a Stopwatch tells: tiered JIT, dead-code elimination, and GC noise, plus how to read the results table.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>.NET Performance</category><author>The Katabench team</author></item><item><title>CDN and edge caching: what belongs at the edge</title><link>https://katabench.com/blog/cdn-edge-caching</link><guid isPermaLink="true">https://katabench.com/blog/cdn-edge-caching</guid><description>CDN edge caching is HTTP caching at scale. Which Cache-Control directives matter, what never belongs at the edge, and how a 95% hit rate changes the origin.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>System Design</category><author>The Katabench team</author></item><item><title>Change data capture: keep a search index in sync without dual writes</title><link>https://katabench.com/blog/change-data-capture-search-index</link><guid isPermaLink="true">https://katabench.com/blog/change-data-capture-search-index</guid><description>Updating the database and the search index in one request is a dual write that drifts. Use change data capture or an outbox to derive the index instead.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>System Design</category><author>The Katabench team</author></item><item><title>Database replication and failover: what a standby promises</title><link>https://katabench.com/blog/database-replication-and-failover</link><guid isPermaLink="true">https://katabench.com/blog/database-replication-and-failover</guid><description>A replica is not a backup and a failover is not free. Database replication and failover explained: sync vs async commit, replication lag, safe promotion.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>System Design</category><author>The Katabench team</author></item><item><title>Database sharding vs partitioning: when one database is not enough</title><link>https://katabench.com/blog/database-sharding-vs-partitioning</link><guid isPermaLink="true">https://katabench.com/blog/database-sharding-vs-partitioning</guid><description>Database sharding vs partitioning: one splits a table inside a database, the other splits data across them. What each gives up and how to pick a shard key.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>System Design</category><author>The Katabench team</author></item><item><title>Transaction isolation levels: the anomalies each level allows</title><link>https://katabench.com/blog/database-transaction-isolation-levels</link><guid isPermaLink="true">https://katabench.com/blog/database-transaction-isolation-levels</guid><description>Database transaction isolation levels are a menu of anomalies you tolerate, not a safety dial. Watch write skew commit, then add the retry Serializable needs.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>Databases &amp; EF Core</category><author>The Katabench team</author></item><item><title>Design a notification system: fan-out, retries, and consent</title><link>https://katabench.com/blog/design-a-notification-system</link><guid isPermaLink="true">https://katabench.com/blog/design-a-notification-system</guid><description>Design a notification system that fans one event out to email, push, and SMS without double-sending, blocking on a dead provider, or messaging opted-out users.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>System Design</category><author>The Katabench team</author></item><item><title>Design a URL shortener: from one API to a billion redirects</title><link>https://katabench.com/blog/design-a-url-shortener</link><guid isPermaLink="true">https://katabench.com/blog/design-a-url-shortener</guid><description>Design a URL shortener with real numbers: 40 writes and 4,000 redirects a second, base62 keys, a cache-aside redirect path, and the 301 vs 302 analytics trade.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>System Design</category><author>The Katabench team</author></item><item><title>EF Core bulk updates with ExecuteUpdate and ExecuteDelete</title><link>https://katabench.com/blog/ef-core-bulk-updates-executeupdate</link><guid isPermaLink="true">https://katabench.com/blog/ef-core-bulk-updates-executeupdate</guid><description>An EF Core bulk update that loads 50,000 entities to change one column pays per byte and per statement. ExecuteUpdate sends one statement and skips the tracker.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>Databases &amp; EF Core</category><author>The Katabench team</author></item><item><title>Fan-out on write vs fan-out on read: designing a social feed</title><link>https://katabench.com/blog/fan-out-on-write-vs-fan-out-on-read</link><guid isPermaLink="true">https://katabench.com/blog/fan-out-on-write-vs-fan-out-on-read</guid><description>Fan-out on write vs fan-out on read, with the arithmetic: why push wins for ordinary accounts, where a 10M-follower post explodes, and how a hybrid merges both.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>System Design</category><author>The Katabench team</author></item><item><title>How to practice system design without waiting for an interview</title><link>https://katabench.com/blog/how-to-practice-system-design</link><guid isPermaLink="true">https://katabench.com/blog/how-to-practice-system-design</guid><description>How to practice system design deliberately: a weekly protocol that picks one pressure, draws the smallest design, breaks it, and compares against a reference.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>Engineering Practice</category><author>The Katabench team</author></item><item><title>Insecure deserialization in .NET: why BinaryFormatter died</title><link>https://katabench.com/blog/insecure-deserialization-dotnet</link><guid isPermaLink="true">https://katabench.com/blog/insecure-deserialization-dotnet</guid><description>Insecure deserialization in .NET turns untrusted input into code execution. Why BinaryFormatter was removed, and the Newtonsoft.Json and XmlSerializer traps.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>Security &amp; Reliability</category><author>The Katabench team</author></item><item><title>Integration testing in .NET with Testcontainers and WebApplicationFactory</title><link>https://katabench.com/blog/integration-testing-testcontainers-dotnet</link><guid isPermaLink="true">https://katabench.com/blog/integration-testing-testcontainers-dotnet</guid><description>Integration testing in .NET with Testcontainers and WebApplicationFactory runs your API against real PostgreSQL, so constraints and query counts get tested.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>Testing &amp; Refactoring</category><author>The Katabench team</author></item><item><title>Load balancing algorithms: round robin to consistent hashing</title><link>https://katabench.com/blog/load-balancing-algorithms</link><guid isPermaLink="true">https://katabench.com/blog/load-balancing-algorithms</guid><description>Load balancing algorithms are bets about your fleet. Round robin assumes equal servers, least connections dodges slow ones, consistent hashing keeps keys put.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>System Design</category><author>The Katabench team</author></item><item><title>Queue-based load leveling: absorb write spikes without losing work</title><link>https://katabench.com/blog/queue-based-load-leveling</link><guid isPermaLink="true">https://katabench.com/blog/queue-based-load-leveling</guid><description>Queue-based load leveling puts a durable queue between a write spike and the workers that drain it. Do the backlog arithmetic and watch the metric that matters.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>System Design</category><author>The Katabench team</author></item><item><title>SSRF in ASP.NET Core: your server as the attacker&apos;s browser</title><link>https://katabench.com/blog/ssrf-aspnet-core</link><guid isPermaLink="true">https://katabench.com/blog/ssrf-aspnet-core</guid><description>Server-side request forgery (SSRF) in ASP.NET Core makes your server the attacker&apos;s browser. Why naive URL checks fail and how to pin the connected address.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>Security &amp; Reliability</category><author>The Katabench team</author></item><item><title>System design fundamentals: nine building blocks</title><link>https://katabench.com/blog/system-design-fundamentals</link><guid isPermaLink="true">https://katabench.com/blog/system-design-fundamentals</guid><description>System design fundamentals as nine building blocks: name the pressure, apply the pattern, count what it costs, and learn the failure mode each block introduces.</description><pubDate>Tue, 08 Sep 2026 00:00:00 GMT</pubDate><category>System Design</category><author>The Katabench team</author></item><item><title>Aspire Service Discovery: Names, Ports, Replicas</title><link>https://katabench.com/blog/aspire-service-discovery</link><guid isPermaLink="true">https://katabench.com/blog/aspire-service-discovery</guid><description>Learn how Aspire service discovery turns logical names into endpoints with WithReference, HttpClient resolution, health checks, and replica load balancing.</description><pubDate>Sun, 09 Aug 2026 00:00:00 GMT</pubDate><category>Architecture &amp; Design</category><author>The Katabench team</author></item><item><title>Circuit Breaker Pattern in .NET with Polly</title><link>https://katabench.com/blog/circuit-breaker-pattern-dotnet</link><guid isPermaLink="true">https://katabench.com/blog/circuit-breaker-pattern-dotnet</guid><description>Build a circuit breaker in modern .NET with Polly and HttpClient resilience. Tune the failure window, compose retries safely, and prove recovery.</description><pubDate>Sun, 09 Aug 2026 00:00:00 GMT</pubDate><category>Architecture &amp; Design</category><author>The Katabench team</author></item><item><title>Message Queue vs Event Bus: Choose the Topology</title><link>https://katabench.com/blog/message-queue-vs-event-bus</link><guid isPermaLink="true">https://katabench.com/blog/message-queue-vs-event-bus</guid><description>Compare message queues, event buses, and pub/sub by delivery topology. Choose competing workers or fan-out, then design retries and ordering honestly.</description><pubDate>Sun, 09 Aug 2026 00:00:00 GMT</pubDate><category>Architecture &amp; Design</category><author>The Katabench team</author></item><item><title>Mutation Testing in C# with Stryker.NET</title><link>https://katabench.com/blog/mutation-testing-csharp</link><guid isPermaLink="true">https://katabench.com/blog/mutation-testing-csharp</guid><description>Mutation testing in C# plants controlled bugs and asks whether your tests notice. Learn Stryker.NET, triage survivors, and set useful CI gates.</description><pubDate>Sun, 09 Aug 2026 00:00:00 GMT</pubDate><category>Testing &amp; Refactoring</category><author>The Katabench team</author></item><item><title>Path Traversal Vulnerability in ASP.NET Core</title><link>https://katabench.com/blog/path-traversal-aspnet-core</link><guid isPermaLink="true">https://katabench.com/blog/path-traversal-aspnet-core</guid><description>A path traversal vulnerability lets user input escape a trusted directory. See the unsafe C# patterns, the containment check, and tests that prove it.</description><pubDate>Sun, 09 Aug 2026 00:00:00 GMT</pubDate><category>Security &amp; Reliability</category><author>The Katabench team</author></item><item><title>C# String Concatenation Performance, Measured</title><link>https://katabench.com/blog/string-concatenation-performance-csharp</link><guid isPermaLink="true">https://katabench.com/blog/string-concatenation-performance-csharp</guid><description>Choose between +, interpolation, StringBuilder, and direct writes in modern C#. Fix repeated copying, then verify the result with allocation benchmarks.</description><pubDate>Sun, 09 Aug 2026 00:00:00 GMT</pubDate><category>.NET Performance</category><author>The Katabench team</author></item><item><title>Structured Logging in .NET: Write Logs You Can Query</title><link>https://katabench.com/blog/structured-logging-dotnet</link><guid isPermaLink="true">https://katabench.com/blog/structured-logging-dotnet</guid><description>Learn structured logging in .NET with ILogger message templates, named fields, scopes, correlation IDs, safe data handling, and query-first design.</description><pubDate>Sun, 09 Aug 2026 00:00:00 GMT</pubDate><category>Architecture &amp; Design</category><author>The Katabench team</author></item><item><title>CancellationToken in ASP.NET Core: stop doing work nobody wants</title><link>https://katabench.com/blog/cancellation-token-aspnet-core</link><guid isPermaLink="true">https://katabench.com/blog/cancellation-token-aspnet-core</guid><description>A disconnected client does not cancel your database query by itself. How RequestAborted flows through ASP.NET Core, EF Core, and HttpClient, and where it stops.</description><pubDate>Sun, 02 Aug 2026 00:00:00 GMT</pubDate><category>.NET Performance</category><author>The Katabench team</author></item><item><title>Transactional outbox pattern in .NET: publish without losing messages</title><link>https://katabench.com/blog/transactional-outbox-dotnet</link><guid isPermaLink="true">https://katabench.com/blog/transactional-outbox-dotnet</guid><description>Saving data and publishing an event are two writes that can disagree. Build a transactional outbox with EF Core, a retrying publisher, and idempotent consumers.</description><pubDate>Thu, 30 Jul 2026 00:00:00 GMT</pubDate><category>Architecture &amp; Design</category><author>The Katabench team</author></item><item><title>Optimistic concurrency in EF Core: stop silent overwrites</title><link>https://katabench.com/blog/optimistic-concurrency-ef-core</link><guid isPermaLink="true">https://katabench.com/blog/optimistic-concurrency-ef-core</guid><description>Two users edit the same row and the last save silently wins. Use EF Core concurrency tokens, handle DbUpdateConcurrencyException, and test the race properly.</description><pubDate>Mon, 27 Jul 2026 00:00:00 GMT</pubDate><category>Databases &amp; EF Core</category><author>The Katabench team</author></item><item><title>AddSingleton vs AddScoped vs AddTransient: what each promises</title><link>https://katabench.com/blog/addsingleton-vs-addscoped-vs-addtransient</link><guid isPermaLink="true">https://katabench.com/blog/addsingleton-vs-addscoped-vs-addtransient</guid><description>AddSingleton vs AddScoped vs AddTransient in plain terms: what each lifetime promises, sensible defaults, and the captive dependency bug that ships.</description><pubDate>Thu, 16 Jul 2026 00:00:00 GMT</pubDate><category>Architecture &amp; Design</category><author>The Katabench team</author></item><item><title>C# async await mistakes that pass code review</title><link>https://katabench.com/blog/async-await-mistakes-csharp</link><guid isPermaLink="true">https://katabench.com/blog/async-await-mistakes-csharp</guid><description>The C# async await mistakes that pass code review: async void, fire and forget tasks, missing CancellationToken plumbing, and blocking on .Result.</description><pubDate>Thu, 16 Jul 2026 00:00:00 GMT</pubDate><category>.NET Performance</category><author>The Katabench team</author></item><item><title>Caching strategies: cache-aside, invalidation, and stampedes</title><link>https://katabench.com/blog/caching-strategies</link><guid isPermaLink="true">https://katabench.com/blog/caching-strategies</guid><description>Caching strategies from the cache-aside flow to the hard parts: invalidation owned by a human and stampedes tamed by single-flight and jitter.</description><pubDate>Thu, 16 Jul 2026 00:00:00 GMT</pubDate><category>Architecture &amp; Design</category><author>The Katabench team</author></item><item><title>Code smells: a working catalog of six, with C# examples</title><link>https://katabench.com/blog/code-smells-csharp</link><guid isPermaLink="true">https://katabench.com/blog/code-smells-csharp</guid><description>Code smells are symptoms, not verdicts. Six worth knowing, with C# examples: the tell for each, why it hurts, and the refactoring move that clears it.</description><pubDate>Thu, 16 Jul 2026 00:00:00 GMT</pubDate><category>Testing &amp; Refactoring</category><author>The Katabench team</author></item><item><title>Connection pooling: why your app ran out of connections</title><link>https://katabench.com/blog/connection-pooling</link><guid isPermaLink="true">https://katabench.com/blog/connection-pooling</guid><description>Connection pooling explained from the failure end: what a connection costs, the three ways pools drain, and why the timeout blames the wrong request.</description><pubDate>Thu, 16 Jul 2026 00:00:00 GMT</pubDate><category>Databases &amp; EF Core</category><author>The Katabench team</author></item><item><title>Cyclomatic complexity: what the number actually tells you</title><link>https://katabench.com/blog/cyclomatic-complexity</link><guid isPermaLink="true">https://katabench.com/blog/cyclomatic-complexity</guid><description>Cyclomatic complexity counts the independent paths through a method. How to compute it by eye, what a score of 10 predicts, and how to reduce it for real.</description><pubDate>Thu, 16 Jul 2026 00:00:00 GMT</pubDate><category>Testing &amp; Refactoring</category><author>The Katabench team</author></item><item><title>.NET garbage collection explained: what gen 0, 1, and 2 cost</title><link>https://katabench.com/blog/dotnet-garbage-collection-explained</link><guid isPermaLink="true">https://katabench.com/blog/dotnet-garbage-collection-explained</guid><description>.NET garbage collection explained: why most objects die young, what gen 0, 1, and 2 collections cost, and why the large object heap hurts latency.</description><pubDate>Thu, 16 Jul 2026 00:00:00 GMT</pubDate><category>.NET Performance</category><author>The Katabench team</author></item><item><title>How do database indexes work? B-trees, page by page</title><link>https://katabench.com/blog/how-database-indexes-work</link><guid isPermaLink="true">https://katabench.com/blog/how-database-indexes-work</guid><description>How do database indexes work? A B-tree is a small sorted structure with huge fanout, so a lookup reads a handful of pages instead of the whole table.</description><pubDate>Thu, 16 Jul 2026 00:00:00 GMT</pubDate><category>Databases &amp; EF Core</category><author>The Katabench team</author></item><item><title>Idempotency in API design: surviving the retry you didn&apos;t send</title><link>https://katabench.com/blog/idempotency-api-design</link><guid isPermaLink="true">https://katabench.com/blog/idempotency-api-design</guid><description>Every serious client retries. How the idempotency key pattern and a database unique constraint keep a retried payment from becoming two charges.</description><pubDate>Thu, 16 Jul 2026 00:00:00 GMT</pubDate><category>Security &amp; Reliability</category><author>The Katabench team</author></item><item><title>Rate limiting algorithms: how token buckets forgive bursts</title><link>https://katabench.com/blog/rate-limiting-algorithms</link><guid isPermaLink="true">https://katabench.com/blog/rate-limiting-algorithms</guid><description>Rate limiting algorithms compared: why fixed windows leak double the limit, how token buckets forgive bursts, and what a good 429 response returns.</description><pubDate>Thu, 16 Jul 2026 00:00:00 GMT</pubDate><category>Security &amp; Reliability</category><author>The Katabench team</author></item><item><title>Unit testing best practices: test behavior, not implementation</title><link>https://katabench.com/blog/unit-testing-best-practices</link><guid isPermaLink="true">https://katabench.com/blog/unit-testing-best-practices</guid><description>Unit testing best practices that survive refactoring: AAA structure, behavior-first assertions, a healthy test pyramid, and determinism over flakiness.</description><pubDate>Thu, 16 Jul 2026 00:00:00 GMT</pubDate><category>Testing &amp; Refactoring</category><author>The Katabench team</author></item><item><title>Primitive obsession: the bug the compiler was begging to catch</title><link>https://katabench.com/blog/primitive-obsession-value-objects</link><guid isPermaLink="true">https://katabench.com/blog/primitive-obsession-value-objects</guid><description>When everything is a string, a decimal, or a Guid, the type system cannot tell arguments apart. Value objects in modern C#, the bugs they delete, their limits.</description><pubDate>Sun, 12 Jul 2026 00:00:00 GMT</pubDate><category>Testing &amp; Refactoring</category><author>The Katabench team</author></item><item><title>Sync over Async: Diagnose .NET Thread Pool Starvation</title><link>https://katabench.com/blog/sync-over-async</link><guid isPermaLink="true">https://katabench.com/blog/sync-over-async</guid><description>Learn how sync over async causes .NET Thread Pool starvation, spot it with dotnet-counters, capture blocking stacks, and fix ASP.NET Core latency.</description><pubDate>Sat, 11 Jul 2026 00:00:00 GMT</pubDate><category>.NET Performance</category><author>The Katabench team</author></item><item><title>Skip and Take will betray you: offset vs keyset pagination</title><link>https://katabench.com/blog/offset-vs-keyset-pagination</link><guid isPermaLink="true">https://katabench.com/blog/offset-vs-keyset-pagination</guid><description>OFFSET pagination reads every row it skips, so page 2,000 costs 2,000 pages of work. Keyset pagination seeks straight to the next page. SQL and EF Core shown.</description><pubDate>Fri, 10 Jul 2026 00:00:00 GMT</pubDate><category>Databases &amp; EF Core</category><author>The Katabench team</author></item><item><title>The LINQ query that ran twice: multiple enumeration and other deferred-execution traps</title><link>https://katabench.com/blog/multiple-enumeration-linq</link><guid isPermaLink="true">https://katabench.com/blog/multiple-enumeration-linq</guid><description>An IEnumerable isn&apos;t a list; it&apos;s a promise to do work later. Enumerate it twice and the work happens twice, including, with EF Core, the database query.</description><pubDate>Thu, 09 Jul 2026 00:00:00 GMT</pubDate><category>.NET Performance</category><author>The Katabench team</author></item><item><title>ReDoS: the innocent regex that can take down your API</title><link>https://katabench.com/blog/redos-catastrophic-backtracking</link><guid isPermaLink="true">https://katabench.com/blog/redos-catastrophic-backtracking</guid><description>Catastrophic backtracking turns an email regex into a denial of service: 30 characters, almost a minute of CPU. Why nested quantifiers explode and the .NET fix.</description><pubDate>Wed, 08 Jul 2026 00:00:00 GMT</pubDate><category>Security &amp; Reliability</category><author>The Katabench team</author></item><item><title>Tutorial hell: why you can finish every course and still freeze at a blank file</title><link>https://katabench.com/blog/tutorial-hell</link><guid isPermaLink="true">https://katabench.com/blog/tutorial-hell</guid><description>Watching code get written trains recognition, not recall. Why tutorials feel like progress, why the skill doesn&apos;t transfer, and how to build a loop that does.</description><pubDate>Tue, 07 Jul 2026 00:00:00 GMT</pubDate><category>Engineering Practice</category><author>The Katabench team</author></item><item><title>Coding interviews are broken, but the skills they fumble are real</title><link>https://katabench.com/blog/coding-interviews-vs-real-skill</link><guid isPermaLink="true">https://katabench.com/blog/coding-interviews-vs-real-skill</guid><description>Whiteboard interviews measure the wrong slice of engineering. Practice what predicts a good engineer instead: correct, fast, well-structured, secure code.</description><pubDate>Thu, 25 Jun 2026 00:00:00 GMT</pubDate><category>Engineering Practice</category><author>The Katabench team</author></item><item><title>The OWASP Top 10 through a C# lens</title><link>https://katabench.com/blog/owasp-top-10-csharp</link><guid isPermaLink="true">https://katabench.com/blog/owasp-top-10-csharp</guid><description>A practical tour of the OWASP Top 10 for .NET developers: the ASP.NET Core and EF Core patterns behind broken access control, injection, SSRF, and overposting.</description><pubDate>Wed, 24 Jun 2026 00:00:00 GMT</pubDate><category>Security &amp; Reliability</category><author>The Katabench team</author></item><item><title>SQL injection is still alive, and it&apos;s hiding in your C#</title><link>https://katabench.com/blog/sql-injection-still-alive</link><guid isPermaLink="true">https://katabench.com/blog/sql-injection-still-alive</guid><description>SQL injection is supposedly solved, yet it&apos;s still in the OWASP Top 10. The C# patterns that keep it alive in EF Core and ADO.NET, and how to kill them.</description><pubDate>Mon, 22 Jun 2026 00:00:00 GMT</pubDate><category>Security &amp; Reliability</category><author>The Katabench team</author></item><item><title>Architecture fitness functions: tests that fail the build when your layers rot</title><link>https://katabench.com/blog/architecture-fitness-functions</link><guid isPermaLink="true">https://katabench.com/blog/architecture-fitness-functions</guid><description>Architecture decays because nothing fails the build when the domain references the DbContext. ArchUnitNET fitness functions assert layering rules in CI.</description><pubDate>Sat, 20 Jun 2026 00:00:00 GMT</pubDate><category>Architecture &amp; Design</category><author>The Katabench team</author></item><item><title>Hexagonal architecture in .NET without the dogma</title><link>https://katabench.com/blog/hexagonal-architecture-dotnet</link><guid isPermaLink="true">https://katabench.com/blog/hexagonal-architecture-dotnet</guid><description>Ports and adapters in plain C#: domain in the center, ports as interfaces, adapters as infrastructure. Why it beats layered spaghetti, and when it is overkill.</description><pubDate>Thu, 18 Jun 2026 00:00:00 GMT</pubDate><category>Architecture &amp; Design</category><author>The Katabench team</author></item><item><title>Dependency inversion in C# is not about your DI container</title><link>https://katabench.com/blog/dependency-inversion-csharp</link><guid isPermaLink="true">https://katabench.com/blog/dependency-inversion-csharp</guid><description>The D in SOLID is the most quoted and least applied principle. Dependency inversion means owning your abstractions and pointing dependencies inward.</description><pubDate>Tue, 16 Jun 2026 00:00:00 GMT</pubDate><category>Architecture &amp; Design</category><author>The Katabench team</author></item><item><title>A test-first playbook for refactoring legacy C# safely</title><link>https://katabench.com/blog/refactoring-legacy-csharp</link><guid isPermaLink="true">https://katabench.com/blog/refactoring-legacy-csharp</guid><description>How to refactor legacy C# without breaking it: write characterization tests first, then take small behavior-preserving steps like extract method and seams.</description><pubDate>Sat, 13 Jun 2026 00:00:00 GMT</pubDate><category>Testing &amp; Refactoring</category><author>The Katabench team</author></item><item><title>Green checkmarks are incomplete: grading C# beyond correctness</title><link>https://katabench.com/blog/green-checkmarks-lie</link><guid isPermaLink="true">https://katabench.com/blog/green-checkmarks-lie</guid><description>A green check proves output without proving the solution scales. How performance, allocation, query, and structure gates turn a pass into actionable feedback.</description><pubDate>Wed, 10 Jun 2026 00:00:00 GMT</pubDate><category>Engineering Practice</category><author>The Katabench team</author></item><item><title>Clean code is a vibe until you measure it</title><link>https://katabench.com/blog/measuring-code-quality</link><guid isPermaLink="true">https://katabench.com/blog/measuring-code-quality</guid><description>Four code quality metrics you can automate in C#: cyclomatic complexity, nesting depth, method length, and duplication, with thresholds and a passing refactor.</description><pubDate>Mon, 08 Jun 2026 00:00:00 GMT</pubDate><category>Testing &amp; Refactoring</category><author>The Katabench team</author></item><item><title>EF Core habits that quietly wreck performance</title><link>https://katabench.com/blog/ef-core-performance-habits</link><guid isPermaLink="true">https://katabench.com/blog/ef-core-performance-habits</guid><description>Nine EF Core habits that pass every test and quietly tank production performance: missing AsNoTracking, whole-entity fetches, N+1, cartesian explosion, more.</description><pubDate>Tue, 02 Jun 2026 00:00:00 GMT</pubDate><category>Databases &amp; EF Core</category><author>The Katabench team</author></item><item><title>Your LINQ is fast; your query plan isn&apos;t</title><link>https://katabench.com/blog/ef-core-query-plans-indexes</link><guid isPermaLink="true">https://katabench.com/blog/ef-core-query-plans-indexes</guid><description>A well-written EF Core query can still do a sequential scan: no index, or a function on a column makes it non-sargable. How to read a query plan and fix it.</description><pubDate>Tue, 26 May 2026 00:00:00 GMT</pubDate><category>Databases &amp; EF Core</category><author>The Katabench team</author></item><item><title>IQueryable vs IEnumerable: the one return type that decides where your query runs</title><link>https://katabench.com/blog/iqueryable-vs-ienumerable</link><guid isPermaLink="true">https://katabench.com/blog/iqueryable-vs-ienumerable</guid><description>Returning IEnumerable, or calling ToList too early, moves filtering and paging into memory. One type change turns an indexed WHERE into loading a million rows.</description><pubDate>Tue, 19 May 2026 00:00:00 GMT</pubDate><category>Databases &amp; EF Core</category><author>The Katabench team</author></item><item><title>The N+1 query problem in EF Core: the most expensive habit in .NET</title><link>https://katabench.com/blog/ef-core-n-plus-1</link><guid isPermaLink="true">https://katabench.com/blog/ef-core-n-plus-1</guid><description>An EF Core loop that looks innocent fires one query per row. It passes every unit test and dies in production. How N+1 happens, the SQL it generates, the fix.</description><pubDate>Tue, 12 May 2026 00:00:00 GMT</pubDate><category>Databases &amp; EF Core</category><author>The Katabench team</author></item><item><title>Deliberate practice for programmers: why a green check isn&apos;t feedback</title><link>https://katabench.com/blog/deliberate-practice-programmers</link><guid isPermaLink="true">https://katabench.com/blog/deliberate-practice-programmers</guid><description>Repetition doesn&apos;t make you better; deliberate practice does. It needs immediate, specific feedback at the edge of your ability, which most practice lacks.</description><pubDate>Tue, 05 May 2026 00:00:00 GMT</pubDate><category>Engineering Practice</category><author>The Katabench team</author></item><item><title>How senior .NET engineers actually keep their edge</title><link>https://katabench.com/blog/how-seniors-practice</link><guid isPermaLink="true">https://katabench.com/blog/how-seniors-practice</guid><description>It isn&apos;t grinding more LeetCode for correctness. Seniors practice what production grades: performance, data-access shape, design, and security.</description><pubDate>Tue, 28 Apr 2026 00:00:00 GMT</pubDate><category>Engineering Practice</category><author>The Katabench team</author></item><item><title>The premature optimization myth: what Knuth actually said</title><link>https://katabench.com/blog/premature-optimization-myth</link><guid isPermaLink="true">https://katabench.com/blog/premature-optimization-myth</guid><description>The most-abused quote in software lets developers dodge performance entirely. Knuth&apos;s real argument, and why finding the critical 3% takes a trained instinct.</description><pubDate>Tue, 21 Apr 2026 00:00:00 GMT</pubDate><category>.NET Performance</category><author>The Katabench team</author></item><item><title>Span&lt;T&gt;, Memory&lt;T&gt;, and stackalloc: when zero-allocation C# is worth it</title><link>https://katabench.com/blog/span-memory-zero-allocation</link><guid isPermaLink="true">https://katabench.com/blog/span-memory-zero-allocation</guid><description>Span&lt;T&gt; and stackalloc let you parse and slice without allocating, but they have real limits. When zero-allocation C# earns its keep and when it&apos;s overkill.</description><pubDate>Thu, 09 Apr 2026 00:00:00 GMT</pubDate><category>.NET Performance</category><author>The Katabench team</author></item><item><title>The allocation tax: why correct, O(n) C# can still be slow</title><link>https://katabench.com/blog/dotnet-allocations</link><guid isPermaLink="true">https://katabench.com/blog/dotnet-allocations</guid><description>Correct, algorithmically optimal .NET code can still drag, because every needless allocation feeds the GC. How to spot and cut allocation pressure in C#.</description><pubDate>Tue, 31 Mar 2026 00:00:00 GMT</pubDate><category>.NET Performance</category><author>The Katabench team</author></item><item><title>Big-O isn&apos;t interview trivia: where complexity actually bites in production</title><link>https://katabench.com/blog/big-o-in-production</link><guid isPermaLink="true">https://katabench.com/blog/big-o-in-production</guid><description>Big-O gets crammed for interviews and forgotten, but quadratic C# passes your tests and melts in prod. Where complexity bites and how to make it an instinct.</description><pubDate>Wed, 18 Mar 2026 00:00:00 GMT</pubDate><category>.NET Performance</category><author>The Katabench team</author></item></channel></rss>