DEV Community: Anton Martyniuk

Getting Started with System Design: 7 Key Decisions

Anton Martyniuk — Tue, 18 Aug 2026 11:49:59 +0000

Most developers learn system design in the wrong way, especially with the help of AI.

They usually study concepts such as load balancing, the CAP theorem, Kafka and Saga.
Something AI can explain.

But knowing the components is not the same as designing a system.

Every real system is the result of a handful of decisions and trade-offs, and each one costs you something.

For example:

Pick strong consistency, and you pay in latency.
Pick a queue, and you pay in debugging across multiple services.
Pick microservices, and you pay in premium operations.

Over the past years, I have built and scaled .NET systems that made every one of these choices, sometimes badly.
This is the short version of what I wish someone had handed me at the start.

In this post, we will explore the 7 decisions every system has to make:

How fresh does this data have to be?
Where should this data live?
Do you buy a bigger machine or more machines?
What do you cache, and where?
Should this be a call or an event?
What happens when more work arrives than you can handle?
How many things do you deploy?

Let's dive in.

How Fresh Does This Data Have To Be?

Most teams answer this once, for the whole system, and then live with the answer for years.
That is the mistake. Freshness is a per-data-type decision.

A payment balance and a product review count do not need the same guarantee.
Treating them the same means you either overpay for the reviews or underprotect the money.

These are the models you are actually choosing between:

Model	What you are promised	Typical use
Strong (linearizable)	Every read sees the latest committed write, from any node.	Bank balances, stock counts, leader election.
Read-after-write	A user always sees their own most recent write.	Your own post appearing in your own feed.
Monotonic reads	Once you see a value, you never see an older one again.	News feeds, where going backward looks broken.
Causal	If A caused B, every reader sees A before B.	Comment threads, chat messages.
Eventual	All replicas converge given enough time and no new writes.	Analytics counters, review totals.

Now the part most articles get wrong.
The CAP theorem says a distributed system can only guarantee two of Consistency, Availability, and Partition tolerance.

That "pick two of three" framing is the part Eric Brewer himself walked back in 2012.
Partition tolerance is not optional because networks fail, and a system that does not tolerate them just falls over.

So the real choice is binary, and only active during a partition.
Either you keep accepting writes and risk divergence (AP), or you refuse writes to protect correctness (CP).
CA databases do not exist in any meaningful sense.

Network partition happens

Can the system
safely guess?

Pick CP
Refuse the request

Pick AP
Answer anyway

Bank ledger
Booking seats
Leader election
Stock counts

Social feed
Shopping cart
DNS
CDN cache

A more honest everyday framing is PACELC:

Partition: choose Availability or Consistency.
Else: choose Latency or Consistency.

When the network is healthy, and it usually is, you trade consistency against latency on every write.
Synchronous quorum costs roughly 1-5 ms per write inside a region and 50-200 ms across regions, and a US East to Europe round trip is 80-100 ms before your code does anything.

CAP only shows up when something is on fire. PACELC is the tax you pay every day.

When you do have to pick a side for a specific piece of data, answer these four questions:

What is the cost of stale data? An old balance leads to a bad decision. An old like count leads to nothing.
What is the cost of downtime? If 30 seconds of unavailability costs thousands in lost sales, lean toward AP.
Can you reconcile later? Merging two shopping carts is easy. Merging two conflicting bank transfers is not.
How long do partitions last? Short ones favour CP. Long multi-region ones favor AP.

Most production systems use both CP for payments, orders, and auth tokens and AP for the catalog, recommendations, and activity tracking.

Once you know how fresh each piece of data must be, the list of databases that can hold it gets much shorter.

👉 Read the full article on my newsletter: https://antondevtips.com/blog/getting-started-with-system-design

How to Set Up Production-Ready Monitoring With ASP.NET Core Health Checks

Anton Martyniuk — Fri, 14 Aug 2026 08:13:52 +0000

Deploying an application to production is only the beginning. You need to know whether your application is healthy and whether your database, cache, and message queue are reachable.

Without proper monitoring, you will only find out about issues when your users start complaining.

I have spent years building and maintaining high-load .NET systems, and health checks have always been my first line of defense. Today, I want to show you how to set up a production-ready monitoring system that gives you complete visibility into your application's health.

In this post, we will explore:

Why health checks matter for production applications
Adding health checks for Postgres, Redis, MongoDB, and RabbitMQ
Building custom health checkers
Building a custom JSON response formatter
Implementing a custom health check publisher
Setting up a professional Health Checks UI

Let's dive in.

Why Health Checks Matter

When you run an application in a modern environment like Kubernetes or Azure, the platform needs to know if your app is ready to handle traffic. This is where health checks come in.

A health check is a simple endpoint that returns the status of your application. If the database or message queue is down, the health check should report that the service is "Unhealthy".

Without health checks:

Load balancers might send traffic to a broken instance.
You won't know about database connection issues until users report errors.
Background tasks might stop running without anyone noticing.

ASP.NET Core provides a built-in framework for health checks. It allows you to check everything from database connections to external APIs and system resources.

👉 Read the full article on my newsletter: https://antondevtips.com/blog/how-to-set-up-production-ready-monitoring-with-aspnetcore-health-checks

REST API Security Best Practices in ASP.NET Core

Anton Martyniuk — Tue, 11 Aug 2026 11:20:09 +0000

It does not matter how clean your architecture is or how fast your queries run - if an attacker can read another user's orders or forge a token, none of that matters.

Most API security problems come from skipping the basics:

Not updated NuGet package with security vulnerability
Missing validation check
Weak authentication setup
An over-permissive CORS policy
A secret committed to source control.

The good news is that ASP .NET Core gives you almost everything you need built in.

Over the years, I have shipped and reviewed many .NET APIs, and the same set of practices keeps them safe.

Here are 18 of them, each with the code to apply it.

In this post, we will explore:

Enforce HTTPS everywhere
Authenticate with tokens, not sessions
Validate the JWT signature, issuer, audience, and lifetime
Authorize with policies, not just [Authorize]
Apply the principle of least privilege
Validate and sanitize all input
Protect against over-posting / mass assignment
Validate content types and limit request size
Use parameterized queries and EF Core
Implement rate limiting and throttling
Configure CORS restrictively
Return minimal error detail
Set security headers
Store secrets securely
Enforce CSRF protection where relevant
Version your API and deprecate insecure endpoints
Log and audit security events
Keep dependencies patched

Let's dive in.

1. Enforce HTTPS Everywhere

Every request to your API should travel over an encrypted connection.

Without HTTPS, tokens, passwords, and personal data move in plain text, where anyone on the network path can read them.
Plain HTTP also opens the door to downgrade attacks, in which an attacker forces a client to use an insecure connection.

