Chief Roadblock Remover and Learning Enabler | Software Development Expert | Leadership & Career Coach | Speaker | Author | Building great products, building great teams!

🎯 I'm a result-driven 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗟𝗲𝗮𝗱𝗲𝗿, 𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗺𝗲𝗻𝘁 𝗘𝘅𝗽𝗲𝗿𝘁, 𝗖𝗼𝗮𝗰𝗵, 𝗧𝗿𝗮𝗶𝗻𝗲𝗿 𝗮𝗻𝗱 𝗖𝗼𝗻𝘀𝘂𝗹𝘁𝗮𝗻𝘁 with more than 20 years of professional experience in different domains, including the 𝗳𝗶𝗻𝗮𝗻𝗰𝗲 𝗶𝗻𝗱𝘂𝘀𝘁𝗿𝘆, 𝗯𝗮𝗻𝗸𝗶𝗻𝗴, 𝗲𝗻𝗲𝗿𝗴𝘆 𝘀𝗲𝗰𝘁𝗼𝗿, 𝘁𝗿𝗮𝗻𝘀𝗽𝗼𝗿𝘁𝗮𝘁𝗶𝗼𝗻, 𝗶𝗻𝘀𝘂𝗿𝗮𝗻𝗰𝗲 𝗮𝗻𝗱 𝘁𝗲𝗹𝗰𝗼. 🚀 My mission is to provide 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗲𝘅𝗰𝗲𝗹𝗹𝗲𝗻𝗰𝗲 focused on architecture, the best agile practices, passionately 𝗯𝘂𝗶𝗹𝗱 𝗵𝗶𝗴𝗵-𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗶𝗻𝗴 𝘁𝗲𝗮𝗺𝘀 𝗮𝗻𝗱 𝗼𝗿𝗴𝗮𝗻𝗶𝘇𝗮𝘁𝗶𝗼𝗻𝘀 to deliver innovative, 𝗵𝗶𝗴𝗵-𝗾𝘂𝗮𝗹𝗶𝘁𝘆 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝘀, working closely with customers and developing software products on different platforms.🎓 As a 𝗿𝗲𝘀𝗲𝗮𝗿𝗰𝗵𝗲𝗿, I published 20+ papers and book chapters in international conferences and journals (having more than 440+ citations and h-index 11 on Google Scholar), obtaining 𝗣𝗵.𝗗. 𝗶𝗻 𝗖𝗼𝗺𝗽𝘂𝘁𝗲𝗿 𝗦𝗰𝗶𝗲𝗻𝗰𝗲𝘀. Also, I have been involved as a 𝗿𝗲𝘃𝗶𝗲𝘄𝗲𝗿 𝗮𝗻𝗱 𝗽𝗿𝗼𝗴𝗿𝗮𝗺 𝗰𝗼𝗺𝗺𝗶𝘁𝘁𝗲𝗲 𝗺𝗲𝗺𝗯𝗲𝗿, member of ACM, the IEEE Computer Society, and GOAI Research group. 🧑‍💼 I work as a professional 𝗛𝗶𝗴𝗵-𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 𝗮𝗻𝗱 𝗖𝗮𝗿𝗲𝗲𝗿 𝗰𝗼𝗮𝗰𝗵 for people in engineering leadership positions.✍🏻 Additionally, I am a 𝗽𝗮𝘀𝘀𝗶𝗼𝗻𝗮𝘁𝗲 𝗮𝘂𝘁𝗵𝗼𝗿, who helps more than 400,000 engineers, managers, and architects to build great careers, products, and teams through various platforms and channels.𝗘𝘅𝗽𝗲𝗿𝘁𝗶𝘀𝗲:📌 Leadership📌 Team building📌 Making things efficient📌 Creating self-contained systems📌 Be highly organized and make others too📌 Focus on strategy/goals📌 Make things happen📌 Career Coaching📌 Mentoring📌 Line management📌 Effective client communication📌 Software Architecture📌 DevOps mindset📌 Cloud (Azure)📌 .NET/C# (ASP.NET/WPF)📌 SQL Server/NoSQL📌 Agile methods (Scrum, Kanban, SAFe)📌 Product/project management📲 Feel free to contact me here via LinkedIn (DM)!

Dr Milan Milanović

Kubernetes killed more startups than server crashes ever did

You don't have Spotify's scale. You have 8 engineers and a single server that's running fine

