The .NET Weekly Newsletter: A Simple Guide to Staying Current

Why keeping up feels hard

.NET moves fast. Every year there is a new version. .NET 10 is the current long-term support (LTS) release, C# 14 has shipped, and C# 15 with its new union types is already in the .NET 11 preview. Libraries change too. Some popular ones, like MediatR, MassTransit, and AutoMapper, even switched to commercial licenses. If you blink, you miss something.

Trying to learn it all at once is a bad idea. Your brain gets full. You feel behind. You give up.

There is a better way. You learn a little bit, every week, on purpose. A good newsletter does this for you. The best one for .NET developers is The .NET Weekly by Milan Jovanovic. This guide shows you how to use it, and other newsletters, to stay sharp without burning out.

A real-life analogy: brushing your teeth

Think about brushing your teeth. You do not brush for three hours once a year. That would be silly, and your teeth would still rot. Instead, you brush for two minutes, twice a day. Small effort. Big result over time.

Learning .NET works the same way. You do not need a giant weekend of study. You need a small, steady habit. One newsletter issue a week is your two-minute brush. It keeps your skills clean and healthy. Miss one and nothing breaks. Do it for a year and you are far ahead of where you started.

What is The .NET Weekly?

The .NET Weekly is a free email newsletter written by Milan Jovanovic, a Microsoft MVP. It lands in your inbox every Saturday. Each issue gives you one practical tip about .NET or software architecture. Just one. That is the secret. It is small enough to actually read.

The newsletter started small and grew to over 70,000 readers. People stay because the tips are real. They are things you can use at your job on Monday, not just theory.

You sign up at milanjovanovic.tech. You type your email. That is it. From then on, one useful idea arrives each week.

Why a weekly habit helps

A weekly rhythm beats random reading for three reasons.

First, it is small. One topic per week will not flood your brain. You can finish it and feel good.

Second, it is regular. The email shows up on the same day. Your brain starts to expect it. Habits that repeat on a schedule stick much better than ones you have to remember.

Third, it compounds. One tip a week is 52 tips a year. Each one is a tiny brick. Stack 52 bricks and you have built a wall of real knowledge.

What topics it covers

The .NET Weekly is not random. It keeps coming back to the same strong themes. These are the topics that matter most for building real software. Let us walk through the big four.

Architecture

Architecture is the shape of your whole app. Where does each piece live? How do the parts connect? Milan writes a lot about this. He covers Clean Architecture, Vertical Slice Architecture, the Modular Monolith, and Domain-Driven Design.

Here is a tiny taste. A common pattern he teaches is the value object, which wraps a raw value so it cannot be wrong.

public record Email
{
    public string Value { get; }
 
    public Email(string value)
    {
        if (!value.Contains('@'))
        {
            throw new ArgumentException("Email must contain @");
        }
 
        Value = value;
    }
}

Now you can never pass a broken email around your app. The type protects you. If you want to go deeper, our article on Clean Architecture folder structure pairs nicely with these issues.

EF Core

EF Core is the tool .NET uses to talk to a database. Milan shares many tips to make it faster and safer. A classic one is fixing the slow "N+1" problem with eager loading.

// Slow: one query for orders, then one per customer
var orders = await db.Orders.ToListAsync();
 
// Fast: load orders and customers together
var orders = await db.Orders
    .Include(o => o.Customer)
    .ToListAsync();

That one word, Include, can turn 101 database trips into one. Issues like this save real money on real servers.

Messaging

Big apps are split into smaller services. Those services need to talk. Messaging is how they send notes to each other without waiting around. Milan covers patterns like the Outbox, events, and queues.

The idea is simple. Instead of calling another service right away and hoping it answers, you drop a message in a box. The other service picks it up when ready. If something is down, the message waits. Nothing is lost.

Testing

Testing is how you prove your code works. Without tests, every change is scary. Milan shows how to write tests that are clear and fast. A simple unit test in .NET looks like this.

[Fact]
public void Email_With_No_At_Sign_Throws()
{
    Action create = () => new Email("not-an-email");
 
    Assert.Throws<ArgumentException>(create);
}

Short. Clear. It checks one thing. Good newsletters keep reminding you to write tests like this, until it becomes a habit.

How to apply each issue

Reading is not learning. Doing is learning. The magic of a newsletter only works if you act on it. Here is a simple loop to follow for every issue.