ASP .NET Core gives you two tools. UseHttpsRedirection redirects HTTP requests to HTTPS, and HSTS (HTTP Strict Transport Security) tells browsers to only ever connect over HTTPS:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHsts(options =>
{
    options.MaxAge = TimeSpan.FromDays(365);
    options.IncludeSubDomains = true;
    options.Preload = true;
});

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseHsts();
}

app.UseHttpsRedirection();

UseHttpsRedirection upgrades any HTTP request to HTTPS.
UseHsts adds the Strict-Transport-Security header, so compliant browsers refuse to talk to your API over plain HTTP at all - which blocks downgrade attacks.

HSTS is skipped during development because you often use http://localhost.

For the full setup, see Configuring HTTPS Redirection and HSTS in ASP .NET Core.

👉 Read the full article on my newsletter: https://antondevtips.com/blog/rest-api-security-best-practices-in-aspnetcore

How to Start a New .NET Project in 2026

Anton Martyniuk — Fri, 07 Aug 2026 08:16:35 +0000

Starting a new .NET project is exciting, but it can also be overwhelming. There are so many decisions to make, and the choices you make in the first few days will affect your project for months or even years.

I have created dozens of .NET projects over the years, and today I want to share my experience with you.

In this post, we will explore the following essential steps to start a new .NET project:

Set Project-Wide Standards
Add Static Code Analysis Packages
Enforce Coding Standards
Centralize Package Management
Simplify Local Development with Aspire
Setup OpenTelemetry
Automate Build and Testing with GitHub Actions
Project Template to Start With

Let's dive in.

1. Directory.Build.props - Set Project-Wide Standards

Every .NET solution should start with a Directory.Build.props file. This file defines project-wide settings that apply to all projects in your solution.

Without this file, you end up duplicating the same configuration across multiple .csproj files. When you want to change a setting, you have to update every project file manually. This leads to inconsistencies and wasted time.

Directory.Build.props solves this problem by centralizing configuration in one place. You create this file in the same directory as your .sln file, and MSBuild automatically applies it to all projects in the solution.

Here is the configuration I use for every new project:

<Project>
    <PropertyGroup>
        <Nullable>enable</Nullable>
        <ImplicitUsings>enable</ImplicitUsings>
        <AnalysisLevel>latest</AnalysisLevel>
        <AnalysisMode>All</AnalysisMode>
        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
        <CodeAnalysisTreatWarningsAsErrors>true</CodeAnalysisTreatWarningsAsErrors>
        <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
    </PropertyGroup>
</Project>

If needed, you can also put Directory.Build.props on any directory level in your project hierarchy and override settings there.

Here is what each setting does:

Nullable: Enables nullable reference types, which help prevent null reference exceptions. The compiler warns you when you might be using a null value incorrectly.

ImplicitUsings: Automatically includes common namespace imports in every file. You do not need to write using System; or using System.Linq; anymore.

AnalysisLevel: Sets the code analysis level to the latest version. You get the most recent code quality checks from Microsoft.

AnalysisMode: Enables all code analysis rules. This gives you the most comprehensive feedback on code quality.

TreatWarningsAsErrors: Prevents compilation if there are any warnings. This forces you to fix issues immediately rather than letting them accumulate.

CodeAnalysisTreatWarningsAsErrors: Applies the same strict treatment to code analysis warnings.

EnforceCodeStyleInBuild: Runs code style checks during build, not just in the IDE. Your CI/CD pipeline will catch style violations.

These settings create a strong foundation for code quality. They catch issues early and enforce consistency across your entire solution.

👉 Read the full article on my newsletter: https://antondevtips.com/blog/how-to-start-a-new-dotnet-project-in-2026

Azure Event Grid and Event Hubs in .NET: When to Use Each

Anton Martyniuk — Tue, 04 Aug 2026 11:17:42 +0000

Azure offers three services with similar names but very different roles: Service Bus, Event Hubs, and Event Grid.

They all move data between parts of your system, so it is easy to assume they are interchangeable.
They are not.

I have already covered Azure Service Bus in detail - the reliable message broker for commands and workflows between services.

This post covers the other two and then shows you exactly when to reach for each.

In this post, we will explore:

Azure Event Grid: how it works
Using Azure Event Grid in .NET
Azure Event Hubs: how it works
Using Azure Event Hubs in .NET
Service Bus vs Event Hubs vs Event Grid: when to use each

Let's dive in.

Azure Event Grid: How It Works

Azure Event Grid is a fully managed event routing service.

It follows a simple idea: something happens, and Event Grid delivers a notification to everyone who cares.

That "something" is an event - a small message that says a change occurred:

A blob was uploaded
A resource was created
An order was placed.

Event Grid does not store your data or run your logic.
It takes events from publishers and pushes them to subscribers, fast and at scale.

Azure Event Grid consists of four parts:

Publishers - where events come from. Azure services like Blob Storage and Resource Groups emit system events automatically. Your own application publishes custom events to a custom topic.
Topic - the endpoint events are sent to. A system topic for Azure events, or a custom topic for your own.
Event subscriptions - the rules that connect a topic to a handler. Each subscription can be filtered by event type or subject, so a handler receives only the events it requested.
Event handlers - where events are delivered: an HTTP webhook, an Azure Function, a Service Bus queue, an Event Hub, and more.

How Event Grid Differs from Service Bus

The key difference is push versus pull.

Service Bus is a broker you pull from: your consumer connects, locks a message, processes it, and completes it. The consumer controls the pace.

Event Grid pushes: when an event occurs, Event Grid makes an HTTP call to your handler. You do not poll - you expose an endpoint and wait to be called.

A few more differences matter:

Reactive notifications, not message transport. An Event Grid event is a lightweight signal ("blob X was created"), not a payload meant to carry megabytes of data. Service Bus messages can carry the full payload your consumer needs.
No ordering, no sessions. Event Grid does not guarantee order. Service Bus offers FIFO ordering through sessions.
Retries and dead-lettering work differently. Event Grid retries a failed HTTP delivery with backoff for up to 24 hours, then dead-letters to a Storage account you configure. Service Bus has a built-in dead-letter sub-queue on every queue and subscription.
Serverless and pay-per-event. Event Grid has no namespace to provision or scale - you pay per operation. Service Bus runs in a provisioned namespace.

Use Event Grid when you want many parts of your system to react to something that happened, especially Azure resource changes.

👉 Read the full article on my newsletter: https://antondevtips.com/blog/azure-event-grid-and-event-hubs-in-dotnet

Getting Started With .NET Aspire 13: Building and Deploying an App With PostgreSQL, Redis, and Docker Compose

Anton Martyniuk — Fri, 31 Jul 2026 15:39:47 +0000