But you watched a KubeCon talk, and now you've got 23 YAML files, a Helm chart nobody fully understands, and engineers debugging pod evictions instead of buildinga  product

Your "cloud-native infrastructure" is just a cloud bill with extra complexity

A $50/month VM can handle millions of requests. Your startup will run out of money debugging networking issues long before you need horizontal pod autoscaling

The best infrastructure decision is often the simplest one

Chief Roadblock Remover and Learning Enabler | Helping 400K+ engineers and leaders grow through better software, teams & careers | Author | Speaker | Leadership & Career Coach

Friday Developers Fun 🤣

The 5-minute meeting with a developer is not what you think it is

#developers #meme #fridayhumor

𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗮𝘀 𝗖𝗼𝗱𝗲

We see more tools enabling you to create software architecture and other diagrams as code. 

The main benefit of using this concept is that 𝗺𝗼𝘀𝘁 𝗼𝗳 𝘁𝗵𝗲 𝗱𝗶𝗮𝗴𝗿𝗮𝗺𝘀 𝗮𝘀 𝗰𝗼𝗱𝗲 𝘁𝗼𝗼𝗹𝘀 𝗰𝗮𝗻 𝗯𝗲 𝘀𝗰𝗿𝗶𝗽𝘁𝗲𝗱 𝗮𝗻𝗱 𝗶𝗻𝘁𝗲𝗴𝗿𝗮𝘁𝗲𝗱 𝗶𝗻𝘁𝗼 𝗮 𝗯𝘂𝗶𝗹𝘁 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲 𝘁𝗼 𝗴𝗲𝗻𝗲𝗿𝗮𝘁𝗲 𝗮𝘂𝘁𝗼𝗺𝗮𝘁𝗶𝗰 𝗱𝗼𝗰𝘂𝗺𝗲𝗻𝘁𝗮𝘁𝗶𝗼𝗻.

Another benefit driving the growing use of diagrams-as-code to create software architecture is that it enables text-based tooling, which most software developers already use.

For architecture, as code, we can use different tools, such as:

𝟭. 𝗦𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗶𝘇𝗿: Create multiple diagrams from a single (C4) model. https://structurizr.com/

𝟮. 𝗣𝗹𝗮𝗻𝘁𝗨𝗠𝗟: It is an open-source tool that allows users to create diagrams from plain text. https://lnkd.in/dWKnyicV

𝟯. 𝗗𝗶𝗮𝗴𝗿𝗮𝗺𝘀: Turn Python code into cloud system architecture diagrams. https://lnkd.in/gPcpcJ7z

𝟰. 𝗠𝗲𝗿𝗺𝗮𝗶𝗱: Generation of diagram and flowchart from a text similar to Markdown. https://lnkd.in/dsTGKbwM

𝟱. 𝗔𝗦𝗖𝗜𝗜 𝗲𝗱𝗶𝘁𝗼𝗿: Free editor for drawing ASCII diagrams. https://asciiflow.com/

𝟲. 𝗠𝗮𝗿𝗸𝗺𝗮𝗽: Could you visualize your Markdown as mind maps? It supports the VS Code plugin. https://markmap.js.org/

𝟳. 𝗚𝗼 𝗱𝗶𝗮𝗴𝗿𝗮𝗺𝘀: Create system diagrams with Go. https://lnkd.in/d-cAq8zB

𝟴. 𝗦𝗲𝗾𝘂𝗲𝗻𝗰𝗲𝗗𝗶𝗮𝗴𝗿𝗮𝗺.𝗼𝗿𝗴: You can create your UML sequence diagrams online using text notation. https://lnkd.in/drux93gN

Image: PlantUML

𝗔𝘇𝘂𝗿𝗲 𝗥𝗼𝗮𝗱𝗺𝗮𝗽 𝗳𝗼𝗿 𝗡𝗘𝗧 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀

As a .NET Developer, you probably already know C#, ASP .NET, and other technologies, but in today's cloud-first world, knowing Microsoft Azure is essential for running and deploying your apps. 

This article provides a step-by-step roadmap for .NET developers who want to master Azure, from the basics to advanced DevOps and architecture.

1) Cloud Fundamentals

Lay the foundation so nothing feels mysterious later

• IaaS / PaaS / SaaS distinctions
• Regions & Availability Zones
• SLAs & cost basics

2) Azure Basics

Learn how Azure is organized and controlled

• Azure Portal, CLI & PowerShell
• Microsoft Entra ID & RBAC (access control)
• Resource groups & tags
• Azure Policy fundamentals

