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 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ć

Developers don't like legacy projects

But, in software, legacy means it makes money

'Greenfield' means 'no revenue' (yet)

Legacy code is messy because it has survived user contact

Greenfield is clean because nobody's tried to break it

The code you hate is funding your salary

The code you want to write isn't

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

The best engineers I know delete more code than they write

Junior engineers add features. Senior engineers remove complexity

Every line of code you write is a liability. It needs to be maintained. It can break. It adds cognitive load to anyone who reads it later

The best pull requests I've seen in the last year? Half of them deleted more than they added. Someone refactored three classes into one. Someone replaced 200 lines of custom logic with a library function. Someone removed an entire abstraction layer that wasn't pulling its weight

Deletion is a skill. You have to know what's safe to remove. You have to understand the system well enough to see what's redundant, over-engineered, or just wrong

Next time you open a file, ask: What can I remove?

The best code is the code you don't write

𝗗𝗼 𝗻𝗼𝘁 𝗹𝗲𝘁 𝗽𝗲𝗼𝗽𝗹𝗲 𝘁𝗵𝗶𝗻𝗸 𝘆𝗼𝘂 𝗱𝗼𝗻’𝘁 𝗯𝗲𝗹𝗼𝗻𝗴

As former President Obama said in the podcast, when you sit with people at fancy places (Harvard, US Senate, etc.) with people with fancy titles and talk to them, you will learn one thing...

They are nothing special; they are just a normal person like you.

They just have confidence that they belong to something.

Give that confidence to yourself and sit at that table.

And when you get a seat at the table, make room for someone else who has never had a seat.

I wish you a great week ahead 👋!

Video: Pivot Podcast.

#management #personaldevelopment #success #career #leadership

If you're a developer who ships code daily, remember these:

- First, make it work; nobody cares how elegant broken code is
- Then make it fast, slow code that works still frustrates users
- After that, make it pretty, so that your teammates read code more than they write it
- Add tests that actually catch bugs, not just boost coverage metrics
- Refactor when you finally understand what you're building (usually the second time through)

Perfect code on the first try is a myth. 

Fast iteration beats slow perfection every time

If you're a senior software engineer, here is an incomplete list of engineering practices you must know:

- Source control / GIT
- Tests (check Test Pyramid)
- Clean code
- Pair / Mob programming
- Design Patterns
- Refactoring
- TDD / BDD
- YAGNI, DRY, KISS, SOLID
- Automatic code analysis
- Code reviews
- Documenting

Anything else to add?

𝗔𝗣𝗜 𝗚𝗮𝘁𝗲𝘄𝗮𝘆 𝘃𝘀 𝗟𝗼𝗮𝗱 𝗕𝗮𝗹𝗮𝗻𝗰𝗲𝗿 𝘃𝘀 𝗥𝗲𝘃𝗲𝗿𝘀𝗲 𝗣𝗿𝗼𝘅𝘆

Regarding a system design, we often need clarification about the roles of a Load Balancer and an API Gateway. Most of our resources are about their implementation rather than real-life use cases.

𝗔𝗣𝗜 𝗚𝗮𝘁𝗲𝘄𝗮𝘆 

It sits between a client and a group of backend services. It serves as a reverse proxy, accepting all application programming interface (API) calls, aggregating the services needed to fulfill them, and returning the appropriate results. 

User authentication, rate limits, and statistics are typical duties that API gateways handle on behalf of an API service system. Also, the API gateway can handle faults (circuit breakers), logging, and monitoring.

𝗟𝗼𝗮𝗱 𝗕𝗮𝗹𝗮𝗻𝗰𝗲𝗿 

It is a service that distributes incoming traffic across many servers or resources. Usually, we have two or more web servers on the backend, and it 𝗱𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝘀 𝗻𝗲𝘁𝘄𝗼𝗿𝗸 𝘁𝗿𝗮𝗳𝗳𝗶𝗰 𝗯𝗲𝘁𝘄𝗲𝗲𝗻 𝘁𝗵𝗲𝗺. 