.NET Aspire is an application framework for building observable, production-ready, cloud-native applications with .NET.
It provides a consistent way to manage your application's dependencies, configuration, and deployment.

Think of Aspire as a layer that sits on top of your application and orchestrates how everything works together.
It handles service discovery, configuration, health checks, and telemetry out of the box.

Starting from version 13, .NET Aspire was rebranded to Aspire and is now a multi-language application platform.

While Aspire continues to provide best-in-class support for .NET applications, version 13.0 brings support for Python and JavaScript.
It provides comprehensive support for running, debugging, and deploying applications written in these languages.

Today, I want to show you how to build and run a .NET application with Aspire 13 and .NET 10.

In this post, we will explore:

Getting Started with Aspire 13
Configuring PostgreSQL and Redis in Aspire
Exploring Aspire Dashboard
Configuring OpenTelemetry
Deploying Aspire Application to Docker Compose

Let's dive in.

Getting Started with Aspire 13

I have built a product API that has the following integrations:

PostgreSQL database
HybridCache with Redis

To add Aspire to your project, we need to do the following steps:

Step 1:

Install the Aspire project templates:

dotnet new install Aspire.ProjectTemplates

Step 2:

Install the Aspire CLI:

dotnet tool install --global aspire.cli

Step 3:

Add the Aspire support for the Products.Api project in Visual Studio or Rider:

Aspire introduces two new project types to your solution:

AppHost: The orchestrator that defines your application's architecture and dependencies.
ServiceDefaults: Shared configuration and observability setup applied to all services.

By default, the AppHost project has the entry file name AppHost.cs with the following content:

var builder = DistributedApplication.CreateBuilder(args);

builder
    .AddProject<Projects.Products_Api>("products-api");

builder.Build().Run();

The only dependency declared in the AppHost project is Products.Api, which contains our Web API.

Step 4:

Install the following NuGet packages in the AppHost project:

dotnet add package Aspire.Hosting.PostgreSQL
dotnet add package Aspire.Hosting.Redis

Step 5:

Configure all the dependencies in the AppHost.cs:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddRedis("cache");

var postgres = builder.AddPostgres("postgres");

builder
    .AddProject<Projects.Products_Api>("products-api")
    .WithReference(cache)
    .WithReference(postgres);

builder.Build().Run();

The WithReference(cache) and WithReference(postgres) methods inject connection strings for Redis and PostgreSQL into the API project.
Aspire automatically sets environment variables that the API can read to connect to these resources.

Step 6:

Configure the connection strings in the Products.Api project to connect to the PostgreSQL database:

using Microsoft.EntityFrameworkCore;
using Products.Domain.Products;
using Products.Infrastructure.Database;
using Products.Infrastructure.Repositories;

namespace Microsoft.Extensions.DependencyInjection;

public static class HostDiExtensions
{
    private static IServiceCollection AddEfCore(
        this IServiceCollection services, 
        IConfiguration configuration)
    {
        var connectionString = configuration.GetConnectionString("postgres");

        services.AddDbContext<ProductDbContext>((_, options) =>
        {
            options.UseNpgsql(connectionString);
        });

        return services;
    }
}

The key part is configuration.GetConnectionString("postgres"). This reads the connection string that Aspire injected when we called WithReference(postgres) in AppHost.cs.
Aspire automatically sets an environment variable with the PostgreSQL connection string, and the configuration system reads it.

This way, you don't need to hardcode connection strings in appsettings.json or your own environment variables.

In this project, I use the regular EF Core NuGet packages for Npgsql:

Microsoft.EntityFrameworkCore 10.0.0
Microsoft.EntityFrameworkCore.Design 10.0.0
Npgsql.EntityFrameworkCore.PostgreSQL 10.0.0

Step 7:

Configure the connection string in the Products.Api project to connect to the Redis cache:

public static IServiceCollection AddWebHostInfrastructure(
    this IServiceCollection services, 
    IConfiguration configuration)
{
    services.AddHybridCache(options =>
    {
        options.DefaultEntryOptions = new HybridCacheEntryOptions
        {
            Expiration = TimeSpan.FromMinutes(10),
            LocalCacheExpiration = TimeSpan.FromMinutes(10)
        };
    });

    return services;
}

private static IServiceCollection AddRedis(
    this IServiceCollection services, 
    IConfiguration configuration)
{
    var redisConnectionString = configuration.GetConnectionString("cache")!;

    services.AddMemoryCache();

    services
        .AddStackExchangeRedisCache(options =>
        {
            options.Configuration = redisConnectionString;
        });

    return services;
}

The AddHybridCache method registers HybridCache with default expiration settings.
The AddRedis method registers StackExchangeRedisCache as the L2 cache.

Just like with PostgreSQL, Aspire injects the Redis connection string via configuration.GetConnectionString("cache").

In this project, I use the following NuGet packages for Redis cache:

Microsoft.Extensions.Caching.Hybrid 10.1.0
Microsoft.Extensions.Caching.StackExchangeRedis 10.0.1

Step 8:

Let's run our application locally with Visual Studio or Rider:

Aspire dashboard

The Aspire dashboard opens automatically in your web browser (the port may vary). The dashboard shows:

Resources - All running services (postgres, cache, products-api)
Console logs - Real-time logs from each service
Structured logs - Filterable and searchable logs
Traces - Distributed traces across services
Metrics - Performance metrics and health checks

The first run may take a few minutes while Docker pulls the container images. Subsequent runs will be much faster.

The dashboard shows all running services, their health status, logs, and distributed traces.

👉 Read the full article on my newsletter: https://antondevtips.com/blog/getting-started-with-dotnet-aspire-13-building-and-deploying-an-app

Github Actions for .NET: Build, Test, and Ship With Docker

Anton Martyniuk — Tue, 28 Jul 2026 11:11:56 +0000

You just pushed your code, and now you wait.

Did the build pass? Did the tests run? Is the Docker image ready to ship?

If you are checking these by hand, you are doing work a machine should do for you.

A good CI/CD pipeline builds, tests, and ships every change the same way, every time - without you babysitting it.

Over the years, I have set up these pipelines for many .NET projects, and GitHub Actions has become my default.

It lives right next to your code, it is free for most projects, and it can take a single commit all the way from a pull request to a published Docker image.

In this post, we will explore:

What are GitHub Actions
Building and testing your .NET app
Publishing a NuGet package after tests pass
Building a Docker image that runs tests
Setting up secrets in GitHub Actions
Pushing the Docker image to the registry

Let's dive in.

What Are GitHub Actions?

GitHub Actions is a built-in automation platform inside every GitHub repository.

You describe what should happen when something occurs in your repository - a push, a pull request, a new tag, a schedule or manual - and GitHub runs it for you on a fresh virtual machine.