3) .NET Compute + Hosting

Deploy your services reliably

• App Service (web app deployment patterns)
• Azure Functions (triggers & bindings)
• Containers fundamentals + Azure Container Registry
• AKS basics (container orchestration)

4) Data Services

Store and connect data with patterns that scale

• Azure SQL + EF Core practices
• Cosmos DB (multi-model, partitioning)
• Blob & Queue Storage essentials
• Service Bus & Event Grid (async/eventing)

5) DevOps & Automation

Shift from manual to repeatable, safe workflows

• GitHub Actions / Azure DevOps pipelines
• Infrastructure as Code: Bicep (Terraform optional)
• Automated builds, tests & gates
• Deployment strategies (canary, blue/green)

6) Security & Identity

Security isn’t optional once you’re live

• Azure Key Vault & secret management
• Managed identities for services
• App security patterns & best practices

7) Observability & Ops

Run it healthily in production, not just launch it

• Application Insights (traces + metrics)
• Log Analytics & KQL basics
• Alerts + dashboards that teams use
• Resilience patterns (retry, circuit breaker)

8) Architecture & Ops

Make systems that tolerate stress and evolve

• Scalability patterns (CQRS, event-driven, partitioning)
• Microservices vs modular monolith thinking
• Cost optimization in design decisions
• Multi-region distribution fundamentals

Cert milestones you can align with:
AZ-900 → AZ-204 → AZ-400 → AZ-305

#dotnet #csharp #azure #cloud #devops

Vibe coding is good at spitting a lot of code, fast

But you still need to know architecture and system design

As well as fundamentals

Because, if you don't, you will get a big ball of mud, fast

𝗬𝗼𝘂𝗿 𝘁𝗲𝗮𝗺 𝗶𝘀 𝘄𝗮𝘀𝘁𝗶𝗻𝗴 𝟰𝟬% 𝗼𝗳 𝗶𝘁𝘀 𝗲𝗳𝗳𝗼𝗿𝘁. 𝗛𝗲𝗿𝗲'𝘀 𝘄𝗵𝗲𝗿𝗲 𝗶𝘁 𝗴𝗼𝗲𝘀

Most engineering leaders blame slow delivery on headcount. The real problem is invisible waste

In 2003, Mary and Tom Poppendieck mapped Lean manufacturing principles to software and identified seven types of waste. Every PR sitting in review, every feature nobody uses, every time a new hire rediscovers what a departed engineer knew, that's waste compounding quietly

But the original seven aren't the whole story. A 2017 empirical study by Sedano et al. observed eight software projects over two years and found new categories

And now there's a new one. GitClear analyzed 211 million lines of code and found that code churn doubled from 2021 to 2024 as AI coding assistants proliferated. Copy-pasted code jumped from 8% to 12%. We're generating waste faster than ever

The good news: once you learn to see waste, you can eliminate it

👉 Full breakdown: https://lnkd.in/d55iaqJu

Practical .NET and Software Architecture Tips | Microsoft MVP

Hi there! 👋

I'm a senior software engineer, primarily working in the .NET ecosystem.

Things I talk about on LinkedIn:
- C# and .NET ❤
- Software engineering and architecture 
- Distributed systems and how to build them
- Databases and optimization techniques
- Career and personal growth

One of my goals (i̶s̶) was to become a Microsoft MVP in Developer Technologies.
I became an MVP in March of 2023.

If this sounds interesting, let's connect!

Milan Jovanović

You don’t need a Dockerfile anymore.

Yes, really.

Modern .NET can publish your app directly as a container image using the SDK. No scaffolding. No boilerplate. No hand-written Dockerfiles.

Here's what you'll learn:
- How dotnet publish builds a Linux container
- How to run it locally with Docker
- How to push it to GitHub Container Registry
- Why this makes self-hosting .NET apps on a VPS much simpler

If you’ve ever copied a Dockerfile you didn’t fully understand, this is for you.

Check it out: https://lnkd.in/dUFzz3du

This is also the first step in a new series I’m working on around self-hosting .NET apps without overengineering.

undefined undefined

AI in .NET is way easier than people think.

And you can start for free.

If you want a practical first project, build vector search:
- Turn text into embeddings (vectors)
- Store them in your vector store (pg_vector)
- Turn the user’s query into a vector
- Compare with cosine similarity to find the closest matches

That’s why it feels like “search by meaning” instead of keywords.

