.NET & ASP.NET Core

Plan for v2 on day one — implement it only when needed.

Tests that are fast, readable and worth keeping.

Test the real HTTP pipeline in memory.

Stop mocking your database. Run the real one in Docker.

Readable test doubles with minimal ceremony.

Stop guessing. Measure performance properly.

Slice data without allocating new arrays or strings.

GC pauses are latency spikes. Allocate less.

String concatenation in loops still hurts.

The data structure decision behind most performance wins.

LINQ is great until it runs a query 500 times.

Live dashboards and notifications in .NET.

Two instances means two separate sets of connections.

Fast, typed service-to-service calls.

Lessons from Stripe and payment gateway integrations.

Upload 2 GB files without exhausting memory.

Offset is easy. Keyset scales.

Patterns from building multi-tenant SaaS in .NET.

Ship code dark, release it when ready.

What I learned integrating Stripe, Razorpay and local gateways.

Make POST requests safe to retry.

Stop losing events between your database and your broker.

A message bus abstraction that saves weeks of plumbing.

Producing and consuming with the Confluent client.

A small, secure image in a multi-stage Dockerfile.

The self-hosted setup I use for many production apps.

Millisecond startup and tiny memory for the right workloads.

Orchestrate APIs, databases and queues with C# instead of YAML.

Secrets never belong in appsettings.json.

Small middleware, big protection.

CORS is a browser feature, not API security.

Protect sensitive data at rest and in transit.

FromSql is safe. String concatenation is not.

Compile-time code generation that replaces reflection.

Let the compiler find your NullReferenceExceptions.

Replace nested if/else with readable expressions.

Less boilerplate for classes that only receive dependencies.

Small language upgrades that clean up real codebases.

Powerful for readability — dangerous for discoverability.

Write reusable code without losing type safety.

What I check in every .NET code review as a tech lead.

From a 900-line controller to clean, testable slices.

Patterns I remove in almost every legacy codebase.

The architecture I recommend before microservices.

Make your architecture rules executable.

A pragmatic path from legacy to modern .NET.

LTS every two years, STS in between — keep moving.

Everything I set up before writing the first feature.

What I tell every junior developer I mentor.

Wrapping up the series — and what comes next.