Daily micro-tips for C#, SQL, performance, and scalable backend engineering.
⚙️ The API Call That Had a Perfectly Valid Body and Still Got Rejected ASP.NET Core’s model binding doesn’t inspect the body of a request to guess what format it’s in – it trusts the Content-Type header the client sent, and picks an input formatter based on that header alone. A request with a flawless, […]
🔧 The Task.WhenAll That Only Ever Told You About One Failure Task.WhenAll is built to run several tasks concurrently and complete once they’re all done, and if more than one of them faults, it faithfully stores every exception on the returned Task’s AggregateException. The trap is in how you usually read the result: awaiting that […]
🔄 The GET Request That Kept Answering From Yesterday A plain fetch() GET request is, by design, eligible for the browser’s standard HTTP cache the same way a static image or script would be, and if the server’s response included cache-friendly headers (or didn’t explicitly forbid caching), the browser is within its rights to serve […]
🧩 The File Picker That Remembered a File It Should Have Forgotten A change event on a file input only fires when its value is different from what it already was, and the browser considers selecting the exact same file from the exact same path as ‘no change’ – the input’s internal value never actually […]
🖌️ The Guides That Only Ever Existed on One Machine Guides placed manually in Photoshop are, by default, stored as part of that specific document’s saved state, which should mean they travel with the PSD file wherever it goes – but a surprising number of workflows strip them out along the way without anyone intending […]
⚡ The Object Property That Disappeared on the Way to JSON JSON has no representation for undefined, functions, or symbols – the format simply doesn’t define a way to encode them – so JSON.stringify doesn’t throw or warn when it encounters one, it just leaves the corresponding key out of the output entirely. A property […]
🤖 The Prompt That Turns ‘Great Team Player’ Into Something You Can Actually Defend A performance review written in a hurry tends to lean on vague, generically positive phrases – ‘strong communicator,’ ‘great attitude,’ ‘goes above and beyond’ – that feel supportive in the moment but fall apart the second someone asks for a concrete […]
☸️ The Pod That Was Technically Running and Never Actually Doing Anything Init containers are designed to run to completion, in order, before any of a pod’s main containers start – which is exactly the right model for setup work like waiting on a dependency or seeding a config file, but becomes a silent trap […]
🤖 The Prompt That Reads Your Async Code the Way a Deadlock Eventually Would Missing ConfigureAwait(false) calls in library code, and synchronous blocking on an async call with .Result or .Wait(), are two of the most common causes of hard-to-reproduce deadlocks in .NET – and both are easy for a human reviewer to skim right […]
⚙️ The Configuration Reload That Never Reached the Singleton IOptionsSnapshot exists specifically to give you a fresh configuration value on every scoped lifetime – typically once per request – which makes it the obvious choice when you want config changes to apply without restarting the app. The catch is that IOptionsSnapshot is itself registered as […]
📝 The robots.txt File That Search Engines Kept Reading From the Past WordPress generates a virtual robots.txt on the fly by default, assembling it from site settings each time it’s requested, which works fine until a full-page caching plugin or a server-level cache layer decides that response is cacheable and stores a copy of it […]
🎨 The Grid Column That Grew to Fit Content It Was Supposed to Contain A fr unit distributes available space among grid tracks, but it doesn’t override each track’s minimum size, and the default minimum width for a grid item is auto – which effectively means ‘at least as wide as my content needs to […]
🖌️ The Color Correction That Leaked Into Every Layer Underneath An adjustment layer, by default, affects every layer stacked beneath it in the document – that’s the whole point of using one instead of editing pixels directly, since it applies non-destructively to the combined result below. Clipping it to a single layer (so it only […]
🔧 The Emptiness Check That Walked the Whole List Anyway Count() and Any() both answer questions about a sequence, but they don’t cost the same thing. Any() asks a yes/no question and can stop at the very first element that satisfies it. Count() has to produce an exact number, which means walking every single element […]
🛠️ The Build Configuration That Kept Undoing Itself Visual Studio’s Solution Configuration dropdown is meant to be a simple, sticky choice – pick Release, and every subsequent build should use it until you change it again. In practice, several common actions quietly override that choice without any confirmation dialog: opening certain project types (especially ones […]
📝 The Child Theme Styles That the Parent Quietly Started Winning Against A child theme’s style.css is supposed to load after the parent theme’s, which is the entire mechanism that lets its rules override the parent’s defaults – but that ordering depends on the child theme correctly enqueuing the parent’s stylesheet as its own dependency […]
🤖 The Prompt That Counts Queries the Way Your Database Would An N+1 query bug happens when code loads a list of records with one query, then loops over that list making a separate query per item to fetch related data – a pattern that runs fine with five test rows and falls over with […]
🗄️ The Filtered Index That Was Never Actually Considered A filtered index narrows an index down to the rows that matter – active orders, non-null email addresses, a specific status – which keeps it small and fast for the queries that only ever care about that subset. The optimizer will only use it, though, when […]
🔀 The Files That Were Committed, Tracked, and Nowhere in Sight Sparse checkout lets a large repository check out only a subset of its directory tree into the working copy, which is genuinely useful on monorepos where nobody needs every folder on disk at once. The trouble is that a sparse-checkout pattern set up for […]
🐳 The Container That Never Heard a Word You Typed After the Image Name ENTRYPOINT and CMD are meant to work together – ENTRYPOINT defines the fixed program that always runs, and CMD supplies default arguments to it that anyone can override by appending their own at the end of docker run. That handoff only […]
🔀 The Commit That Vanished From an Interactive Rebase Without a Trace An interactive rebase lets you reorder, squash, reword, and drop commits by editing a simple todo list before Git replays them one by one – which is exactly what makes it easy to delete the wrong line, or change pick to drop on […]
🪟 The Microphone That Only Worked for Windows Itself Windows 11’s Sound settings page shows a live input meter that reacts to a microphone picking up audio at the driver level, which only confirms that the operating system itself is receiving a signal – it says nothing about whether the specific app you’re using has […]
🗄️ The Primary Key That Scattered Every New Row Across the Whole Table A clustered index physically orders the table’s data pages to match the key, which is cheap to maintain when new values always sort to the end – an IDENTITY column does exactly that, so every insert simply appends a new row to […]
🔧 The ThreadStatic Field That Forgot Everything After One Await A [ThreadStatic] field gives every thread its own private copy of a value, which makes it a tempting way to stash per-operation context like a correlation ID or a current user without threading a parameter through every method call. That guarantee is tied to the […]
🪟 The Boot Menu That a Windows Update Quietly Erased A dual-boot setup works by having the Windows Boot Manager present a menu that points at more than one operating system entry, and Windows considers that boot configuration entirely its own to manage. A cumulative update that touches the boot loader – which happens more […]
🔧 The Request Body That Bound to null Because It Was the Wrong Shape Minimal API model binding reads the request body and tries to deserialize it directly into whatever parameter type the endpoint declared. When a client sends a JSON object and the parameter is a record expecting one, this is seamless. When a […]
🔧 The Promise.race() Winner That Didn’t Actually Stop Anything Promise.race() settles as soon as the first of several promises settles, and returns that result – but it has no way to reach into the other promises and stop them, because a JavaScript Promise has no built-in cancellation mechanism at all. A promise that ‘loses’ the […]
🔧 The Default Interface Method That Only Worked Through One Door A default interface method was added specifically so an interface could grow a new member without breaking every class that already implements it – any class that doesn’t override the member simply falls back to the body written on the interface itself. What catches […]
🔧 The fetch() Call That Treated a 404 Page Like a Perfectly Good Response fetch()’s Promise only rejects for a genuine network-level failure – a dropped connection, a DNS failure, a request that never reached a server at all. An HTTP error status returned by a server that was reached successfully, whether that’s a 404, […]
🔧 The Pinned Overlay That Started Scrolling Away With Everything Else position: fixed is specified to position an element relative to the viewport – until an ancestor somewhere between it and the document root has a transform, a filter, or a few other specific properties applied, any one of which creates a new containing block […]