Stefan Đokić | .NET

➡️ Level Up with Everyday .NET Content | Microsoft MVP
➡️ YouTube: Newsletter | 20k+

[Stefan Đokić | .NET @TheCodeMan__]

This reality hits:

deadlines, new team members, rushed PRs, “we’ll fix it later.”

Most #dotnet projects don’t fall apart because of bad developers.

They fall apart because nobody decided how things should look when things get messy.

At the beginning:
✔ clean structure
✔ good intentions
✔ “we’ll keep it tidy”

Then reality hits:
• deadlines
• new team members
• rushed PRs
• “we’ll fix it later”

And suddenly the codebase starts fighting back.

This carousel shows the full curriculum of Pragmatic .NET Code Rules.

Not as a syllabus.
But as a system.

A system that:
- removes pointless decisions
- enforces consistency automatically
- keeps projects clean even when teams grow

I made this course for developers who:
• are tired of style debates
• want predictable projects
• care about long-term sanity, not quick wins

Already 50+ developers joined during pre-order.

And yes, you get access immediately.
And yes, you get access to the community.

You don’t wait.
You apply.

You improve your project while the course grows.

40% OFF Preorder price: $59.89
(Only 4 spots left at the price and only today)

Original price is $150.

👉 Get it now here:
https://t.co/xhEsynIezB

Curious, what’s the one rule your current codebase is missing?

[Stefan Đokić | .NET @TheCodeMan__]

@AntonMartyniuk The interesting tradeoff is that many teams reach for a new database before exhausting partitioning, compression, indexing, aggregation, and storage optimizations in their existing one.

[Stefan Đokić | .NET @TheCodeMan__]

I keep seeing the same thing with beginner .NET developers. They spend months “learning”…

But never stay on one path long enough to actually build something real.

One week: Clean Architecture
Next week: microservices

Then:

• Kubernetes
• event sourcing
• AI agents
• whatever YouTube recommends next

…and after 6 months, they still haven’t deployed a real application.

That’s why I made this roadmap.

Not another: “Here are 97 technologies you should learn in 2026” PDF.

I wanted something practical.

A roadmap that answers:

1. What to build first
2. What to ignore
3. What actually matters for junior jobs
4. When to move to more advanced topics

So the roadmap walks through building progressively:

→ first API
→ databases
→ authentication
→ Docker
→ CI/CD
→ background jobs
→ scaling
→ testing

Step by step.

Not theory collecting.
Actual progression.

And honestly, the most important part is probably what I left OUT.

Because beginners lose insane amounts of time learning infrastructure and architecture patterns they simply do not need yet.

Meanwhile, someone with fewer technologies but better direction usually becomes job-ready much faster.

The roadmap has already crossed 1,200+ downloads, so I figured I should share it here again.

Download it for free: https://t.co/JK6ol31Oed

Or comment: “roadmap” and I’ll send it over.
__

📌 Join the Newsletter and get "AI in .NET" Starter Kit projects for free: https://t.co/gI46R2Kc0c

♻️ Repost to others.
📂 You can save this post for later, and you should do it.

➕ Follow me to learn .NET and Architecture every day.

[Stefan Đokić | .NET @TheCodeMan__]

📌 Join the Newsletter and get "AI in .NET" Starter Kit projects for free: https://t.co/gOdESeHKN6

[Stefan Đokić | .NET @TheCodeMan__]

The worst bug isn't the one that crashes. It's the one where your method returns "Success", and three systems disagree about what just happened.

Classic version: customer gets charged, the payment provider has the money, but your SaveChanges() threw right after. The order rolls back to draft. The user gets a "Payment failed, please retry" email. One click, and every subsystem now tells a different story.

The trap is that a use case *looks* like a transaction. It sits behind one method call. But the moment it touches more than one system, DB + payment + email, you're dealing with partial failure, and there's no single "handle errors properly" rule that saves you.

What actually helps is classifying every side effect first:

→ Transactional (DB inserts/updates, in-process domain events) - commit these LAST, after the external work has succeeded.
→ External but reversible (charge → refund, reserve → release) - make it idempotent (an idempotency key so a retry is a no-op) or compensate via an event.
→ External and irreversible (emails, webhooks, SMS) - get them OUT of the use case entirely. Raise a domain event, let the Outbox dispatch it after commit. If the transaction never commits, the email never escapes the DB.

The one thing you never do: swallow the failure to make the method "look successful." The symptom leaves your logs, the money stays gone, and the retry double-charges.

The mental model that fixed this for me: a use case is a unit of *intent*, not a unit of *atomicity*. Most event-driven production bugs I've debugged come down to a method that lied about whether it actually succeeded.

I break down production #dotnet patterns like this every Monday for 20,000+ engineers → https://t.co/gI46R2Kc0c

How do you handle the charge-succeeds-but-commit-fails case in your services?

[Stefan Đokić | .NET @TheCodeMan__]

For years, we faked union types in C#.

Marker interfaces. Base classes. The OneOf library. Anything to model "this is either a Success or a Failure."