Its primary purpose is to use resources optimally. A more equal task allocation and increased capacity can enhance the system's responsiveness and reliability. 

There are three load balancers at a high level: hardware-based, cloud-based, and software-based.

𝗥𝗲𝘃𝗲𝗿𝘀𝗲 𝗣𝗿𝗼𝘅𝘆 

A server sits in front of backend servers and forwards client requests to them. Reverse proxies are typically used to enhance security, performance, and reliability. 

A reverse proxy receives a request from a client, forwards it to another server, and returns the response to the client, giving the impression that the first proxy server handled the request. These proxies ensure that users don't access the origin server directly, giving the web server anonymity. 

They are usually used for Load balancing, where we need to handle incoming traffic and distribute it across multiple backend servers, or for caching.

So, the main thing that differs these two is that an 𝗔𝗣𝗜 𝗚𝗮𝘁𝗲𝘄𝗮𝘆 𝗶𝘀 𝗳𝗼𝗰𝘂𝘀𝗲𝗱 𝗼𝗻 𝗿𝗼𝘂𝘁𝗶𝗻𝗴 𝗿𝗲𝗾𝘂𝗲𝘀𝘁𝘀 to the appropriate service and it handles requests for APIs, while a 𝗟𝗼𝗮𝗱 𝗯𝗮𝗹𝗮𝗻𝗰𝗲𝗿 𝗶𝘀 𝗳𝗼𝗰𝘂𝘀𝗲𝗱 𝗼𝗻 𝗱𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗶𝗻𝗴 𝗿𝗲𝗾𝘂𝗲𝘀𝘁𝘀 𝗲𝘃𝗲𝗻𝗹𝘆 between a group of servers and handles requests that are sent to a single IP address, which works at protocol or socket level (TCP, HTTP).

Some 𝗲𝘅𝗮𝗺𝗽𝗹𝗲𝘀 of API Gateways are Amazon API Gateway, Ocelot (.NET-based), Tyk, or Apache APISIX, while Load Balancers are Azure Load Balancer, HAProxy, or Seesaw.

An example of reverse proxy services is 𝗔𝗽𝗮𝗰𝗵𝗲 𝗣𝗿𝗼𝘅𝘆, 𝗡𝗴𝗶𝗻𝘅 𝗼𝗿 𝗜𝗜𝗦 with additional modules (Url Rewrite).

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ć

I upgraded my Clean Architecture template to .NET 10.

And it took only a few minutes. Here's how 👇

My .NET version is defined in one place, a Build props file. I updated to net10 and that took care of all the projects in the solution.

The next part was updating the NuGet packages.

This was equally simple with central package management. I updated the version in the Packages props file, and it was picked up by all the projects in the solution.

Here's what's inside:
- Simple domain model with Domain Events pattern
- CQRS (no MediatR) + clean use cases implementation
- Validation and logging cross-cutting concerns
- Authentication with JWT and user context
- Boilerplate for RBAC authorization
- Docker Compose orchestration
- Minimal APIs, health checks

You can get the template here: https://lnkd.in/eihaFihr

I recently found out my template is used by a local company, doing $30M+ yearly revenue.

Did you check out the new IExceptionHandler feature?

You have to handle exceptions somehow.

IExceptionHandler implements the "try-" pattern.

You can decide which exceptions to handle.

To tell the middleware you handled the exception, you return true.

So, what makes this so interesting?

You can also chain multiple exception handlers that will run sequentially.

The first one to handle the exception successfully breaks the chain.

Here's how to use this in .NET 10: https://lnkd.in/e9k5yeJ3

It's a way to compose multiple exception handlers.

How do you approach global error handling?

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

LinkedIn

JSESSIONID

li_at

linkedin.com

Talks about #csharp, #dotnet, #databases, #softwareengineering, and #softwarearchitecture

.NET 10 is officially released! 🎉

Here are the top updates 👇

First, .NET 10 is an LTS (long-term support) release. So we get support for the next 3 years.