To do this cleanly in .NET, start with MEAI (Microsoft Extensions AI), the official library for LLM + embeddings.

Start here: https://lnkd.in/dkpadmVc

---

Do you want to simplify your development process? Grab my Clean Architecture template here and save 7 days of development time: https://lnkd.in/dfGYcyFC

I think this makes me an Azure core developer now

/s

Should you stop using random UUIDs in .NET?

Traditional UUIDs (Guid.NewGuid()) are randomized. Great for uniqueness, but terrible for database performance.

They cause:

❌ Expensive index rebalancing
❌ Poor insert performance
❌ High fragmentation

That’s why many developers switched to ULIDs. It's 128-bit, sortable, and still unique.

They preserve temporal order, which makes them more index-friendly.

But now, there’s something new:

✅ Guid.CreateVersion7() in .NET 9+

UUID V7 is time-ordered and compatible with ULIDs, without needing a 3rd-party package.

You get the benefits of ULID, but natively supported in .NET.

Would you switch from ULID to V7 UUIDs?

---

Do you want to simplify your development process? Grab my Clean Architecture template here and save 7 days of development time: https://lnkd.in/dfGYcyFC

Not all Load Balancing strategies are created equal.

If you are using YARP (Yet Another Reverse Proxy) in .NET, you have 5 built-in ways to distribute traffic. But which one should you choose?

Here is the breakdown:

1. RoundRobin: The classic. It cycles through servers evenly. Simple, but it assumes all servers are equally fast.

2. LeastRequests: The smart choice. It sends traffic to the server currently doing the least work.

3. Random: It picks a server at random. Surprisingly effective for high-volume, uniform workloads.

4. PowerOfTwoChoices: The balanced approach. It picks two random servers and chooses the one with fewer requests. It avoids the overhead of checking every server.

5. FirstAlphabetical: The "sticky" one. It always picks the first available server. Good for failover setups, bad for load distribution.

Most people stick with RoundRobin, but switching to LeastRequests can significantly improve tail latency in systems where request times vary.

I dive deeper into how to scale horizontally using YARP here: https://lnkd.in/daDNMpmB

Which strategy is your default choice?

---
Sign up for the .NET Weekly with 75K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/dcvJmi7E

Stop calling DateTime.UtcNow in business logic.

This line looks harmless... and it’s the reason your tests are a mess.

Here’s the trap:

- DateTime.UtcNow > user.SubscriptionEnd

Seems harmless, right?

But the moment you try to test this logic, you realize the problem:

- You can’t control DateTime.UtcNow
- Your tests become flaky or complicated
- Business rules are tied to infrastructure

There are better ways:

1. Inject DateTime as a parameter — simplest, great for small methods

2. Introduce an IClock interface — more scalable, and test-friendly

By inverting the dependency on time, you make your domain logic:

✅ Easier to test
✅ More deterministic
✅ Separation of concerns

Next time you write a time-based condition, stop and ask:

“Will I need to test this?”

If the answer is yes, extract the clock.

---
Do you want to simplify your development process? Grab my Clean Architecture template here and save 7 days of development time: https://lnkd.in/dfGYcyFC

How did we make a simple idea so complicated?

CQRS is the simplest pattern out there.

First, there was CQS: Command Query Separation.

What does this mean? We split an object's methods into write (command) and read (query) methods.

CQRS is the evolution of CQS. CQRS works on the architectural level. At the same time, CQS works on the method (or class) level.

The CQRS pattern uses separate models for reading and updating data.

This separation can be logical OR physical.

My preferred approach is starting with logical CQRS.

One database + separate flows for writes and reads.

You can design a data model fine-tuned for each operation.

A lot of developers stay away from CQRS because they think it's complex.

The reality is you're probably already applying CQRS principles without knowing it.

Here's a simple implementation: https://lnkd.in/d-qUdpn3

What do you think about the CQRS pattern?

---
Sign up for the .NET Weekly with 75K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/dnecq4zh

The best HttpClient config is the one you don’t repeat in every service.

In .NET, you set it up once with IHttpClientFactory (and Aspire if you’re using it):
- Discovery for service-to-service calls
- Resilience defaults so transient failures don’t hurt you

Then you just inject the client and write business code.

Want the full walkthrough?

Start here: https://lnkd.in/dQNxjHix

---

Do you want to simplify your development process? Grab my Clean Architecture template here and save 7 days of development time: https://lnkd.in/dfGYcyFC

