Milan Jovanovic Tech

Founder

Upwork

Senior Software Engineer

HTEC Group

Responsible for major architectural and software design decisions in various in-house projects. Acting as a technical advisor to teams solving challenging problems. Also working as the lead developer for an order placement and processing application for a luxury kitchen manufacturing company.

Application Architect Associate

Responsible for major architectural and design decisions in order placement and processing application for a luxury kitchen manufacturing company. The system has a set of unique challenges from a domain and technology perspective.

I developed a robust Outbox / Inbox messaging system for our event-driven application. Also commonly known as the "Outbox pattern".
The application is split into independent modules, which interact with each other by publishing events.
We needed to process outgoing messages "out of process", to avoid distributed transactions.
We also needed to ensure "at least once" message delivery, and ensure idempotency on the receiving side.

Another one of my responsibilities was application performance, where I focused on the following:
- Ensuring all our SQL queries were optimally written, often investigating the execution plan to make adjustments
- Creating the optimal database indexes for queries processing a large number of records
- Troubleshooting and optimizing algorithms

Developing an order placement and processing system for a luxury kitchen manufacturing company. The application has a set of unique challenges from a domain and technology perspective.

The domain itself is very rich and complex, which is why we have adopted DDD for modeling the core of the system.

We are developing the application itself using the Modular Monolith architecture.
Each Module is implemented with Clean Architecture and CQRS.
Modules interact with each other using messaging, through RabbitMQ.

Software Engineer

Ingsoftware

My responsibilities as a technical lead at Ingsoftware are managing a small development team that consists of front-end and back-end developers. I'm in charge of making important technical decisions aimed at providing the highest quality technical solutions for the present business problems. Communicating with clients (and sometimes stakeholders) on a daily basis and making sure everything is going smoothly.

Apart from these responsibilities, I also regularly take part in the interviewing process for new prospective candidates, as well as work as a mentor for our .NET interns.

Technical Lead

My responsibilities as a software developer at Ingsoftware are:
- Back-end development using C# with ASP.NET Core and .NET Core frameworks,
- Database modeling utilizing SQL Server,
- Proposing efficient and scalable solutions for client requirements,
- Providing accurate LOE estimates for client requirements,
- Mentoring less-experienced teammates and helping them improve (something I truly enjoy),
- Communicating directly with clients,
- Application deployment.

Apart from these responsibilities, I also regularly take part in the interviewing process for new prospective candidates, as well as work as a mentor for our .NET interns.

I won a paid internship through an entry exam that Ingsoftware organized at the annual Job Fair that is held at the Faculty of Electronic Engineering in Niš. The internship helped me learn many new skills that later paved my way into my first employment.

During the internship my responsibilities were:
- Back-end development using C# with ASP.NET MVC and .NET Framework,
- Front-end development using plain vanilla Javascript and Boostrap as a UI framework,
- Using SQL Server for database creation.

.NET Intern

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!

I wrote two almost identical SQL queries.

One of them was 451 times faster.

I was implementing cursor pagination.

And I thought... Why don't I add an index to make my query faster?

This is where things went terribly wrong.

We have an Index Scan using the composite index. Seems good.

But the query is even slower than it was without an index.

What gives?

This might be because the dataset is too small to benefit from the index.

But that wasn't it...

What if we were to use a tuple comparison in SQL?

Finally, the index is working - 0.668 ms.

The query optimizer cannot determine whether the composite index can be used for row-level comparison.

However, the index is effectively used with a tuple comparison.

If I didn't look at the query plan, I wouldn't have figured this out.

Here's the complete performance analysis: https://lnkd.in/eJPgV-UQ

Milan Jovanović

Do you want to learn Clean Architecture and DDD?

I prepared 33 lessons for you 🔥

𝗖𝗹𝗲𝗮𝗻 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗙𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀

- Project setup - https://lnkd.in/dqZeKdvU
- Minimal APIs - https://lnkd.in/eKsvdyeQ
- Dependency injection - https://lnkd.in/e7KK27d9
- CA + Document database - https://lnkd.in/eEywJHFS
- Project setup from scratch - https://lnkd.in/dvAVHzzg
- 4 Best practices for new project - https://lnkd.in/dPfxPfuY
- Structured logging - https://lnkd.in/dRT4EGvr
- Message queues - https://lnkd.in/dvSsgAyn

𝗗𝗼𝗺𝗮𝗶𝗻-𝗗𝗿𝗶𝘃𝗲𝗻 𝗗𝗲𝘀𝗶𝗴𝗻 𝗜𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻

- Rich Domain model - https://lnkd.in/drbTK9_W
- Entities - https://lnkd.in/dQzuqzR6 
- Value objects - https://lnkd.in/d4iWcybq
- Aggregate root - https://lnkd.in/dxb6dx-y
- Domain validation - https://lnkd.in/dZMjb5_v
- Domain model tradeoffs - https://lnkd.in/d2_9fBSv
- Repository pattern - https://lnkd.in/dq-mst-P
- Specification pattern - https://lnkd.in/enP-8n9i
- Unit of work - https://lnkd.in/e668P6wK
- Smart Enums - https://lnkd.in/efq34FS7
- Snapshot pattern - https://lnkd.in/eubBfFk4
- Strongly typed IDs - https://lnkd.in/dpgZ4gBw
- Anemic Domain model - https://lnkd.in/dmrGQTY9
- DDD modeling - https://lnkd.in/dnvgNgfg
- DDD + EF mapping - https://lnkd.in/dmSXbxqt
- Incomplete aggregates - https://lnkd.in/dBDQhRNQ
- Double dispatch - https://lnkd.in/dK4jQT7g

𝗖𝗤𝗥𝗦

- CQRS Fundamentals - https://lnkd.in/dKYS87-6
- Validation /w Result - https://lnkd.in/dZuc-6MM
- Validation /w Exception - https://lnkd.in/dqh9ZcAD
- Read models - https://lnkd.in/dD5W3FDn
- UoW pipeline - https://lnkd.in/dzwg6Uad
- The "Truth" on CQRS - https://lnkd.in/dbpFQ-2f
- CQRS Query side - https://lnkd.in/dKfXaeNx
- Materialized views - https://lnkd.in/dmfjhMKR

Hope this is helpful!

If you liked this, you should join The .NET Weekly - my newsletter with 64,000+ engineers.

Join here → https://lnkd.in/eiwSHUqs

Have an awesome day!

What are the benefits of Clean architecture?

- Modularity
- Separation of concerns
- Testability of business logic
- Improved team productivity
- Loose coupling of components

There's no "right" way to build software.

You should decide what works for you.

Clean architecture works well for me.

I've used it to build excellent products.

If you want to get started faster, I made a free CA template.

Get it here: https://lnkd.in/eYj5ss4W

Why do we need background jobs in .NET?

Let's say I want to move some work in my application to the background.

I want this background work to run outside the normal application flow.

Here are a few examples:

- Sending an email after completing a sale
- Processing messages from a queue
- Clearing stale cache items

You can set up a background task in .NET within minutes.

The most straightforward approach is using the BackgroundService class.

With .NET 8, we can also start these background services concurrently.

What if you need a more robust solution?

Quartz is my first choice.

Here's why: https://lnkd.in/eyWRk8px

5 things I always add to new .NET (API) projects 👇

1. Coding conventions

2. Static code analysis

3. Observability - OpenTelemetry

4. Docker-compose / Aspire - orchestration

5. CI/CD pipeline for build & test (bare minimum)

I built this free Clean Architecture template that has all of this.