You need to know these terms to be able to read any workflow:

Workflow: an automated process defined in a YAML file under .github/workflows. A repository can have many.
Event: what triggers a workflow - a push, a pull_request, a release, or a schedule.
Job: a group of steps that runs on one machine. Jobs run in parallel by default, or in order when one needs another.
Step: a single task - either a shell command (run) or a reusable action (uses).
Runner: the machine that executes a job. GitHub hosts Linux, Windows, and macOS runners, and you can host your own.

Any workflow in GitHub Actions is a series of steps that run on a virtual machine.

With these, you can automate almost anything related to your code: run tests on every pull request, publish a NuGet package with a new release, build and push a Docker image, run a nightly security scan, or post a message to Slack.

Because a workflow is just a file in your repository, it is versioned with your code and reviewed in pull requests like everything else. The pipeline evolves together with the application it builds.

Every workflow is a single YAML file. Here is the smallest one that does real work - it runs on each push to main and prints a line on an Ubuntu runner:

name: HELLO

on:
  push:
    branches: [ "main" ]

jobs:
  hello:
    runs-on: ubuntu-latest
    steps:
      - run: echo "GitHub Actions is running"

Save this as .github/workflows/hello.yml, push it, and open the Actions tab in your repository to watch it run.

👉 Read the full article on my newsletter: https://antondevtips.com/blog/github-actions-for-dotnet-build-test-and-ship-with-docker

Why Every EF Core Developer Needs to Try Entity Framework Extensions

Anton Martyniuk — Fri, 24 Jul 2026 08:21:37 +0000

When building data-intensive applications with Entity Framework Core, you will eventually face a critical performance challenge: inserting, updating, or deleting thousands of records efficiently.

The standard EF Core approach using SaveChanges() works perfectly for small datasets or even a few hundred rows, but it becomes a significant bottleneck when you need to process thousands of records.

There is a better solution: Entity Framework Extensions provides high-performance bulk operations that can process thousands of records in less than a second. You still use the same code you have in EF Core with a new set of DbContext extension methods.

In this post, we will explore:

Why inserting 10,000+ rows with EF Core quickly becomes a performance bottleneck
What happens under the hood when you call SaveChanges() and why it slows down at scale
How Entity Framework Extensions solve bulk data problems without rewriting your EF Core code
How to import data at scale using BulkInsert to insert thousands of records in a single operation
How to apply mass updates with BulkUpdate to efficiently modify large datasets
How to clean up data with BulkDelete to remove large volumes of records in one database round-trip
How to perform upserts and sync external systems using BulkMerge with minimal code
How to run full data synchronization jobs using BulkSynchronize to keep databases in sync reliably

Let's dive in.

Why Inserting 10,000+ Rows with EF Core Becomes a Performance Bottleneck

You are building an IoT platform that collects telemetry data from thousands of devices every minute. Each device sends temperature readings, humidity levels, and status updates.

Your system needs to insert 50,000 telemetry records into the database every few minutes.

You start with the standard Entity Framework Core approach:

app.MapPost("/telemetries", async (IotDbContext dbContext, InsertTelemetryRequest request) =>
{
   var telemetryEntries = request.MapToTelemetryEntries();

   dbContext.Telemetries.AddRange(telemetryEntries);
   await dbContext.SaveChangesAsync();

   return Results.Ok();
});

Using the standard SaveChanges() approach, this operation could take several seconds or even minutes and consume excessive memory. This is a common problem when working with Entity Framework Core at scale.

EF Core is excellent for typical CRUD operations, but it was not designed for bulk data operations. When you need to insert, update, or delete thousands of records, the standard SaveChanges() method becomes a performance bottleneck.

Entity Framework Extensions is a library that solves this problem. It extends EF Core with high-performance bulk operations that can handle large datasets efficiently.

All examples in this post were tested on a SQL Server database using the IoT telemetry application.

👉 Read the full article on my newsletter: https://antondevtips.com/blog/why-every-ef-core-developer-needs-to-try-entity-framework-extensions

10 Reasons to Upgrade to .NET 10

Anton Martyniuk — Thu, 23 Jul 2026 20:21:58 +0000

.NET 10 and C# 14 were released on November 11, 2025.

Today, I want to show 10 reasons why you should consider upgrading your projects to .NET 10.

1. Long-Term Support (LTS) Release

Here is a lifecycle for the currently supported .NET versions:

.NET 10

Release date: November 11, 2025
Release type: LTS
End of support: November 14, 2028

.NET 9

Release date: November 12, 2024
Release type: STS
End of support: November 10, 2026

.NET 8

Release date: November 14, 2023
Release type: LTS
End of support: November 10, 2026

As a Long-Term Support (LTS) release, .NET 10 will receive three years of support until November 14, 2028.
This makes it a solid choice for production applications that need long-term stability.

Support for .NET 8 ends on November 10, 2026, so you should consider upgrading to .NET 10 as soon as possible.

👉 Read the full article on my newsletter: https://antondevtips.com/blog/10-reasons-to-upgrade-to-dotnet-10

Top 10 Things Every .NET Developer Needs to Do in 2026

Anton Martyniuk — Thu, 23 Jul 2026 18:42:31 +0000

I have been working with .NET since .NET Framework 3.5, and I have learned that staying ahead means adopting the right tools and practices at the right time. In this post, I want to share 10 actionable steps that will help you grow as a .NET developer in 2026.

These are practices I follow myself and recommend to every developer I work with.

Let's dive in.

1. Migrate Your Existing Projects to .NET 10

.NET 10 and C# 14 were released on November 11, 2025.

As a Long-Term Support (LTS) release, .NET 10 will receive three years of support until November 14, 2028. This makes it a solid choice for production applications that need long-term stability.

Here are the most amazing new features in this release:

C# 14:

Extension Members
Null-Conditional Assignment
The Field Keyword
Lambda Parameters with Modifiers
Partial Constructors and Events

File-Based Apps:

Starting with .NET 10, you can create a single *.cs file and run it directly, without solution file (sln) and project file (csproj).

ASP.NET Core:

Validation Support in Minimal APIs
JSON Patch Support in Minimal APIs
Server-Sent Events (SSE)
OpenAPI 3.1 Support

EF Core:

Optional Complex Types
JSON and struct Support for Complex Types
LeftJoin and RightJoin Operators
Named Query Filters
ExecuteUpdate for JSON Columns
Regular Lambdas in ExecuteUpdate

Here is a list of resources to help you migrate your existing projects to .NET 10:

My in-depth article on the new features.
Breaking changes in .NET 10
How Migrate from ASP.NET Core in .NET 9 to ASP.NET Core in .NET 10
.NET Upgrade Assistant

It's a good time to start migrating your projects to .NET 10 in 2026.