Step 1: Read it the day it arrives. Do not let it pile up. An inbox with 30 unread issues is a guilt machine. Read one, then delete or archive it.

Step 2: Try the idea in code. Open a small test project. Type the example by hand. Do not copy and paste. Your fingers learn what your eyes skip.

Step 3: Write one note. Keep a simple file called learnings.md. After each issue, write one line: "EF Core Include fixes N+1." Future you will thank present you.

Step 4: Share it. Tell a coworker at lunch. Teaching something tiny locks it into your memory. It also makes your team a little smarter.

You do not have to do all four steps every week. Even doing step one and step two is huge. The goal is steady motion, not perfection.

The book, docs, and course tip

Newsletters point you to deeper sources. When an issue mentions a book chapter, the official docs, or one of Milan's courses, those usually come with small example snippets too. Treat those snippets the same way. Type them out.

For example, a docs-style snippet on the Options pattern teaches you to bind settings cleanly.

builder.Services
    .Configure<EmailSettings>(
        builder.Configuration.GetSection("Email"));
 
// Later, inject it where you need it
public class EmailSender(IOptions<EmailSettings> options)
{
    private readonly EmailSettings _settings = options.Value;
}

Small snippets like this are the whole point. They are bite-sized. You can try them in minutes. That is why newsletter learning sticks while giant tutorials do not.

Other good .NET newsletters

The .NET Weekly is our top pick, but it is not the only good one. Reading two or three is plenty. More than that and you drown. Here is a short, honest list.

A simple plan: pick The .NET Weekly for depth, and one roundup like ASP.NET Core News or The Morning Dew for breadth. That gives you both a deep tip and a wide view, without inbox overload.

How it fits with the rest of your learning

A newsletter is one part of a healthy diet. It is the steady snack. You still want bigger meals sometimes: a full book, a video course, the official docs. Think of it like this.

The newsletter often tells you which book or doc to go read next. That is its quiet superpower. It is a map, not just a meal.

A gentle word on hype

Not every new thing is worth chasing. Some libraries change a lot. Some, like MediatR, MassTransit, and AutoMapper, recently moved to commercial licenses, which surprised many teams. A good newsletter helps you tell real signal from loud noise. Milan often explains why a change matters and whether you should care yet. That judgment is worth more than the news itself.

So do not panic when you see a shiny new tool. Read calmly. Ask: does this solve a problem I actually have? Often the answer is "not yet," and that is fine.

A simple weekly routine you can copy

If you like rules, here is a tiny one you can follow without thinking. Pick a quiet time. Saturday morning works well because that is when the email arrives. Pour a drink. Open the issue. Give it ten honest minutes.

Then ask yourself three short questions. Did I learn one new word? Can I try this in code in under ten minutes? Does this touch a problem I have at work right now? If the answer to any of them is yes, do the four-step loop from earlier. If the answer to all three is no, archive it and move on with no guilt. Not every issue is for you, and that is normal.

Over a month that is four issues. Over a year that is around fifty. You will not remember all of them. But you will remember the ones you tried in code, and those become real skills you carry into every project. That is the whole game: small, steady, hands-on, repeated.

One last tip. Keep your learnings.md file in a place you see often, like your desktop or a pinned tab. When you forget something, you search your own notes first. Half the time the answer is already there, written in your own words. That is the quiet payoff of a weekly habit done for a year.

Quick recap

• Keeping up with .NET is easier with a small weekly habit, like brushing your teeth.
• The .NET Weekly by Milan Jovanovic sends one practical tip every Saturday, for free.
• It focuses on four pillars: architecture, EF Core, messaging, and testing.
• Apply each issue with a loop: read, try the code, write one note, share it.
• Type code by hand. Do not copy and paste. Your fingers learn.
• Read one deep newsletter plus one roundup. More than that and you drown.
• Newsletters are a map. They point you to the books and docs to read next.
• Stay calm about hype. Not every new tool is for you right now.

References and further reading

• The .NET Weekly by Milan Jovanovic — the main newsletter this guide is about.
• Milan Jovanovic's blog — the full archive of past issues.
• ASP.NET Core News — a weekly curated digest of ASP.NET Core links.
• Andrew Lock — .NET Escapades — deep posts on how .NET works under the hood.
• .NET News — a daily, wide digest of the .NET ecosystem.
• Our article on Clean Architecture folder structure.
• Our guide to Vertical Slice Architecture.
• Our explainer on what a Modular Monolith is.