Get it here (it's free): https://dub.sh/caw8

How do you draw architectural diagrams?

The most popular option is UML diagrams.

However, there's also the C4 model.

C4 stands for:

- (System) Context Diagram
- Container Diagram
- Component Diagram
- Code Diagram

It's a lightweight model to describe your architecture.

Want to learn more about the C4 model?

Check out this article: https://lnkd.in/ezQ8EBUa

Multiple EF Core DbContexts in a single application?

Here's when it makes sense to do this:

- Working with multiple databases
- Separating concerns
- Modular monolith
- Read replicas

I did this when implementing a modular monolith application.

Each module had a dedicated schema in the database and a separate DbContext in the code.

The surprising part?

How EF Core deals with database migrations and different schemas.

Here's a breakdown of how I solved this: https://lnkd.in/eK8p-azY

No alternative text description for this image

Why should you use Clean Architecture?

Or Hexagonal architecture or Onion architecture...

All three of these architectures follow similar ideas:

- The direction of dependencies is toward the center
- The core contains the domain entities and business rules
- The core should be independent of any external concerns

What do we get from this?

The two qualities I want to highlight are:

- Stability
- Testability

Our business rules and domain entities are in the center and don't depend on anything. This makes them stable because the things around them can change, but it won't affect the business rules.

The second quality is testability. Because our business rules depend on abstractions, they are easy to test. We can provide a mock implementation of the abstraction and use it for testing.

Of course, I still do integration testing with a real database.

So, the essence here is decoupling the business rules from the framework and infrastructure-specific code.

Once you understand these ideas, you don't need a fancy name for the architecture.

Another thing you should consider is cohesion.

Here's why cohesion is important: https://lnkd.in/eKpTW-Kq

What do you think about domain-centric architectures?

How did we make a simple idea so complicated?

CQRS is the simplest pattern out there.

CQRS separates the writes and reads in the application.

This separation can be logical OR physical.

CQRS has many benefits:

- Complexity management
- Improved performance
- Scalability
- Flexibility
- Security

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 out of fear of complexity.

They think you need MediatR to implement CQRS.

This isn't true.

Here's why: https://lnkd.in/eFMnSNsX

What do you think about the CQRS pattern?

MediatR is one of the best .NET libraries I ever worked with.

It just does so many things well, and I can write the code that matters.

MediatR gives you:

- Organize your code around use cases (high cohesion)
- Easily implement cross-cutting concerns
- API endpoints become very thin
- Use cases are highly testable

The aspect is MediatR's most criticized aspect.

It can make code harder to follow, especially for newcomers to the codebase.

However, you can easily solve this problem by defining the requests in the same file as the handler.

Another important thing.

MediatR != CQRS (but it can be)

Here's why: https://lnkd.in/ew9Vu-TU

This is how you do integration testing the right way.

In-memory API instance → Postgres container → Run integration test

You don't need to change anything in your code.

Just set the connection string to point to the Postgres instance.

It doesn't get any simpler than this.

Here's the complete example: https://lnkd.in/eThwmsdP

What is a Webhook?

Here's an example to help you understand it.

You have an application, and you want it to automatically do things without you having to trigger them manually.

That's where webhooks come in!

Webhooks are like messengers, allowing one system to send a message to another whenever a specific event happens. It's like getting a notification on your phone when someone comments on your social media post or when you receive an email.

Webhooks work similarly but for systems and applications.

Here's the basic flow:

1) Service A exposes a webhook
2) Service B subscribes to the webhook from Service A
3) Service A writes down the subscription
4) The event occurs in Service A
5) Service A sends the webhook request to Service B

There are many ways that webhooks can be helpful.
 
For example, you can use webhooks to automatically update a database or trigger an action when a form is submitted on your website.

They can also be used to send notifications or alerts, such as when a new user signs up for your service or when an error occurs in your system.

The main benefit of Webhooks is async processing.

Here's to use it to build better APIs: https://lnkd.in/esB8m2np

What is Dapr?

Dapr is a portable, event-driven runtime that simplifies building microservices.

At its core, Dapr provides standardized building blocks that abstract away the complexity of common microservice patterns.

Rather than wrestling with infrastructure-specific code, you can focus on your business logic while Dapr handles the rest.