Here are 9 excellent libraries I use in my projects:

1. YARP
2. Polly
3. EF Core
4. Refit
5. Testcontainers
6. OpenTelemetry
7. FluentValidation
8. xUnit
9. Dapper

Which library would you add to the list?

---
Sign up for the .NET Weekly with 76K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/dbU3m97Q

Stop trying to force Domain-Driven Design into every feature.

Sometimes, the best architecture is the simplest one: The Transaction Script.

It’s a classic pattern from Martin Fowler, and it fits 80% of CRUD scenarios perfectly.

Instead of building complex aggregates and value objects, you just write a simple, procedural script that handles a single request:

1. 𝗩𝗮𝗹𝗶𝗱𝗮𝘁𝗲 the input data.
2. 𝗖𝗮𝗹𝗰𝘂𝗹𝗮𝘁𝗲 the result (business logic).
3. 𝗣𝗲𝗿𝘀𝗶𝘀𝘁 the changes to the database.
4. 𝗥𝗲𝘁𝘂𝗿𝗻 the response.

It is fast, readable, and easy to test.

I wrote an article showing a side-by-side comparison of this vs. a Rich Domain Model.

See the code here: https://lnkd.in/d9dwgpdq

👉 When to switch: Start with a Transaction Script. Only refactor to a Domain Model when the business logic becomes "chatty", meaning you have too many if/else blocks or complicated state transitions that are hard to track in a single method.

---
Sign up for the .NET Weekly with 76K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/dbU3m97Q

In .NET, you usually have to choose between Speed and Consistency.

In-Memory Caching (IMemoryCache):
✅ Blazing fast (nanoseconds).
❌ Data is stuck on one server. If you have 10 nodes, you have 10 caches.

Distributed Caching (IDistributedCache / Redis):
✅ Shared across all servers. Consistent data.
❌ Network latency. Serialization costs. It's slower.

The Solution: HybridCache.

Don't choose one. Use both.

A Hybrid Cache creates a tiered architecture:

- L1 (Local): The app checks RAM first. If it's there, return instantly.
- L2 (Distributed): If missing locally, check Redis.
- Source: If missing in Redis, fetch from DB, then populate both L1 and L2.

While Microsoft is working on a native implementation, I still swear by FusionCache as the most robust, battle-tested library for this.

I wrote a guide on how to set this up properly: https://lnkd.in/d6NKgMVp

Are you currently using just Redis, or a multi-layer cache?

---
Sign up for the .NET Weekly with 75K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/dCMpeCNe

Most OAuth demos are useless in the real world.

They skip the part that matters: how public clients should actually get tokens.

I just published a step-by-step video on running Keycloak in Docker + OAuth 2.0 Authorization Code flow with PKCE.

What you’ll see:
- Keycloak (latest) running locally with Docker/Compose
- Realm + user + public client setup
- Using .well-known/openid-configuration so you don’t guess endpoints
- Full PKCE flow in Postman (authorize → code → token exchange)
- Quick JWT inspection + the “why is this 401/403?” scope moment

If you’re building SPAs or mobile apps, PKCE isn’t optional. It’s the safe default.

Watch it here: https://lnkd.in/deZWiEbi

The worst kind of bug is the one that explodes 3 days after deployment.

This is the hidden danger of the standard Options Pattern in .NET.

You might bind your appsettings.json to a class, inject it, and everything looks fine. The app starts up perfectly.

But if a required API Key is missing? You won't know until a user triggers that specific feature, and the app crashes.

This is why "Fail Fast" is crucial for configuration.

If your config is invalid, your application should refuse to start. Period.

You can achieve this by extending the Options Pattern with IValidateOptions.

Instead of just binding data, you attach validation logic:

1. Define rules (e.g., "ApiKey cannot be null", "RetryCount must be > 0").
2. Register the validator.
3. If the config breaks the rules, the DI container throws an exception immediately at startup.

I took this a step further and integrated FluentValidation to make the rules cleaner and more expressive.

Here is the complete implementation code: https://lnkd.in/djz5Yfux

---
Sign up for the .NET Weekly with 75K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/dcvJmi7E

Hidden danger of Options Pattern in .NET

I failed a .NET interview question that looked easy.

“Add caching to an async API.”

The tricky part isn’t caching.
It’s what happens when 50 requests hit the same cold cache at once:
- race conditions
- cache stampedes (thundering herd)
- why ConcurrentDictionary still isn’t enough
- why you can’t await inside a lock
- the SemaphoreSlim async-lock pattern (with try/finally, double-check, timeout)
- scaling it with per-key locks to reduce contention