🔥 Performance improvements

Under the hood, .NET 10 delivers major performance boosts. The JIT compiler has been tuned with new optimizations such as de‑abstraction, smarter inlining heuristics and constant‑folding, allowing the runtime to do more work at compile‑time rather than at run‑time. There are many other optimizations across collections and LINQ, which translate to tangible speedups across everyday workloads.

🚀 Aspire goes polyglot

Formerly .NET Aspire, Aspire is now a polyglot, developer‑first platform for orchestrating front ends, APIs, containers and databases. Version 9.5 introduces a preview of a single‑file AppHost, letting you define and run your entire distributed application in a single file. The release also debuts a Generative AI visualizer to inspect and debug prompts and responses, plus expanded AI support with typed clients for GitHub Models and Azure AI Foundry and first‑class OpenAI integration.

🔗 EF Core’s new LeftJoin/RightJoin operators

LINQ’s lack of a built‑in outer join has long been a pain point. EF Core 10 fixes this by adding LeftJoin and RightJoin operators, so the code now reads exactly like the SQL you intend. For example, you can join products to reviews using LeftJoin() and EF will generate the correct LEFT JOIN statement under the hood. A corresponding RightJoin() keeps all rows from the right side while bringing in matches from the left. These new operators eliminate the verbose GroupJoin + DefaultIfEmpty pattern and make LINQ queries easier to read and maintain.

What's your favorite feature coming in .NET 10?

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

What's new in .NET 10?

I failed an interview because I didn't know how locks work in C#.

Read this to make sure it never happens to you.

I've told this story a couple of times before, but it's worth repeating.

I was in an interview some 7-8 years ago, doing a live coding exercise.

I was integrating with a currency conversion API and needed to add caching.

The problem was how this would scale with multiple concurrent requests.

A classic cache stampede problem.

I wanted to prevent this with locking.

Locking allows us to control how many threads can access some piece of code.

Note that I rarely worked with low-level code.

But the company I was interviewing for does.

Of course, they'd have this in the interview process.

Here's the situation:

- I knew I needed a locking mechanism
- But the method was async (oof!)
- So I tried to solve this using the `lock` statement

And that's where it all went to shit...

The `lock` statement doesn't work with async-await.

And it makes sense.

You can't guarantee which thread will complete the method.

So what's the solution?

You need to use an asynchronous synchronization primitive.

Luckily, C # has many to choose from.

Semaphore, SemaphoreSlim, Mutex, Monitor, etc.

Two important remarks:

1) Use a timeout when waiting on the semaphore
2) Always release the lock with a try-finally

Here's a tough question for you.

How would you implement a lock in a database?

If you want to find the answer, go here: https://lnkd.in/eVTMfu-y

Would you have nailed this interview?

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

You can find security risks in your code at build time.

Here's a simple way you can implement this in .NET in a few minutes.

Imagine being able to find security risks when you build your code.

Static code analysis lets you do this.

Here's an example build error that warns me my password hashing code is insecure. 👇

Static code analysis can help you write secure and consistent code. And you can also enforce this at build, even in CI pipelines.

If you want to see how to set this up from scratch, check out this article: https://lnkd.in/dyYFpBYZ

Note that this doesn't detect every possible issue.

If you want to take this further, you can look at more powerful solutions like SonarQube.

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

If you're still writing five separate interfaces and classes for every single command in .NET, you need to see this.

For years, many of us in the .NET community have relied on MediatR and MassTransit for command handling and messaging. But the boilerplate is real.

I finally took the plunge and explored Wolverine, a library that claims to be the "next generation" of .NET messaging by focusing on convention over configuration.

In my new video, I share my raw, first-take as a long-time user of other messaging tools: https://lnkd.in/eDm9Aa3p

No alternative text description for this image

I love working with the Service Discovery library in .NET.

It's a lightweight configuration-based approach.

This actually came out of the effort done in Aspire.

If you're new to this concept, here's a quick breakdown.