C# 15 finally bakes them into the language.

What changes in practice:

→ You declare the shape once - Success or Failure - and the compiler knows the full set of cases.

→ Your switch becomes exhaustive. Miss a case, and the compiler tells you, instead of a NullReferenceException at runtime.

→ No more third-party library just to express a closed set of outcomes.

This is one of those features that quietly removes a whole category of bugs. Modeling "one of N states" has always been clumsy in C#. Now it's first-class.

What do you think about it? How have you created it so far?
__

📌 Join the Newsletter and get "AI in .NET" Starter Kit projects for free: https://t.co/gI46R2Kc0c

♻️ Repost to others.
📂 You can save this post for later, and you should do it.
➕ Follow me to learn .NET and Architecture every day.

[Stefan Đokić | .NET @TheCodeMan__]

@AntonMartyniuk Happy Birthday, bro! Everything I wish for myself, I wish for you too. Keep pushing harder and never stop chasing greatness. Have an amazing day! 🎉💪

[Stefan Đokić | .NET @TheCodeMan__]

800+ GitHub stars. 20,000+ developers. And the most common thing they tell me?

"I wish I had this before my last interview."

So here it is -> Pass Your .NET Interview. 250 questions with answers, code, and complexity analysis. Free.

What you get:

🔹 Arrays, Lists & Trees, 60 coding problems, each with 2–3 C# solutions and Big-O breakdown
🔹 General .NET / C# / SQL, 70 questions covering the full stack: async, SOLID, DI, EF, Blazor, CI/CD, SQL
🔹 Updated to #dotnet 10
🔹 2 bonus ebooks included

Whether you're prepping for your first job or going for a senior role, this kit gives you the structure you need most.

👇 Grab it here (no credit card, no catch):
https://t.co/xrTmRfBtGp

[Stefan Đokić | .NET @TheCodeMan__]

@AntonMartyniuk EF Core is often blamed for problems that are really query design problems. The database doesn't care whether the SQL came from EF Core or handwritten SQL if both generate the same execution plan.

[Stefan Đokić | .NET @TheCodeMan__]

@AntonMartyniuk Exactly. Exposing an MCP tool is basically exposing an API surface to an AI client. Without authorization, allow-lists, validation, and audit logs, “controlled access” quickly becomes uncontrolled execution.

[Stefan Đokić | .NET @TheCodeMan__]

After I published my article about building an MCP server in #dotnet, a lot of people asked me to record a video.

So I did.

In this one, I show how an AI agent can call real tools in a .NET app:

- run load tests
- compare API endpoints
- analyze results
- explain performance issues

The point is simple:

AI agents become much more useful when they stop guessing and start working with real data.

Watch it here: https://t.co/3jy5D5zp2P

[Stefan Đokić | .NET @TheCodeMan__]

@edandersen Welcome to the club, Ed!

[Stefan Đokić | .NET @TheCodeMan__]

@ifeanyi_we @edandersen lol

[Stefan Đokić | .NET @TheCodeMan__]

A few days ago, I published an article about building an MCP server with .NET.

And the most common response I got was:
“Can you record a video version of this?”
So I did.

But I didn’t want to make another generic “AI chatbot talks to your app” demo.

I wanted to show something more practical:
How can an AI agent actually interact with a real .NET application and help us understand what is happening at runtime?

The demo is simple.

I have an ASP .NET Core API with two endpoints:
/slow-thread-sleep
/slow-task-delay

At first glance, they look almost identical.

Both wait.
Both return a response.
Both seem fine from the outside.

But under load, they behave very differently.

So I built an MCP server in #dotnet that exposes a few tools the AI agent can use:
→ run a load test
→ compare the endpoints
→ analyze the results
→ generate a performance report

And this is where MCP becomes much more interesting.
The AI is no longer just reading code and guessing.

It can call real tools, collect real runtime data, and explain the behavior based on actual measurements.

That’s the part I think many developers are missing when they look at MCP.
MCP is not only about giving AI more context.

It’s about giving AI controlled access to useful actions inside your system.

That could be:
→ performance testing
→ logs
→ metrics
→ database diagnostics
→ deployment checks
→ feature flags
→ internal workflows

Or anything else your team needs.
I recorded a short video where I explain the concept and show the full demo in action.

You can watch it here: https://t.co/DQSolIWsBl

📌 Join the Newsletter and get "AI in .NET" Starter Kit projects for free: https://t.co/3jy5D5zp2P

♻️ Repost to others.
📂 You can save this post for later, and you should do it.

➕ Follow me to learn .NET and Architecture every day.

[Stefan Đokić | .NET @TheCodeMan__]

After I published my article about building an MCP server in #dotnet, a lot of people asked me to record a video.

So I did.

In this one, I show how an AI agent can call real tools in a .NET app:

- run load tests
- compare API endpoints
- analyze results
- explain performance issues

The point is simple:

AI agents become much more useful when they stop guessing and start working with real data.

