Technical Blog

0
1191
Should You Let an Agent Modernize Your Legacy .NET?
4 Min Read
A checklist before pointing GitHub Copilot's modernization agent at a legacy codebase: test coverage as a prerequisite, review capacity as the real constraint, and what to keep humans in front of.

0
1898
Your CI Is Slow and the Logs Won't Tell You Why
4 Min Read
Pipeline duration is an observability problem, not a performance problem. Why CI runs deserve traces rather than transcripts, what usually turns up, and why flakiness costs more than slowness.

0
585
Putting an LLM in the Clinical Loop: ICD-10 Coding to Production
5 Min Read
Taking LLM-assisted ICD-10 coding from benchmarking to production — evaluation on real clinical data, guardrails, human-in-the-loop design, and honest notes on GPU capacity planning.

0
644
Testcontainers and Argo Rollouts: Progressive Delivery When a Bad Deploy Costs You
4 Min Read
Why integration tests against real PostgreSQL containers and metric-gated canary rollouts solve different halves of the same problem — and why you should adopt them in that order.

0
582
Twenty Engineers, Three Clouds: What Changed When I Stopped Writing Most of the Code
5 Min Read
Eighteen months into an engineering manager role: the leverage shift, hiring leads, why multi-cloud is an organisational problem, and the two metrics I actually watch.

0
1055
Service Templates Are Governance, Not Scaffolding
4 Min Read
A service template is how an engineering org makes its standards the default instead of the aspiration — and why drift, not creation, is the problem that kills most of them.

0
1373
SSE, WebSockets, or Just Polling? Picking a Push Channel
4 Min Read
A decision framework for real-time updates in .NET: why server-to-client problems usually want Server-Sent Events, what bites you at scale, and an honest defence of polling.

0
895
What Happens Before Your Code Runs
4 Min Read
dotnet run is restore, build, and a runtime bootstrap wearing a trench coat. Why startup time became a scaling property, where it actually goes, and what genuinely helps.

0
927
Compiler Errors That Don't Mean What They Say
4 Min Read
The RequestDelegate error in Minimal APIs as a case study in diagnostics: why overload resolution reports against the wrong overload, how to narrow it in ninety seconds, and the general technique.

0
87
Postgres Under Load: CPU Saturation, Write Amplification, and Plan Regressions
5 Min Read
Three production PostgreSQL incidents after a large migration, and what each one teaches about indexing strategy, HOT updates, fillfactor, and why query plans change without a deploy.

0
426
Two Analyzers, One Codebase: Choosing Static Analysis for a C# Team
4 Min Read
Editor tooling doesn't set your standard — the repository does. On enforcing analyzers in CI, keeping a noise budget, separating style from quality, and why this matters more in AI-first editors.

0
1932
Git Workflow Is a Team Decision, Not a Tool Feature
4 Min Read
Better Git tooling won't give you short-lived branches or reviewable pull requests. On why branch lifetime is the only branching question that matters, and why large PRs are effectively unreviewed.

0
829
When a Core Dependency Changes Its License
4 Min Read
AutoMapper and MediatR going commercial is a useful case study in dependency risk: separate cost from coupling, do the usage inventory, then choose among paying, pinning, replacing, or removing the need.

0
591
What AI Code Review Catches, and What It Doesn't
4 Min Read
A year of AI-assisted code review: the mechanical defects it reliably finds, the domain correctness it structurally can't, and the real risk — what automated comments do to reviewer attention.

0
816
Source Generators Are Not Free
4 Min Read
A source generator is a build-time dependency, and build time is a shared resource. What generators actually cost, the packaging trap, the debugging question, and when they're clearly worth it.

0
1013
Ten Years In: What AI Changed About Writing Software
4 Min Read
An honest account of what got faster, what didn't, and the new failure mode worth watching — confidence outrunning understanding, in a domain where 'looked right' isn't a standard.

0
62
What NPHIES Certification Actually Takes: FHIR R4 in the Real World
5 Min Read
Lessons from taking a claims platform through NPHIES vendor certification — profile validation, identifier mapping, terminology, asynchronous messaging, and why the error paths carry the weight.

0
83
Zero Downtime, 50 Million Records: Migrating a Claims Platform from CosmosDB to PostgreSQL
5 Min Read
How we moved a live claims platform off Azure CosmosDB and Elasticsearch onto PostgreSQL as the single source of truth — 50M+ records at terabyte scale, with dual-writes, shadow reads, and 100% reconciliation.

0
561
What to Actually Measure in a .NET Service
4 Min Read
IMeterFactory is the easy part. Choosing metrics is the hard part: rate, errors, duration, saturation — plus the cardinality trap and why business throughput catches failures system metrics never will.

0
709
Serialization Is a Contract: Notes on System.Text.Json at Scale
4 Min Read
Your property names are public API. On separating wire types from domain types, deciding what unknown fields mean, explicit discriminators, and why nullable annotations lie at the boundary.

0
532
From Developer to Director: Leadership Lessons for Engineers
6 Min Read
Practical advice for software engineers transitioning to leadership roles, based on my journey from Senior Engineer to Technology Director.

0
478
AI in Healthcare: A Practitioner's Perspective on Implementation
5 Min Read
Real-world insights on implementing AI and ML in healthcare systems, from intelligent claims processing to clinical decision support.

0
462
Multi-Cloud Strategy: Navigating Azure, AWS, GCP, and Beyond
5 Min Read
A practical guide to multi-cloud architecture based on real experience deploying healthcare systems across Azure, AWS, G42 Cloud, Oracle Cloud, and GCP.

0
392
Why I Closed My Startup After 3 Years: Lessons in Entrepreneurship
5 Min Read
A candid reflection on founding Core System, the challenges of running a startup while working full-time, and why I made the difficult decision to close it.

0
320
Building Scalable Healthcare Systems: Lessons from the Trenches
5 Min Read
Practical insights on designing and scaling healthcare IT systems including EMRs, HIS, and claims management platforms.

0
291
From Help Desk to Technology Director: My 9-Year Journey in Tech
5 Min Read
A personal reflection on my career path from IT support to leading technology strategy at a healthcare company, and the lessons learned along the way.