👉 Read the full article on my newsletter: https://antondevtips.com/blog/top-10-things-every-dotnet-developer-needs-to-do-in-2026

Named Global Query Filters Were Updated in EF Core 10

Anton Martyniuk — Mon, 20 Jul 2026 19:41:09 +0000

Global query filters in Entity Framework Core (EF Core) is a powerful feature that can be effectively used to manage data access patterns.

Global query filters are LINQ query predicates applied to EF Core entity models. These filters are automatically applied to all queries that involve the corresponding entities. This is especially useful in multi-tenant applications or scenarios requiring soft deletion.

In EF Core 10, Global Query Filters were renamed to Named Query Filters.

This update now solves a significant limitation EF Core previously had: support for multiple global query filters on a single entity.

In this post, we will explore:

Query Filters for a Soft Delete use case
Query Filters for a Multi-Tenant application
Named Query Filters

Let's dive in.

Query filters for a soft delete use case

Let's explore a use case where global query filters are particularly useful — entity soft deletion. In some applications, entities can't be completely deleted from the database and should remain for statistics and historical purposes. Or to ensure that related data remains unchanged, i.e, referenced by foreign keys. A solution for this use case is soft deletion.

Soft deletion is implemented by adding an is_deleted column to the database table for required entities. Whenever an entity is considered deleted, this column is set to true. In most application database queries, "deleted" entities should be ignored in read operations and not be visible to end users.

Let's explore an example for the following entities:

public class Author
{
    public required Guid Id { get; set; }
    public required string Name { get; set; }
    public required string Country { get; set; }
    public required List<Book> Books { get; set; } = [];
}

public class Book
{
    public required Guid Id { get; set; }
    public required string Title { get; set; }
    public required int Year { get; set; }
    public required bool IsDeleted { get; set; }
    public required Guid TenantId { get; set; }
    public required Author Author { get; set; }
}

We need to create and set up our DbContext with a global query filter:

public class ApplicationDbContext : DbContext
{
    public DbSet<Author> Authors { get; set; } = default!;

    public DbSet<Book> Books { get; set; } = default!;

    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
    {
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Book>()
            .HasQueryFilter(x => !x.IsDeleted);

        base.OnModelCreating(modelBuilder);

        modelBuilder.Entity<Author>(entity =>
        {
            entity.ToTable("authors");

            entity.HasKey(x => x.Id);
            entity.HasIndex(x => x.Name);

            entity.Property(x => x.Id).IsRequired();
            entity.Property(x => x.Name).IsRequired();
            entity.Property(x => x.Country).IsRequired();

            entity.HasMany(x => x.Books)
                .WithOne(x => x.Author);
        });

        modelBuilder.Entity<Book>(entity =>
        {
            entity.ToTable("books");

            entity.HasKey(x => x.Id);
            entity.HasIndex(x => x.Title);

            entity.Property(x => x.Id).IsRequired();
            entity.Property(x => x.Title).IsRequired();
            entity.Property(x => x.Year).IsRequired();
            entity.Property(x => x.IsDeleted).IsRequired();

            entity.HasOne(x => x.Author)
                .WithMany(x => x.Books);
        });
    }
}

In this code, we're applying a query filter to the Book entity on the IsDeleted property:

modelBuilder.Entity<Book>()
    .HasQueryFilter(x => !x.IsDeleted);

Here we are filtering out all softly deleted books from the result query. When querying books from DbContext, this query filter is applied automatically. Let's have a look at the following minimal API endpoint:

app.MapGet("/api/books", async (ApplicationDbContext dbContext) =>
{
    var nonDeletedBooks = await dbContext.Books.ToListAsync();
    return Results.Ok(nonDeletedBooks);
});

Every time we query books, we only get those that are not deleted, thus we don't need to use a LINQ Where statement in all DbContext queries.

In some cases, however, we might need to access all entities and ignore the query filter. EF Core has a special method called IgnoreQueryFilters for such a case:

app.MapGet("/api/all-books", async (ApplicationDbContext dbContext) =>
{
    var allBooks = await dbContext.Books
        .IgnoreQueryFilters()
        .Where(x => x.IsDeleted)
        .ToListAsync();

    return Results.Ok(allBooks);
});

That way, all the books are retrieved from the database, and the query filter on the Book entity is completely ignored.

👉 Read the full article on my newsletter: https://antondevtips.com/blog/named-global-query-filters-were-updated-in-ef-core-10

How to Build a Production-Ready Invoice Builder in .NET Using IronPDF

Anton Martyniuk — Sat, 06 Dec 2025 19:09:17 +0000

Today, I want to show you how to build a production-ready invoice builder application.

We will build an app that helps clients create, manage, and download invoices from business data.
It turns orders and customer records into branded documents with accurate taxes, totals, and payment terms, and provides users with clear actions, such as previews and PDF downloads.

In production, it must be reliable and consistent, and produce PDFs that are easy to store and easy to read on any device.

Invoice Builder requirements

Business requirements:

Create Invoice Customers and Senders
Create Invoices: Invoice & Date details, existing Customer and Sender data, line items
Generate and download Invoice PDF files

PDF requirements:

Consistent layout at any length: a single item or hundreds of rows should paginate cleanly.
Accurate rendering and stable formatting on any device.
High-quality rendering with crisp text, logos, and tables suitable for printing or archiving.
PDF/UA compliance for long-term storage and audit needs.
Digital signatures to prove integrity and origin, with an optional visible signature appearance.
Fully managed, cross-platform runtime with fast generation and small operational overhead.

UI Features:

Home Screen:
- Tabs: Invoices, Customers, Senders
Invoices:
- List paged invoices in a table view
- Create new invoices
- Table actions: View, Edit, Delete (with confirmation), Download PDF
Customers:
- List paged customers in a table view
- Create new customers
- Table actions: View, Edit, Delete (with confirmation)
Senders:
- List paged senders in a table view
- Create new senders
- Table actions: View, Edit, Delete (with confirmation)

Implementation Tech Stack:

Backend:

ASP .NET Core 10, EF Core, IronPDF for generating PDFs

Frontend:

React, TypeScript, TailwindCSS

Architecture:

Modular Monolith
Vertical Slice Architecture + Clean Architecture

Database:

PostgreSQL

Deployment:

Docker Compose

Let's dive into the implementation details.

Invoice Builder UI Overview

To better understand how the Invoice Builder app works, let's take a look at the UI screens.

Here is the Home Screen with Invoices, Customers, and Senders tabs:

The Invoices tab shows a list of invoices with actions such as View, Edit, Delete, and Download PDF.

To create a new invoice, we need to create a Customer and a Sender first.

Now we can create an invoice. We need to fill the following fields:

