Beginner's Guide to .NET 10 introduces the three tools you will meet in nearly every modern ASP.NET Core project: Blazor, EF Core, and Minimal APIs. Each one is simple on its own, but beginners often struggle to see how they cooperate. This article explains every tool in plain language, then walks through a tiny example that uses all three — the same trio that powers the Indotalent product suite.
Beginner's Guide to .NET 10: Three Pieces, One Application
Here is the division of labor in a single sentence: Minimal APIs receive HTTP requests, EF Core reads and writes the database, and Blazor renders the user interface. In the Indotalent architecture the Blazor Server UI calls the REST API, the Minimal API endpoints forward work to MediatR handlers, and those handlers talk to the database through EF Core. You do not need to master all of it at once — understanding the boundaries between the pieces is what makes each one easy to learn.
What Is Blazor Server?
Blazor is the UI layer of modern ASP.NET Core. Blazor Server keeps all of your C# code on the server, and the browser stays in sync over a persistent SignalR connection. Every click, form submit, and data refresh becomes a C# method call rather than a page reload. That means a beginner can build interactive pages with the same language they are already learning, without maintaining a separate JavaScript codebase. Indotalent products run on Blazor Server specifically, because it keeps the whole stack in one language, one deployment, and one team's skill set.
What Is EF Core?
Entity Framework Core is the data access layer. You define plain C# classes called entities, and EF Core maps them to database tables. Queries are written in LINQ, which the framework translates into SQL for you, and migrations let you evolve the schema as your models change. For a beginner the payoff is immediate: you never hand-write INSERT or SELECT statements for day-to-day work, and typos in column names become compile-time errors instead of runtime surprises.
What Are Minimal APIs?
Minimal APIs are the lightweight way to expose endpoints in ASP.NET Core. Instead of controllers with dozens of lines of boilerplate, an endpoint is a single method call that maps a URL to a handler. They were introduced to make small services and prototypes fast, and .NET 10 refines them further with better performance and smaller generated code. An endpoint can be as short as one line:
app.MapGet("/", () => "Hello, .NET 10!");That one line registers a route, a handler, and a response. It is the smallest possible web application, and it teaches the mental model for every larger API you will build afterwards.
A Tiny Example That Uses All Three
Start with an entity and a database context. A Product entity and a ShopDbContext are enough to prove the EF Core idea:
public class Product
{
public int Id { get; set; }
public string Name { get; set; } = string.Empty;
public decimal Price { get; set; }
}
public class ShopDbContext : DbContext
{
public ShopDbContext(DbContextOptions<ShopDbContext> options)
: base(options) { }
public DbSet<Product> Products => Set<Product>();
}The DbSet property is the important part — it tells EF Core that Product maps to a Products table. Next, wire everything together in Program.cs. Register the context, map a Minimal API endpoint that queries through EF Core, and enable the Blazor Server render mode:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<ShopDbContext>(o =>
o.UseSqlite("Data Source=shop.db"));
builder.Services.AddRazorComponents().AddInteractiveServerComponents();
var app = builder.Build();
app.MapGet("/products", async (ShopDbContext db) =>
await db.Products.ToListAsync());
app.MapRazorComponents<App>().AddInteractiveServerRenderMode();
app.Run();Read the example top to bottom and watch the handoffs. The endpoint receives a ShopDbContext through dependency injection — the framework constructs it per request. EF Core translates the LINQ query into SQL against the SQLite file, and the JSON result travels back over HTTP. A Blazor page can then call that endpoint and render the products in a table with no additional plumbing. That is the complete loop, and it is the same loop running behind every Indotalent product.
Beginner's Guide to .NET 10: How the Pieces Talk to Each Other
One detail is worth repeating because it explains why the trio is so maintainable: each tool only knows its own job. The Minimal API knows nothing about the database schema, EF Core knows nothing about HTML, and Blazor knows nothing about SQL. They communicate through well-defined seams — HTTP requests, dependency injection, and LINQ. Learning to keep these boundaries clean is the fastest way to write .NET that survives contact with a growing business, and it is exactly the discipline that Vertical Slice Architecture formalizes in production applications.
Key Takeaways
- Blazor builds the UI, Minimal APIs expose endpoints, and EF Core talks to the database.
- Blazor Server keeps all UI logic in C# over a real-time SignalR connection.
- EF Core maps C# classes to tables and translates LINQ queries into SQL.
- A single Program.cs can register the database, map endpoints, and enable Blazor.
- Keeping the three layers separate is what makes real projects maintainable.
- Indotalent products combine Blazor Server, EF Core, and REST APIs — full .NET 10 source code for $21 each.
FAQ
Do I need all three tools in my first app?
No. A first app can be just a Minimal API, or just a Blazor page with no database. Add EF Core only when you have data to store, then add the pieces you actually need instead of scaffolding everything upfront.
Is Blazor Server slower than Blazor WebAssembly?
Blazor Server sends only UI updates over the connection, which is efficient for forms, tables, and dashboards. Latency mainly matters for games and highly interactive canvases, not for the business applications this stack targets.
Can I use raw SQL with EF Core?
Yes. EF Core supports raw SQL queries for complex cases, and migrations give you full control over the schema whenever you need to tune something by hand.
Where can I see all three working together in production?
The Indotalent products are complete .NET 10 applications that use exactly this stack, with full source code available for $21 each.