I break it down step-by-step using a currency conversion example, and show the exact refactor path from “works locally” to “works under load.”

Watch it here: https://lnkd.in/dyN7_acX

If you need to run a task "Every Friday at 5 PM," how do you implement it?

A While(true) loop with a Thread.Sleep() is not the answer.

You need a robust scheduler that understands Cron Expressions.

A Cron expression allows you to define complex recurring schedules with a compact string.

For example:

• 15 10 * * * = 10:15 AM every day.
• 15 10 * * MON-FRI = 10:15 AM, but only on weekdays.

In the .NET ecosystem, the heavyweight champion for this is Quartz.

It parses these expressions for you and ensures your background services fire exactly when they are supposed to.

I broke down how to configure your first job and trigger in this article: https://lnkd.in/dfy-U7jp

What library do you currently use for background jobs?

---
Sign up for the .NET Weekly with 75K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/dJGs8Uzv

Stop wasting the first 3 days of every project setting up boilerplate.

I built a free, production-ready Clean Architecture template to handle the plumbing for you.

It's already used by 40,000+ developers.

Here is what's inside the latest version:

- 𝗨𝗽𝗱𝗮𝘁𝗲𝗱 𝘁𝗼 .𝗡𝗘𝗧 𝟭𝟬
- 𝗡𝗲𝘄 .𝘀𝗹𝗻𝘅 𝗦𝗼𝗹𝘂𝘁𝗶𝗼𝗻 𝗙𝗼𝗿𝗺𝗮𝘁
- CQRS (No MediatR dependency)
- Structured Logging & Validation
- JWT Authentication & RBAC
- Docker Compose support

It saves you hours of setup time.

Download it for free here: https://lnkd.in/dbU3m97Q

💡 Why the shift to .slnx? The new Solution format in .NET is a game-changer. It replaces the old bloated syntax with a clean XML syntax. It makes merge conflicts in your solution file a thing of the past.

AI won’t replace you in 2026.

But a developer who knows how to engineer with AI absolutely will.

I recorded a new video on how I’m using AI tooling for .NET development (mainly Cursor), and the point isn’t Cursor.

It’s the workflow.

Here’s what I do every time:
- Plan first (write the steps before touching code)
- Give AI tight constraints (what to change, what NOT to change)
- Review like it’s a PR (DI lifetimes, packages, SQL correctness, connection handling)
- Verify (build + tests) so you don’t ship “confidently wrong” code

In the video, I walk through a real refactor: moving query handlers from EF Core to raw SQL/Dapper, and show the exact spots where AI gets you 90% there... and where that last 10% can break things.

You can watch it here: https://lnkd.in/dzZiKR66

If you’re trying to “stay relevant” in the AI era, the skill isn’t prompting.

It’s owning correctness.

No alternative text description for this image

Data Annotations are great for simple things.

[Required]? Fine.
[MaxLength(50)]? Sure.

But what happens when you need to validate something against a database?
Or validate based on a configuration setting in appsettings.json?

Data Annotations hit a wall. You can't easily inject dependencies into an Attribute.

This is where FluentValidation shines.

Because your validators are just standard classes registered in the DI container, you can inject anything you need.

Want to check if a CouponCode is valid by calling the IPricingService? Just inject it into the OrderValidator constructor.

It turns validation from a static check into a dynamic, intelligent logic layer.

I explain how to wire this up seamlessly in ASPNET Core here: https://lnkd.in/d9nVR8fu

It is a game changer for complex business rules.

---
Sign up for the .NET Weekly with 75K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/dCMpeCNe

taplio

The Battle

Dr Milan Milanović

Milan Jovanović

Followers

Posts

Engagements

Likes

Performance ScoreDr Milan Milanović's LinkedIn Performance

Performance ScoreMilan Jovanović's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Dr Milan Milanović

Milan Jovanović

Followers

Posts

Engagements

Likes

Performance Score.css-goub6s{font-size:var(--chakra-fontSizes-md);font-weight:500;color:var(--chakra-colors-gray-600);display:block;margin-top:var(--chakra-space-1);}Dr Milan Milanović's LinkedIn Performance

Performance ScoreMilan Jovanović's LinkedIn Performance

Ready to grow your LinkedIn presence?

Performance ScoreDr Milan Milanović's LinkedIn Performance