Dapr uses the sidecar architectural pattern, where it runs as a separate process alongside your application.

Your application communicates with the Dapr sidecar through HTTP or gRPC, and Dapr handles communication with infrastructure services.

Want to learn more about Dapr?

I wrote a getting started guide for .NET developers.

Find it here: https://lnkd.in/ecwhTHUw

Deploy Full-Stack .NET Apps for FREE with Azure + Postgres

In this step-by-step tutorial, we'll cover:

- Setting up Azure App Service for your backend
- Deploying your frontend with Azure Static Web Apps
- Setting up a free Postgres database using Supabase or Neon

Watch it here: https://lnkd.in/eAa4AC-D

---
P.S. I built this Clean Architecture template to help you ship applications faster. Get it for free: https://dub.sh/caw8

Middleware, but for outgoing HTTP requests?

Yes, we have this in ASP .NET Core.

DelegatingHandlers allow you to add behavior around outgoing requests.

It's like a middleware, except it works in the opposite direction.

An excellent use case for this feature?

Adding authentication headers to the request. 👇

Here's how to implement this + 2 more use case for DelegatingHandler: https://lnkd.in/daWFgRzF

Did you check out the new IExceptionHandler in .NET?

It's a simplified way to handle exceptions globally. IExceptionHandler is part of the built-in exception handling middleware.

You can handle all exceptions or a specific exception. Which also means you can chain handlers.

Want to learn more?

Here's an in-depth article: https://lnkd.in/emipsCZq

There's built-in support for rate limiting in .NET.

Here's what's good and not so good about it.

Rate limiting can make your APIs more robust and secure.
 
It's a technique to limit the number of requests to a server or an API.

There are four popular rate limit algorithms:

- Fixed window
- Sliding window
- Token bucket
- Concurrency

But the .NET implementation has a problem - it only works in memory.

If you want to apply rate limiting in a distributed system, you'll have to define the rate limit policies on a reverse proxy like YARP. Luckily, YARP also works with the built-rate limiting algorithms.

Learn more: https://lnkd.in/e7hAKSnn

What is an API gateway?

The simplest explanation: it's a glorified reverse proxy.

An API gateway is the "front door" to your backend services and APIs.
 
It acts as an intermediary layer, handling client requests and routing them to the appropriate destinations.

The key characteristics of an API gateway are:

- Request routing and composition
- Authentication and Authorization
- Load balancing
- Rate limiting
- Monitoring
- Caching

I think of it as a reverse proxy with extra responsibilities.

Here's how to build an API gateway in .NET: https://lnkd.in/eH-UtMMT

Architecture testing can help you control technical debt.

Technical debt is the consequence of prioritizing development speed over well-designed code.

With architecture testing, you can control:

- Direction of dependencies
- Naming conventions
- Various design rules

Curious to learn more?

I wrote this in-depth guide that I think you'll enjoy: https://lnkd.in/dE5YMq_n

Your web applications need to serve increasing numbers of users and handle surges in traffic.

When a single server reaches its limits:

- Performance degrades
- Leading to slow response times
- Or even complete downtime

The solution?

Just add more web apps and load balancing.

Load balancing between multiple API servers improves the scalability of your system.

Here's how you can introduce a load balancer in .NET: https://lnkd.in/eTiT4fNR

Taplio

Milan Jovanović's Linkedin Analytics

Who is engaging with Milan

's Best Posts (last 30 days)

Want to drive more opportunities from LinkedIn?

Taplio

.css-1jgreyo{background-image:linear-gradient(284deg, rgba(39,43,72,1) 0%, rgba(33,47,183,1) 100%);color:transparent;-webkit-background-clip:text;background-clip:text;}Milan Jovanović's Linkedin Analytics

Who is engaging with Milan

's Best Posts .css-qqfgvy{font-size:var(--chakra-fontSizes-md);}(last 30 days)

Want to drive more opportunities from LinkedIn?

Milan Jovanović's Linkedin Analytics

's Best Posts (last 30 days)