Service discovery allows developers to reference external services using logical names instead of physical IP addresses and ports.

There's a centralized store for services to register themselves.

Clients can query the service registry to find the service's physical address.

The service discovery library for .NET is simpler, though.

It still lets you use logical names to refer to external services.

However, the discovery side is "lacking".

You have to specify the physical addresses in the application settings.

Here's a step-by-step tutorial: https://lnkd.in/eX4Wy3jD

You can configure the service URLs during deployment in your CI/CD pipelines.

Or even use a central configuration store (Azure App Configuration) for service discovery URLs.

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

Most REST APIs fail not because of bad code, but because of bad design.

After building and reviewing dozens of APIs over the years, I’ve learned one thing: Consistency and pragmatism matter more than “perfect” architecture.

In my latest video, I share 8 pragmatic REST API design tips that I use in production. From consistent naming and correct status codes, to pagination, error responses, and hypermedia links, all shown in a real .NET example app.

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

If you’re designing APIs for real-world systems (not toy projects), this one’s for you.

What's the fastest way to do a SQL bulk insert?

I tested out all the popular approaches...

SqlBulkCopy is your winner. It's the fastest way to insert a large amount of data into SQL Server. But it does require writing more code than the other approaches.

Postgres has the COPY command, which works similarly.

Here are 5 more solutions I compared: https://lnkd.in/eearSh_z

Which one would you use?

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

The fastest way to do Bulk Inserts

Need to generate a PDF document?

I love the simplicity of using HTML templates to generate PDF documents.

I create a Razor view as the template and render it to HTML with my data.

You can also use Handlebars. It doesn't matter as long as you create an HTML document.

Then you need a library that can convert the HTML into a PDF.

I used IronPDF in this example. Free options include Puppeteer or Playwright.

Here's a simple way to get started: https://lnkd.in/ewai8kjk

This could be all you need for generating your PDF documents.

What is your approach to creating PDFs?

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

PDF Reporting in .NET

Stop storing secrets in appsettings.json. Seriously.

That file was never meant to hold production credentials, yet I see it in real projects all the time.

I just published a new walkthrough where I show how to secure your .NET apps with Azure Key Vault:

- Creating your first Key Vault
- The exact RBAC roles you actually need
- Storing secrets with versioning
- Authenticating with DefaultAzureCredential
- Pulling secrets directly into ASPNET Core configuration
- Loading connection strings + options without touching appsettings

It’s a clean setup that keeps your sensitive values out of the repo and follows Azure’s best practices.

Learn more here: https://lnkd.in/eU4mUKnY

If you want to upgrade how you handle secrets in .NET, this one will help you get it right from the start.

I built a stock price dashboard using Cursor + .NET. 🔥

The real-time component uses SignalR.

The backend gets the initial stock price from a free stock market API.

Then, I have a background job that generates a price update and streams it to clients using SignalR.

The UI is pure HTML + JavaScript + Tailwind CSS for stylization.

And I vibe coded all this with AI in a couple of minutes.

It took me about ~15 seconds to add support for dark mode.

Did you have a chance to try Cursor?

It's my go-to AI editor these days.

Developer + AI is the future.

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

Are you accidentally crippling your EF Core queries?

Before you start bashing on EF, this is an SQL problem, not an EF problem.

But it can be problematic to find and fix with EF.

Understand the Cartesian Explosion problem and how it occurs in your queries.

I'll give you a practical solution using EF Core's query-splitting feature.

Here's the full story: https://lnkd.in/ezv5B48v

In future versions of EF, the split queries will be batched, which should significantly improve performance. 

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

EF Query splitting

I rewrote a 40-year-old APL system to a modern tech stack.

It powers a $10M manufacturing business with 460+ database tables.

Here are 5 lessons I learned in 4 years:

1. Start with core business logic first

2. Modular architecture is worth the investment

3. Data sync is harder than you think

4. Balance technical needs with business pressure

5. Document institutional knowledge before it's gone

Want the full story of our legacy migration journey?

Check out my blog post: https://lnkd.in/eacxqj7z