Invoice Details (Number, Dates, Tax Rate, Notes, etc.)
Sender Info
Customer Info
Line Items

We need to select a Customer and Sender from the dropdowns.

After we click "Create Invoice", the invoice is created and stored in the database.

You can download the PDF file by clicking the "Download PDF" button on the invoice details page or the Invoices list page.

Now, let's explore the options we have for generating the PDF file.

Selecting C# PDF Library for Invoice Generation

There are multiple options for generating PDFs in C# and ASP.NET Core:

IronPDF
QuestPDF
Aspose.PDF
PuppeteerSharp

Let's briefly explore each of them and compare their pros and cons.

IronPDF

IronPDF is a powerful .NET library for creating, editing, signing, and rendering PDFs.
It is designed to be developer-friendly: many complex tasks in raw PDF APIs or lower-level tools are easier with IronPDF via a more fluent, higher-level API.

IronPDF pros:

HTML, DOCX, RTF, XML, MD, Image to PDF Conversion
PDF FROM URL, PDF to HTML
Compliant to PDF/A, PDF/UA, and PDF/X standards
Fully managed and cross-platform
High-performance rendering
Digital Signatures & Security
Rich PDF Manipulation (edit, merge, split PDFs)
Good documentation

IronPDF cons:

Requires a paid license for commercial use.

QuestPDF

QuestPDF is a popular open-source PDF generation library for .NET developers.
Its primary goal is to simplify PDF creation through a C# fluent API.

QuestPDF pros:

Fluent C# API — build documents directly in code using a layout-based approach.
Consistent layouts — predictable, repeatable output for structured documents.
Good documentation with many examples and patterns for reports.
Free for commercial use for small companies.

QuestPDF cons:

Missing HTML-to-PDF conversion — unable to convert HTML content directly into PDFs, limiting versatility in web applications.
Missing Compliance standards — no built-in support for PDF/A (archival) or PDF/UA (accessibility).
Missing Digital signatures or security — no native features for signing, password protection, or permissions.
Missing Interactive forms or JavaScript rendering — limited scope to static layouts only.
Requires a paid license for commercial use for larger companies.

Aspose.PDF

Aspose.PDF provides advanced capabilities for programmatic PDF creation.
It gives developers extensive control over document elements, including paragraphs, tables, images, forms, and annotations.

Aspose.PDF pros:

Extensive programmatic control over PDF elements (paragraphs, tables, images, forms, annotations).
Advanced PDF manipulation features for complex document workflows.
Support for PDF/A standards and digital signatures.
Mature library with a long track record in enterprise environments.

Aspose.PDF cons:

Verbose API requiring detailed coding even for simple tasks, leading to a steeper learning curve.
Limited HTML-to-PDF conversion — lacks native Chromium engine, resulting in rendering limitations.
No JavaScript execution support for dynamic content rendering.
Slower performance and higher memory usage compared to Chromium-based alternatives (like IronPDF).
Expensive licensing with higher pricing tiers compared to competitors.

PuppeteerSharp

Puppeteer Sharp is a .NET port of the official Node.js Puppeteer API.

It lets you drive Chromium/Chrome from C# over the DevTools Protocol:
open pages, run JavaScript, wait for selectors, take screenshots, and print pages to PDF.

It runs headless by default and can also connect to a remote browser.

PuppeteerSharp pros:

Easy API to create PDFs using Chrome Engine
Open-source and free for commercial use

PuppeteerSharp cons:

Puppeteer-Sharp is a browser automation library, and not a .NET-native PDF SDK. While it excels at rendering HTML into PDFs, it is not a full-featured .NET PDF SDK.
Missing Compliance standards — no built-in support for PDF/A (archival) or PDF/UA (accessibility).
Missing Digital signatures or security — no native features for signing, password protection, or permissions.
Missing PDF editing — no tools for merging, splitting, or modifying existing PDFs.

Why IronPDF is the Best Choice for Invoice Builder Application

I have personally tested all the libraries, and my preferred choice for commercial projects is IronPDF.

For an invoice builder application, it's a perfect choice because it meets all our requirements:

Consistent layout at any length: a single item or hundreds of rows should paginate cleanly.
Accurate rendering and stable formatting on any device.
High-quality rendering with crisp text, logos, and tables suitable for printing or archiving.
PDF/A-3b compliance for long-term storage and audit needs.
Digital signatures to prove integrity and origin, with an optional visible signature appearance.
Fully managed, cross-platform runtime with fast generation and small operational overhead.

QuestPDF and PuppeteerSharp don't meet these requirements.

Aspose can be an alternative, but IronPDF is better in HTML-to-PDF conversion, is faster and uses less memory.
Also, IronPDF offers a license at a much more affordable price.

Now let's explore how we can generate the invoice PDF file on the backend, using IronPDF.

Generating Invoice PDFs with IronPDF

IronPDF has a quick learning curve, just 5 minutes from getting started to generating the first PDF.

First, you need to install the following NuGet package:

dotnet add package IronPdf

With IronPDF, you can create a PDF document from HTML content in just three lines of code:

using IronPdf;

var htmlContent = @"
<html>
<head>
    <style>
        h1 { color: blue; }
        p { font-size: 16px; }
    </style>
</head>
<body>
    <h1>Invoice 1000471</h1>
    <p>Test invoice</p>
</body>
</html>";

// Create a PDF from HTML content
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("Invoice.pdf");

Creating PDF documents from HTML content is pretty easy.
But how can we quickly generate a rich, professional-looking HTML invoice document in ASP.NET Core?

For this purpose, we can use Razor views.
They are used in ASP.NET Core MVC, Razor Pages and Blazor applications.

Razor views have a .cshtml extension and allow you to use C# inside the HTML markup.

Let's build the Invoice PDF document using Razor views.

You need to install the additional NuGet package:

dotnet add package Razor.Templating.Core

Razor.Templating.Core package allows you to use Razor views in any assembly, even in a class library, so you don't need to create an ASP.NET Core MVC application.

Here is our set of Invoice models:

public sealed record InvoiceResponse(
    Guid Id,
    string InvoiceNumber,
    DateTime InvoiceDate,
    DateTime DueDate,
    string Currency,
    string Notes,
    CustomerResponse Customer,
    SenderResponse Sender,
    List<InvoiceLineItemResponse> LineItems,
    decimal Subtotal,
    decimal TaxRate,
    decimal TotalAmount
);

public sealed record CustomerResponse(
    Guid Id,
    string CompanyName,
    string CustomerName,
    string CustomerAddress,
    string PostalCode,
    string CustomerEmail,
    string CustomerTaxVatId
);

public sealed record SenderResponse(
    Guid Id,
    string SenderCompanyName,
    string SenderFullName,
    string SenderAddress,
    string SenderTaxVatId,
    string BankDetails
);