Watch it here: https://t.co/3jy5D5zp2P

[Stefan Đokić | .NET @TheCodeMan__]

The most underrated question in API versioning is not "how do we version?".

It is "how do we know when it is safe to delete the old version?"

A lot of teams treat version removal as a calendar event.
The sunset date arrives, somebody opens a pull request to delete v1, and nobody really checks if the world is ready.

Sometimes it works.
Sometimes it takes down a key partner integration on a Friday afternoon.

The difference between those two outcomes is rarely the code.
It is the data you collected before pressing delete. A simple but effective practice is to track three things during the deprecation period.

First, what percentage of total requests still hit v1.
Second, which clients or API keys are responsible for that traffic.
Third, which specific endpoints on v1 are still being used.

With those three numbers, "should we remove v1?" stops being a debate and starts being a decision.

If 2% of traffic still uses v1 and it is all coming from one internal team, you know exactly who to talk to.
If 30% of traffic still uses v1 and it comes from twenty different consumers, you are not ready, no matter what the calendar says.

The teams that do this well usually define removal thresholds upfront. Something like: "we remove a major version only when its traffic stays under 5% for 30 consecutive days, and no top-10 consumer is still on it."

That kind of rule removes emotion and politics from the conversation. It also gives consumer teams a clear target. They know exactly what "done" looks like.
There is one more benefit that is easy to miss.

When you base removal on telemetry, your communication with customers improves. Instead of saying "we are removing v1 on this date, please migrate", you can say "you are currently using v1 on these specific endpoints, here is the migration guide for each of them."

That level of specificity dramatically increases the chance that the migration actually happens on time.

Version removal is a production event, not a cleanup task.
Treat it like a release, with data, monitoring, and a rollback plan, and it will stop being scary.

I cover the full decision framework and examples here: https://t.co/UpThwxL1Mb
__

📌 Join the Newsletter and get "AI in .NET" Starter Kit projects for free: https://t.co/gI46R2Kc0c

♻️ Repost to others.
📂 You can save this post for later, and you should do it.

➕ Follow me to learn .NET and Architecture every day.

[Stefan Đokić | .NET @TheCodeMan__]

Let's see what it can do...

[Stefan Đokić | .NET @TheCodeMan__]

@denicmarko @Shefali__J @BatsouElef @RitikaAgrawal08 @natmiletic @mjovanovictech @AntonMartyniuk @orcdev @FrancescoCiull4 @ThePeterMick @webdevluc @csaba_kissi @venelinkochev @razvanmuntian @gabriel_raiseos @rrmdp @petarivanovv9 Thanks Mare!

[Stefan Đokić | .NET @TheCodeMan__]

@AntonMartyniuk I’ve seen header versioning work well internally, but public APIs become harder to reason about when the version is invisible. A simple curl request suddenly depends on hidden metadata instead of the URL telling the full story.

[Stefan Đokić | .NET @TheCodeMan__]

The most underrated question in API versioning is not "how do we version?".

It is "how do we know when it is safe to delete the old version?"

A lot of teams treat version removal as a calendar event.
The sunset date arrives, somebody opens a pull request to delete v1, and nobody really checks if the world is ready.

Sometimes it works.
Sometimes it takes down a key partner integration on a Friday afternoon.

The difference between those two outcomes is rarely the code.
It is the data you collected before pressing delete. A simple but effective practice is to track three things during the deprecation period.

First, what percentage of total requests still hit v1.
Second, which clients or API keys are responsible for that traffic.
Third, which specific endpoints on v1 are still being used.

With those three numbers, "should we remove v1?" stops being a debate and starts being a decision.

If 2% of traffic still uses v1 and it is all coming from one internal team, you know exactly who to talk to.
If 30% of traffic still uses v1 and it comes from twenty different consumers, you are not ready, no matter what the calendar says.

The teams that do this well usually define removal thresholds upfront. Something like: "we remove a major version only when its traffic stays under 5% for 30 consecutive days, and no top-10 consumer is still on it."

That kind of rule removes emotion and politics from the conversation. It also gives consumer teams a clear target. They know exactly what "done" looks like.
There is one more benefit that is easy to miss.

When you base removal on telemetry, your communication with customers improves. Instead of saying "we are removing v1 on this date, please migrate", you can say "you are currently using v1 on these specific endpoints, here is the migration guide for each of them."

That level of specificity dramatically increases the chance that the migration actually happens on time.

Version removal is a production event, not a cleanup task.
Treat it like a release, with data, monitoring, and a rollback plan, and it will stop being scary.

I cover the full decision framework and examples here: https://t.co/UpThwxL1Mb
__

📌 Join the Newsletter and get "AI in .NET" Starter Kit projects for free: https://t.co/gI46R2Kc0c

♻️ Repost to others.
📂 You can save this post for later, and you should do it.

➕ Follow me to learn .NET and Architecture every day.

[Stefan Đokić | .NET @TheCodeMan__]

📌 Watch my last YouTube video: https://t.co/Q1sbikSfuI