This project taught me so many things about enterprise architecture.

I think you'll learn a few things too.

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

Looking for a simple message bus in .NET?

I recommend taking a look at System Threading Channels.

You can implement a simple in-memory message bus using Channels in .NET.

Channels implement the producer-consumer pattern:

- Producers asynchronously produce data
- Consumers asynchronously consume that data

A channel has a Writer and Reader, that you can use to publish and consume messages. respectively.

Here's how you can use this to implement a simple message bus: https://lnkd.in/ekfJZd5n

Remember that this is still an in-memory bus, so it's not reliable.

You can implement resiliency around this, but it only goes so far.

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

Most teams get microservices communication wrong.

They obsess over APIs and forget the real problem: coupling and reliability.

In my latest video, I break down how microservices should actually talk to each other. You’ll see where synchronous (HTTP, gRPC) calls make sense, and where you should switch to asynchronous messaging with queues and topics.

I also cover real .NET examples with Azure Service Bus, Redis, and distributed tracing, so you can see how to design communication that’s fast, reliable, and easy to reason about.

Check it out here: https://lnkd.in/eGB3WUqW

If you’re building or refactoring a microservices system, this will save you a lot of pain later.

Implementing resilience in .NET? You better...

Polly is probably your first choice.

And Polly is much faster in V8+.

But why should you care about making your application resilient?

Let's say your services communicate by sending HTTP requests.

HTTP requests can fail because of network or server issues.

These failures can disrupt service availability, especially as dependencies increase. This increases the risk of cascading failures.

Luckily, there's a simple way to solve this in your .NET applications.

Here's how you can make your apps resilient: https://lnkd.in/e39__DXH

Do you use Polly in your applications?

There's also an official resilience library in .NET.

But it's a wrapper around Polly that adds OpenTelemetry on top.

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

Was API Versioning a mistake?

I built and maintained a large public API (400+ endpoints).

The API has dozens of integrations, serving mainly mobile applications.

When your API is serving so many clients, breaking changes are expensive.

So, everything I implemented on the public API had to be planned.

If I wanted to introduce breaking changes, I had to version the API.

This wasn't a standard I decided on, but I had to live with the consequences.

API versioning allows your API to evolve independently from the clients using it - or so they say.

What we actually need is change management for APIs.

1. Don't remove anything
2. Don't change business rules
3. Don't make optional things required
4. New things must be optional

I explained this (and many other things) in-depth in Pragmatic REST APIs: https://lnkd.in/eXP53TP6

What do you think about API versioning?

P.S. I've got a Black Friday offer for my Pragmatic REST APIs course that expires soon. Don't miss it.

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

Do you know all 3 service lifetimes in .NET?

ASPNET Core has three service lifetimes:
- Transient
- Singleton
- Scoped

Here's how they work. 👇

Transient services are created each time they're requested from the service container.

Scoped services are created once within the scope's lifetime. For ASP .NET Core applications, a new scope is created for each request. This is how you can resolve scoped services within a given request. You can also create a custom scope within a method, for example.

ASPNET Core applications also have a root service provider to resolve singleton services.

What if you want to resolve a scoped service inside a singleton service?

Here's what you will need to do: https://lnkd.in/eg_EQHb6

The solution isn't too complicated.

Save this for when you need it.

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

Cursor pagination is blazing fast.

But it's not a good solution for every situation. Here's why. 👇

Cursor pagination uses a reference point (cursor) to fetch the next page of results.

This reference point must be a unique identifier or a combination of fields that define the sort order.

My tests showed cursor pagination was 17x faster compared to offset pagination.

So why don't we always use it?

Cursor pagination works particularly well for real-time feeds and infinite scroll interfaces.

If most users start at the first page and rarely visit other pages, offset pagination might be sufficient. This will be the case for many applications.

Want to learn more about cursor pagination?

Here's an implementation guide + performance analysis: https://lnkd.in/eS2h4CgC

Did you ever implement cursor pagination?

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

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