public sealed record InvoiceLineItemResponse(
    Guid Id,
    string ItemName,
    decimal Quantity,
    decimal UnitPrice,
    decimal Total
);

For styling, we can use Tailwind CSS, which simplifies CSS and makes it easier to create responsive layouts.

Let's create an InvoiceTemplate.cshtml file in the Views folder:

@model Modules.Invoices.Features.Features.Shared.Responses.InvoiceResponse

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Invoice @Model.InvoiceNumber</title>
    <script src="https://cdn.tailwindcss.com"></script>
</head>
<body class="bg-white">
    <div class="max-w-4xl mx-auto p-8">
        <!-- Header -->
        <div class="flex justify-between items-start mb-8">
            <div>
                <h1 class="text-4xl font-bold text-gray-900 mb-2">INVOICE</h1>
                <p class="text-lg text-gray-600">@Model.InvoiceNumber</p>
            </div>
            <div class="text-right">
                <p class="text-sm text-gray-600">Invoice Date</p>
                <p class="text-lg font-semibold text-gray-900">@Model.InvoiceDate.ToString("MMM dd, yyyy", System.Globalization.CultureInfo.InvariantCulture)</p>
                <p class="text-sm text-gray-600 mt-2">Due Date</p>
                <p class="text-lg font-semibold text-red-600">@Model.DueDate.ToString("MMM dd, yyyy", System.Globalization.CultureInfo.InvariantCulture)</p>
            </div>
        </div>

        <!-- Sender and Customer Information -->
        <div class="grid grid-cols-2 gap-8 mb-8">
            <!-- From (Sender) -->
            <div class="bg-gray-50 p-6 rounded-lg">
                <h2 class="text-sm font-semibold text-gray-500 uppercase mb-3">From</h2>
                <div class="space-y-1">
                    <p class="text-lg font-bold text-gray-900">@Model.Sender.SenderCompanyName</p>
                    <p class="text-gray-700">@Model.Sender.SenderFullName</p>
                    <p class="text-gray-600 text-sm">@Model.Sender.SenderAddress</p>
                    <p class="text-gray-600 text-sm mt-2">
                        <span class="font-semibold">VAT/Tax ID:</span> @Model.Sender.SenderTaxVatId
                    </p>
                    <div class="mt-3 pt-3 border-t border-gray-300">
                        <p class="text-xs text-gray-500 uppercase font-semibold mb-1">Bank Details</p>
                        <p class="text-sm text-gray-700">@Model.Sender.BankDetails</p>
                    </div>
                </div>
            </div>

            <!-- To (Customer) -->
            <div class="bg-blue-50 p-6 rounded-lg">
                <h2 class="text-sm font-semibold text-blue-700 uppercase mb-3">Bill To</h2>
                <div class="space-y-1">
                    <p class="text-lg font-bold text-gray-900">@Model.Customer.CompanyName</p>
                    <p class="text-gray-700">@Model.Customer.CustomerName</p>
                    <p class="text-gray-600 text-sm">@Model.Customer.CustomerAddress</p>
                    <p class="text-gray-600 text-sm">@Model.Customer.PostalCode</p>
                    <p class="text-gray-600 text-sm mt-2">
                        <span class="font-semibold">Email:</span> @Model.Customer.CustomerEmail
                    </p>
                    <p class="text-gray-600 text-sm">
                        <span class="font-semibold">VAT/Tax ID:</span> @Model.Customer.CustomerTaxVatId
                    </p>
                </div>
            </div>
        </div>

        <!-- Line Items Table -->
        <div class="mb-8">
            <table class="w-full border-collapse">
                <thead>
                    <tr class="bg-gray-800 text-white">
                        <th class="text-left py-3 px-4 font-semibold text-sm">Item Description</th>
                        <th class="text-right py-3 px-4 font-semibold text-sm">Quantity</th>
                        <th class="text-right py-3 px-4 font-semibold text-sm">Unit Price</th>
                        <th class="text-right py-3 px-4 font-semibold text-sm">Total</th>
                    </tr>
                </thead>
                <tbody>
                    @foreach (var item in Model.LineItems)
                    {
                        <tr class="border-b border-gray-200 hover:bg-gray-50">
                            <td class="py-3 px-4 text-gray-900">@item.ItemName</td>
                            <td class="text-right py-3 px-4 text-gray-700">@item.Quantity.ToString("N2")</td>
                            <td class="text-right py-3 px-4 text-gray-700">@item.UnitPrice.ToString("N2") @Model.Currency</td>
                            <td class="text-right py-3 px-4 font-semibold text-gray-900">@item.Total.ToString("N2") @Model.Currency</td>
                        </tr>
                    }
                </tbody>
            </table>
        </div>

        <!-- Totals Section -->
        <div class="flex justify-end mb-8">
            <div class="w-80">
                <div class="bg-gray-50 p-6 rounded-lg space-y-3">
                    <div class="flex justify-between items-center">
                        <span class="text-gray-700">Subtotal</span>
                        <span class="text-lg font-semibold text-gray-900">@Model.Subtotal.ToString("N2") @Model.Currency</span>
                    </div>
                    <div class="flex justify-between items-center">
                        <span class="text-gray-700">Tax (@(Model.TaxRate.ToString("N2"))%)</span>
                        <span class="text-lg font-semibold text-gray-900">@((Model.TotalAmount - Model.Subtotal).ToString("N2")) @Model.Currency</span>
                    </div>
                    <div class="border-t-2 border-gray-300 pt-3">
                        <div class="flex justify-between items-center">
                            <span class="text-xl font-bold text-gray-900">Total Amount</span>
                            <span class="text-2xl font-bold text-blue-600">@Model.TotalAmount.ToString("N2") @Model.Currency</span>
                        </div>
                    </div>
                </div>
            </div>
        </div>

        <!-- Notes Section -->
        @if (!string.IsNullOrWhiteSpace(Model.Notes))
        {
            <div class="bg-yellow-50 border-l-4 border-yellow-400 p-4 mb-8">
                <h3 class="text-sm font-semibold text-gray-700 uppercase mb-2">Notes</h3>
                <p class="text-gray-700 text-sm">@Model.Notes</p>
            </div>
        }

        <!-- Footer -->
        <div class="border-t-2 border-gray-300 pt-6 text-center">
            <p class="text-sm text-gray-600">Thank you for your business!</p>
            <p class="text-xs text-gray-500 mt-2">This is a computer-generated invoice and does not require a signature.</p>
        </div>
    </div>
</body>
</html>

Then we call RazorTemplateEngine.RenderAsync to dynamically render the HTML content from a Razor view:

public sealed class InvoicePdfGenerator : IInvoicePdfGenerator
{
    private const string InvoiceTemplatePath = "~/Views/Invoice/InvoiceTemplate.cshtml";
    private const int DefaultMargin = 10;

    public async Task<byte[]> GeneratePdfAsync(InvoiceResponse invoice)
    {
        var html = await RazorTemplateEngine.RenderAsync(InvoiceTemplatePath, invoice);

        var renderer = CreatePdfRenderer();
        var pdf = await renderer.RenderHtmlAsPdfAsync(html);

        return pdf.BinaryData;
    }
}

Here we use the ChromePdfRenderer class from IronPDF to generate a PDF document:

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

The InvoicePdfGenerator is used in the DownloadInvoiceHandler, which reads the invoice from the database and generates the PDF document:

internal sealed class DownloadInvoiceHandler(
    InvoicesDbContext context,
    IInvoicePdfGenerator pdfGenerator)
    : IDownloadInvoiceHandler
{
    public async Task<Result<InvoicePdfResponse>> HandleAsync(
        Guid id,
        CancellationToken cancellationToken)
    {
        var invoice = await context.Invoices
            .Include(x => x.Customer)
            .Include(x => x.Sender)
            .Include(x => x.Items)
            .FirstOrDefaultAsync(x => x.Id == id, cancellationToken);

        if (invoice is null)
        {
            return InvoiceErrors.NotFound(id);
        }

        var invoiceResponse = invoice.MapToResponse();

        var pdfBytes = await pdfGenerator.GeneratePdfAsync(invoiceResponse);

        var fileName = $"Invoice_{invoice.InvoiceNumber}_{DateTime.UtcNow:yyyyMMdd}.pdf";

        return new InvoicePdfResponse(pdfBytes, fileName);
    }
}

We can use the Results.File with contentType: "application/pdf" to download the file from the ASP .NET Core Minimal API endpoint:

public class DownloadInvoiceApiEndpoint : IApiEndpoint
{
    public void MapEndpoint(WebApplication app)
    {
        app.MapGet(RouteConsts.Download, Handle);
    }

    private static async Task<IResult> Handle(
        Guid id,
        IDownloadInvoiceHandler handler,
        CancellationToken cancellationToken)
    {
        var response = await handler.HandleAsync(id, cancellationToken);
        if (response.IsError)
        {
            return response.Errors.ToProblem();
        }

        var pdfData = response.Value!;

        return Results.File(
            fileContents: pdfData.FileBytes,
            contentType: "application/pdf",
            fileDownloadName: pdfData.FileName);
    }
}

Here is what the downloaded report looks like:

This invoice looks good and professional.

Now let's explore how we can add PDF/UA Compliance to the generated PDF.

Generating Compliant PDFs with IronPDF

For invoices, regulations and accessibility standards often require that documents follow strict formats.
Two of the most important standards are PDF/A and PDF/UA.

PDF/A (PDF for Archiving) ensures that a document can be stored long-term without losing fonts, colors, or layout.
It is often required for contracts, invoices, and government filings.

PDF/UA (Universal Accessibility) ensures that a document is accessible to everyone, including individuals who rely on screen readers or other assistive technologies.
This is important for accessibility compliance.

With IronPDF, you can create both PDF/A and PDF/UA documents in just a few lines of code.
It uses the Chromium engine to render HTML and CSS, then exports the result into the required compliant format.

You can convert the rendered HTML into PDF/A or PDF/UA using the ConvertToPdfA or ConvertToPdfUA methods:

using IronPdf;

var renderer = CreatePdfRenderer();

var pdf = await renderer.RenderHtmlAsPdfAsync(html);
pdf = pdf.ConvertToPdfUA();

And let the user download the compliant PDF file.

Now let's explore the final piece of the puzzle: adding a digital signature to the generated PDF.

Adding a Digital Signature to PDF with IronPDF

Invoices often need a signature to prove integrity and origin.

There are two parts you can combine:

A visual mark inside the PDF (a stamp or signature block) so the human reader sees a signed area.
A cryptographic digital signature that a PDF reader can verify.

Let's explore how we can add a visual signature with a sender name to the generated PDF:

using IronPdf;

var renderer = CreatePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync(html);

AddSignatureToPdf(pdf, invoice.Sender.SenderFullName);

private void AddSignatureToPdf(PdfDocument pdf, string senderFullName)
{
    var signatureText = $"Digitally signed by: {senderFullName}";

    var stamp = new IronPdf.Editing.TextStamper
    {
        Text = signatureText,
        FontFamily = "Arial",
        FontSize = 20,
        IsBold = false,
        IsItalic = true,
        VerticalAlignment = IronPdf.Editing.VerticalAlignment.Bottom,
        HorizontalAlignment = IronPdf.Editing.HorizontalAlignment.Right,
        Opacity = 100,
        Rotation = 0
    };

    pdf.ApplyStamp(stamp);

    logger.LogDebug("Added signature to PDF: {SignatureText}", signatureText);
}

This code adds a stamp with the sender's name to the bottom right corner of the PDF:

To add a real cryptographic signature, sign the document with a certificate (PFX).

This feature ensures your PDFs are secure for business, legal, and compliance purposes.

Digital signatures prove the authenticity of a document.

With IronPDF, you can sign using a certificate (.pfx or .p12) and add details like the signer's name, location, or even an image:

var renderer = CreatePdfRenderer();

var pdf = await renderer.RenderHtmlAsPdfAsync(html);
pdf = pdf.ConvertToPdfUA();

var signature = new PdfSignature("IronSoftware.pfx", "123456")
{
    SignatureDate = DateTime.Now,
    SigningContact = "cert@company.com",
    SigningLocation = "Chicago, USA",
    SigningReason = "Contractual Agreement",
    TimeStampUrl = "[http://timestamp.digicert.com](http://timestamp.digicert.com)",
    TimestampHashAlgorithm = TimestampHashAlgorithms.SHA256,
    SignatureImage = new PdfSignatureImage("assets/visual-signature.png", 0,
        new Rectangle(350, 750, 200, 100))
};

pdf.Sign(signature);

This ensures that the PDF cannot be changed without invalidating the signature.

For more information, refer to the official documentation.

Licensing

IronPDF follows a commercial licensing model.

Free trial available: You can start with a trial license to explore features.
Commercial licenses required for production: Businesses and organizations must obtain a license before deploying IronPDF in production.
Support and updates included: A license comes with access to updates, bug fixes, and professional technical support.

IronPDF provides enterprise-grade features, including PDF/A and PDF/UA compliance, digital signatures, and document security, which are often required in professional and regulated environments.

IronPDF offers a license at a much more affordable price and offers more benefits than Aspose, which is honestly very overpriced.

IronPDF offers the best support, helping developers quickly resolve issues — a feature that other PDF libraries often lack.