Blog: .NET 10, Blazor & VSA

What Is ASP? From Classic ASP to ASP.NET Core and Modern .NET

What ASP means, how classic ASP became ASP.NET, and where ASP.NET Core and modern .NET fit in Microsoft's web stack.

What Is .NET Framework? .NET Framework vs Modern .NET Explained

Understand .NET Framework, its Windows-only history, and how modern cross-platform .NET replaced it for new applications.

Microsoft .NET Explained: What Is MS .NET and What Can You Build With It?

Microsoft .NET explained: runtime, SDK, C#, and the web, desktop, mobile, cloud, data, and game workloads you can build.

ASP.NET Core Explained: From .NET to Modern Web Applications

ASP.NET Core explained: the open-source, cross-platform web framework on .NET, and how MVC, Razor Pages, Minimal APIs, and Blazor relate.

What Is MVC? Model-View-Controller Explained

Learn the MVC meaning, what Model, View, and Controller do, and how the pattern works in ASP.NET Core.

ASP.NET Core MVC Tutorial: Controller, View, Model, EF Core and SQL

Learn ASP.NET Core MVC controllers, actions, routing, Razor views, model binding, EF Core, DbContext, and SQL with C# examples.

Build a Real ASP.NET Core MVC Feature: Razor View, API, and Database

Walk through one real ASP.NET Core MVC feature: page-routing controller, Razor view, collocated JavaScript, Minimal API endpoint, CQRS handler, EF Core, and SQL.

Why ASP.NET Core MVC Controllers Become Bloated: CQRS and Better Alternatives

Learn why MVC controllers become bloated and how CQRS, MediatR-style dispatching, and focused Minimal API endpoints keep them thin.

ASP.NET Core MVC + Minimal APIs + CQRS: A Practical Vertical Slice Architecture

Compare ASP.NET Core MVC and Minimal APIs, then combine both with CQRS handlers and EF Core in one Vertical Slice Architecture monolith.

From ASP.NET Core MVC Tutorial to Production-Ready Business Software

Move beyond a basic MVC tutorial into production architecture with VSA, CQRS, Minimal APIs, authentication, logging, jobs, and AI-assisted development.

Blazor CRM Source Code in ASP.NET Core

Evaluate Blazor CRM source code in ASP.NET Core: pipeline modules, shared stack, database and demo data, and the customization path in a complete CRM project.

CRM System in C#: From Lead to Closing

Study the CRM system in C# through the actual lead, contact, activity, campaign, budget, expense, and sales-team entities behind the pipeline screens.

CRM Database Design: Leads, Contacts, and Campaigns

Study CRM database design with actual lead, contact, activity, campaign, budget, expense, and sales-team entities plus a readable relationship diagram.

CRM Database Schema: Properties, Keys, and Indexes

Inspect the actual CRM schema in Blazor CRM: column types, nullability, foreign keys, unique indexes, audit fields, and soft delete.

Blazor CRM REST API Design

Trace the actual lead REST API in the Blazor CRM source: routes, methods, DTOs, bearer authentication, response envelopes, and validation boundaries.

Building a CRM Interface with Blazor and MudBlazor

See how a Blazor CRM interface connects MudBlazor forms and data tables to typed services, lookup endpoints, snackbar feedback, and the pipeline API.

Building a CRM with ASP.NET Core

Learn how the Blazor CRM app is composed with ASP.NET Core: startup, dependency groups, EF Core providers, Identity and JWT, and the /api request path.

CRM Vertical Slice Architecture in ASP.NET Core

Trace CRM Vertical Slice Architecture from a MudBlazor lead form through its service, Minimal API, MediatR handler, validation boundary, and EF Core save.

Warehouse Management System in ASP.NET Core

Explore an ASP.NET Core warehouse management system with Blazor, EF Core, inventory transactions, purchasing, sales, and complete C# source code.

Blazor Warehouse Management System

See how a Blazor warehouse management system connects MudBlazor forms to warehouse APIs, CQRS handlers, and EF Core in a complete WMS source project.

Inventory Management System Source Code

Evaluate inventory management system source code through actual WMS modules, data models, APIs, customization paths, and source-code purchase considerations.

ASP.NET Core Inventory Management

Follow receipts, deliveries, transfers, adjustments, and stock counts in ASP.NET Core inventory management using the actual Blazor WMS transaction model.

Warehouse Database Design

Study warehouse database design with actual WMS entities, foreign-key relationships, business documents, inventory movements, and a readable relationship diagram.

Inventory Database Schema

Inspect the actual Product, Warehouse, and InventoryTransaction schema in Blazor WMS: C# types, foreign keys, movement fields, indexes, audit, and soft delete.

Warehouse REST API Design

Trace actual warehouse API routes, JSON requests, bearer authentication, response envelopes, and validation boundaries in the Blazor WMS source code.

Building Inventory Management with EF Core

Learn EF Core inventory implementation through real WMS entities, relationship mapping, stock queries, save behavior, soft delete, audit, and database initialization.

WMS Vertical Slice Architecture

Trace WMS Vertical Slice Architecture from a Blazor warehouse form through its service, Minimal API, MediatR handler, validation boundary, and EF Core save.

ASP.NET Core MVC Request Lifecycle: From URL to Database

Follow an ASP.NET Core MVC request from a Razor page to a Minimal API, a feature handler, and EF Core using a practical Country example.

Program.cs and Middleware in ASP.NET Core MVC Explained

Understand service registration, middleware order, and endpoint mapping in Program.cs with practical examples from a feature-based ASP.NET Core MVC app.

ASP.NET Core Dependency Injection: Scoped Services and Feature Handlers

Learn transient, scoped, and singleton lifetimes, then trace how a request-scoped DbContext reaches a directly constructed MVC feature handler.

ASP.NET Core MVC Areas and Feature Folders: A Beginner Guide

Understand MVC Areas, conventional routing, and explicit Razor view paths, then organize a Country feature with controllers, handlers, endpoints, and views.

ASP.NET Core Configuration and EF Core: Connect the Right Database

Learn configuration sections, provider selection, and DbContext registration in ASP.NET Core MVC, including the difference between EnsureCreated and migrations.

ASP.NET Core Parameter Binding and DTOs: Understand a JSON Request

Trace JSON, route values, injected services, and cancellation tokens into a Minimal API endpoint inside an ASP.NET Core MVC application.

ASP.NET Core Validation for Beginners: From Input Rules to API Errors

Separate model binding, server-side validation, and business rules, then follow a pragmatic FluentValidation handler in an ASP.NET Core MVC feature.

Razor Views and JavaScript in ASP.NET Core MVC: A Practical Form Flow

Learn where Razor stops and browser JavaScript starts, then trace a Country form through a collocated script, fetch request, and visible success state.

ASP.NET Core MVC Search, Sorting, and Pagination with EF Core

Follow a server-side Country list query through filtering, sorting, DTO projection, and pagination, with practical checks for table-to-API contracts.

EF Core Relationships and MVC Lookup Dropdowns for Beginners

Connect a Currency form to Country data using a foreign key, a lookup DTO, and a dropdown, with practical checks for optional and invalid selections.

ASP.NET Core MVC Authentication vs Authorization: Protect Pages and APIs

Understand identity, authentication schemes, and role authorization, then protect both a Country MVC controller and its separate API route group.

EF Core Soft Delete and Audit Fields in ASP.NET Core MVC

Learn how a deletion flag, global query filter, and SaveChanges audit hooks work together in a pragmatic ASP.NET Core MVC data layer.

VSA Todo App — Part 2: CQRS Command Handlers in Practice

Implement Create, Update, and Delete Todo commands with VSA. Compare MediatR-based handlers (from Blazor CRM) with manual handler classes (from MVC Project Manager). Learn record types, ApiResponse wrapper, and when MediatR is overkill.

VSA Todo App — Part 3: Query Handlers & Response DTO Patterns

Design VSA query handlers for single Todo detail (with child items) and list queries. Learn DTO projection, Include/ThenInclude strategies, IHasAuditDisplay pattern, user lookups, and avoiding N+1 queries.

VSA Todo App — Part 4: FluentValidation Inside Vertical Slices

Where to put validation in VSA: server-side FluentValidation called inside handlers vs client-side in Blazor MudForm and MVC Vue.js. Covers enum validation, child entity rules, conditional validation, and ApiResponse.Fail() error responses.

VSA Todo App — Part 5: Minimal API Endpoints & Route Organization

Organize VSA Minimal API endpoints per feature. Covers MapGroup, JWT authorization, request size limits for file uploads, endpoint-per-feature pattern, and hybrid MVC controller + Minimal API approaches.

VSA Todo App — Part 6: Parent-Child Relationships & Nested Operations

Handle parent-child relationships in VSA: TodoItems as children of Todo. Compare separate child handlers (Blazor CRM pattern) vs nested request DTOs (MVC PM pattern). Covers cascade operations and child validation.

VSA Todo App — Part 7: File Uploads & Storage in Vertical Slices

Implement file and image attachments in VSA. Covers FileStorageService, diff-based attachment management, rollback on failure, download endpoints, and validation for .png/.pdf/.docx/.zip.

VSA Todo App — Part 8: Server-Side Pagination, Sorting & Excel Export in VSA

Implement server-side DataTables in VSA: pagination, multi-column sorting, global search, and Excel export. Compare server-side DataTables protocol (MVC PM) with client-side in-memory filtering (Blazor CRM).

VSA Todo App — Part 9: Soft Delete, Audit Trail & Cross-Cutting Concerns in VSA

Add soft delete with cascade, automatic audit trail (CreatedAt/CreatedBy/UpdatedAt/UpdatedBy), and cross-cutting concerns to VSA. Covers IHasAuditDisplay, auto-number generation, progress tracking, and enum categorization.

VSA Todo App — Part 10: Blazor Server vs MVC Frontend Comparison in VSA

Compare two production VSA frontends for the same Todo backend: Blazor Server with MudBlazor (from Blazor CRM) vs ASP.NET Core MVC with Vue.js (from MVC PM). Covers state management, validation UX, and file upload UX.

VSA Todo App — Part 11: Auto-Number Generation & EF Core Fluent API Configuration

Implement VSA auto-number generation with consonant-based templates (e.g., BKG/2026/00001). Covers EF Core Fluent API entity configuration, shadow properties, and value converters.

VSA Todo App — Part 12: Front-End Service Layer & Typed HTTP Client Patterns

Build a front-end service layer for VSA APIs: TodoService extending BaseService, RestClient wrapper, typed HTTP clients with IHttpClientFactory, and how the service layer bridges Blazor components to VSA endpoints.

VSA Todo App — Part 13: Blazor Component Architecture with MudBlazor & State Machines

Design Blazor components for VSA Todo: TodoPage.razor state machine (Table/Create/Update/View modes), MudBlazor DataTable with search and pagination, MudForm with FluentValidation, MudDialog for child items, and Excel export.

VSA Todo App — Part 14: Vue.js & DataTables.js — Reactive Frontends for VSA APIs

Build reactive VSA frontends with Vue.js and DataTables.js for ASP.NET Core MVC. Covers Vue.js component composition, server-side DataTables integration, modal dialogs, drag-and-drop file upload, and image gallery.

VSA Todo App — Part 15: Enum-Based Domain Modeling — Priority, Category & Status Patterns

Model domain concepts with enums in VSA: TodoPriority (Low/Medium/High), TodoCategory (Personal/Work/Learning). Covers enum validation with FluentValidation, EF Core storage, and client-side rendering.

VSA Todo App — Part 16: Business Logic in VSA Handlers — Progress, Due Dates & Owner Assignment

Where business logic belongs in VSA: progress tracking (0-100 slider), due date validation, owner assignment with user lookup, tags management, and keeping handlers focused without leaking business rules.

VSA Todo App — Part 17: Excel Export & Reporting with ClosedXML in VSA

Add Excel export to VSA Todo: ClosedXML workbook generation, flat TodoExportItem DTO projection, audit trail resolution in exports, server-side export endpoint, and client-side triggers from Blazor and MVC.

VSA Todo App — Part 18: Authorization per Slice — JWT, Cookie Auth, Roles & Policies

Implement authorization in VSA slices: JWT Bearer (Blazor CRM) vs Cookie Authentication (MVC PM), per-endpoint role requirements, policy-based authorization, and protecting both API endpoints and Razor views.

VSA Todo App — Part 19: Error Handling & Resiliency Patterns in VSA

Standardize error handling across VSA slices: ApiResponse wrapper pattern, validation error responses, try-catch in handlers, global exception middleware, rollback on partial failure, and logging strategies.

VSA Todo App — Part 20: Testing VSA Slices — Integration, Handler & Validation Tests

Test VSA slices end-to-end: WebApplicationFactory integration tests for endpoints, unit tests for handlers with mocked DbContext, FluentValidation test helpers, testing authorization, and how VSA makes testing simpler.

Tutorial Vertical Slice Architecture VSA in Blazor — Part 1: Project Setup & First Slice

Step-by-step tutorial for beginners: create a Blazor Server project in .NET 10, set up the VSA feature-folder structure, add MediatR + EF Core, define the Todo entity, and build the first read-only slice (GetTodoList handler + page) with real code from Blazor CRM.

Tutorial Vertical Slice Architecture VSA in Blazor — Part 2: Complete CRUD with MudBlazor

Complete the Blazor VSA tutorial: create, update, and delete slices (CreateTodoHandler, UpdateTodoHandler, DeleteTodoByIdHandler), FluentValidation, MudForm with validation, the state-machine page pattern (Table/Create/Update/View), MudDialog delete confirmation, and Snackbar feedback — all from Blazor CRM.

Tutorial Vertical Slice Architecture VSA in ASP.NET Core MVC — Part 1: Project Setup & First Slice

Step-by-step tutorial for beginners: create an ASP.NET Core MVC project in .NET 10, set up Areas, build the per-feature folder structure (Controllers, Cqrs, Endpoints, Views), wire plain CQRS handlers, and render the first Todo list with a controller + Razor view using real code from MVC Project Manager.

Tutorial Vertical Slice Architecture VSA in ASP.NET Core MVC — Part 2: Complete CRUD with Vue.js

Complete the MVC VSA tutorial: create and edit Todo with Vue.js forms, server-side FluentValidation in handlers, ApiResponse<T> error handling, TodoEndpoint REST routes (POST/PUT/DELETE), and the diff-based update pattern — all from MVC Project Manager.

ASP.NET Core MVC Vertical Slice Architecture: Complete Implementation Guide

Implement Vertical Slice Architecture in ASP.NET Core MVC: feature folders, controllers, CQRS handlers, per-feature endpoints, and Razor views in one slice. Complete .NET 10 guide.

AI-Assisted Development: A Practical Guide for .NET Developers

A practical guide to AI-assisted software development for .NET: the tools, the workflow, and how to keep a human in control of architecture and quality.

Why One-Shot AI Prompts Fail for Software Development

Why one-shot AI prompts fail for real software projects, and how specification-first, human-directed AI-assisted development produces reliable code.

How to Write a PRD for AI-Assisted Development

How to write a PRD that AI coding agents can execute: scope, traceability, data dictionary, page layouts, endpoints, and acceptance rules.

Data Dictionary for AI-Assisted Software Development

Why a data dictionary is the highest-leverage AI context: entity names, types, nullability, relationships, and validation rules the AI must follow.

Software Engineering Rules for AI Coding Agents

Write engineering rules your AI coding agent must obey: naming, folder structure, soft delete, cancellation tokens, validation, and build gates.

AI-Assisted Development Workflow: From Requirement to Code

The full AI-assisted development workflow: engineering rules, data dictionary, features, PRD, AI implementation, and human review.

Human-Directed vs AI-Directed Software Development

Human-directed vs AI-directed software development: who owns architecture, requirements, and review, and why constraints make AI output reliable.

How to Give AI Enough Context Without Wasting Tokens

Give AI enough context without wasting tokens: feature folders, reference slices, scoped skills files, and progressive context loading.

AI-Assisted Development with ASP.NET Core

AI-assisted development with ASP.NET Core: structure, conventions, and a rules file that turns one entity into a full, buildable feature.

AI-Assisted CRUD Development with ASP.NET Core MVC

AI-assisted CRUD in ASP.NET Core MVC: from one entity class to controller, CQRS handlers, endpoints, validators, and Razor views.

Building an AI-Ready .NET Project Structure

Design an AI-ready .NET project structure: feature folders, single-project monolith, a skill/rules file, and reference implementations AI can copy.

Audit Trail Implementation: Compliance-Ready Logging for Enterprise .NET

Audit Trail Implementation for compliance: immutable append-only logs, GDPR and SOX-ready .NET design, user identity capture, and audit retention policies.

C# 14 Features in Vertical Slice Architecture: Cleaner Slices

C# 14 Features in Vertical Slice Architecture: slimmer handlers, less boilerplate, and cleaner slices with field, params, and extension members in .NET 10.

The 10 Features of a True Enterprise Blazor Template

Enterprise Blazor Template features: the 10 capabilities that separate a true enterprise template from a demo project, from JWT auth to observability and CI/CD.

CQRS with MediatR vs Plain Services: When to Use Each Pattern

CQRS with MediatR vs plain services: understand the real trade-offs before you choose. Compare coupling, control flow, testing, plus real .NET 10 examples.

C# 14 Features: Field Properties and Other Productivity Wins

C# 14 Features productivity wins: the field keyword kills backing-field boilerplate, plus params collections, nameof on generics, and leaner domain models.

.NET Enterprise Architecture: A Practical Blueprint for .NET 10 Teams

.NET Enterprise Architecture blueprint for .NET 10 teams — a step-by-step checklist from project layout and authentication to REST APIs and deployment.

Enterprise Blazor Template: What Every Production App Needs From Day One

Enterprise Blazor Template essentials: what a production-grade Blazor Server app needs from day one — Identity auth, EF Core migrations, MediatR, and MudBlazor.

Vertical Slice Architecture with EF Core: Where Migrations and Data Access Live

Vertical Slice Architecture with EF Core: where the DbContext and migrations live, one-context versus per-slice contexts, and a complete EF Core slice.

Inside the Blazor Server Architecture of a Production CRM System

Blazor Server Architecture in production: an inside look at a CRM with circuits, scoped DI, tenant isolation, and rendering patterns that hold up under load.

CQRS with MediatR Pipeline Behaviors: Validation, Logging, and Transactions

CQRS with MediatR pipeline behaviors add cross-cutting concerns to every command and query. Learn validation, logging, and transaction behaviors in .NET 10.

C# 14 Features: Modern C# in Action with Real .NET 10 Code

C# 14 Features in action with real .NET 10 code — modern C# using field, params collections, nameof on generics, and extension members end to end in a slice.

.NET Enterprise Architecture: Modular Monoliths and Domain Boundaries

.NET Enterprise Architecture through modular monoliths — drawing domain boundaries inside a single process, sharing data safely, and knowing when to split.

Vertical Slice Architecture vs Clean Architecture: Which One Should You Choose?

Vertical Slice Architecture vs Clean Architecture: compare coupling, testing, and maintainability to choose the right structure for your .NET 10 application.

Blazor Server Architecture vs MVC: Why Component-Based Wins

Blazor Server Architecture vs MVC: why component-based Razor UI beats stateless controllers for interactive enterprise applications built on modern .NET 10.

CQRS with MediatR: A Practical Guide for .NET 10

CQRS with MediatR is a practical pattern for .NET 10 apps. Learn commands vs queries, handler wiring, validation, and how to keep code simple and testable.

C# 14 Features: What's New in the Latest Language Release

C# 14 Features: what's new in the latest language release — field keyword, params spans, nameof on generics, ref structs, and extension members in preview.

.NET Enterprise Architecture for CRM, HRM, and WMS Systems

.NET Enterprise Architecture for CRM, HRM, and WMS systems — how real products structure modules, domains, REST APIs, and Blazor UI on .NET 10 in production.

Vertical Slice Architecture in Practice: A Walkthrough of 10 Real Slices

Vertical Slice Architecture in practice: a walkthrough of 10 real slices from production .NET 10 apps, from simple CRUD endpoints to complex workflows.

Blazor Server Architecture Best Practices: State, Rendering, and Lifecycles

Blazor Server Architecture best practices for state, rendering, and component lifecycles, with actionable .NET 10 patterns for ShouldRender and cleanup.

Blazor Server vs WebAssembly: Migration Scenarios and Use Cases

Blazor Server vs WebAssembly migration scenarios and use cases: when to switch hosting models, and how Blazor Web App hybrid render modes ease the move.

.NET 10 Source Code: What's Inside a Production-Ready Blazor Application

.NET 10 Source Code in a production Blazor app: Program.cs, dependency injection, EF Core, JWT auth, and vertical slices. See what each part really does.

.NET Enterprise Architecture: Layered, Clean, or Vertical Slices?

.NET Enterprise Architecture compared: layered, clean, and vertical slice — when each wins in 2026, the trade-offs, and a decision path for .NET 10 teams.

Vertical Slice Architecture: The Complete Guide for .NET Developers

Vertical Slice Architecture organizes .NET code by business features. This complete guide covers feature folders, Minimal APIs, MediatR handlers, and CQRS.

Designing Blazor Server Architecture for Enterprise Applications

Blazor Server Architecture for enterprise: patterns for scoped services, multi-tenancy, background work, and security boundaries in a .NET 10 application.

Blazor Server vs WebAssembly: The Developer Experience Difference

Blazor Server vs WebAssembly developer experience differences: C# everywhere, breakpoints in the server process, MudBlazor productivity, and JS interop.

How to Read .NET 10 Source Code Effectively as a Developer

.NET 10 Source Code reading strategies: start at Program.cs, trace one request end-to-end, and lean on IDE tooling to map dependencies without getting lost.

.NET Enterprise Architecture: The Patterns That Actually Matter in 2026

.NET Enterprise Architecture in 2026: the patterns that still earn their keep — vertical slices, modular monoliths, CQRS, and DDD — with .NET 10 code.

Blazor Server Architecture: How SignalR, DI, and Razor Components Fit Together

Blazor Server Architecture: how SignalR circuits, scoped DI, and Razor component lifecycles fit together in a modern .NET 10 app, with practical code examples.

Blazor Server vs WebAssembly: Cost and Hosting Comparison

Blazor Server vs WebAssembly cost and hosting comparison: RAM per circuit and persistent connections versus cheap static hosting and a separate API backend.

.NET 10 Source Code Tour: From Program.cs to Vertical Slices

.NET 10 Source Code tour: follow one request from the Program.cs startup file through dependency injection and EF Core into a vertical slice, end to end.

Audit Trail Implementation in a Blazor Server Admin Dashboard

Audit Trail Implementation in Blazor Server: surface change history in an admin dashboard with MudBlazor tables, filters, and drill-down details. C# included.

Blazor Server vs WebAssembly: Performance Benchmarks You Can Trust

Blazor Server vs WebAssembly performance benchmarks you can really trust: compare SignalR circuit latency and first render with WASM download and boot time.

Where to Get Real .NET 10 Source Code (Not Just Tutorial Snippets)

.NET 10 Source Code you can study: the official dotnet and aspnetcore repositories, Microsoft Learn samples, open source apps, and complete paid codebases.

ASP.NET Core 10 Features: Upgrading from ASP.NET Core 8 Without Pain

ASP.NET Core 10 Features: upgrading from ASP.NET Core 8 without pain — target net10.0, handle breaking changes, and follow a step-by-step migration plan.

Audit Trail Implementation: Who Changed What, When, and Why

Audit Trail Implementation: track user identity, timestamps, and change reasons to prove who changed what, when, and why in your .NET app with C# examples.

.NET 10 Source Code Analysis: How Indotalent Structures Enterprise Apps

.NET 10 Source Code analysis of an enterprise Blazor application: how Indotalent structures projects, vertical slices, EF Core, Identity, and multi-tenancy.

CQRS + MediatR in VSA: Make Your Code Not Spaghetti Code

How CQRS and MediatR inside Vertical Slice Architecture eliminate spaghetti code. See the before-and-after transformation of a tangled controller into clean VSA slices.

Why Vertical Slice Architecture is the Best Architecture for AI-Assisted Development

VSA organizes code by feature in a single folder end-to-end. This makes AI tools like GitHub Copilot and ChatGPT dramatically more effective by keeping context focused in one place. Stop jumping between 7 projects.

Blazor Server vs WebAssembly: Choosing the Right Hosting Model

Compare Blazor Server and Blazor WebAssembly for enterprise applications. Which hosting model is right for your .NET 10 project? Complete analysis with pros and cons.

Introduction to Vertical Slice Architecture in .NET 10

Learn how Vertical Slice Architecture (VSA) organizes .NET 10 code by business features instead of technical layers. Complete with Minimal API code examples.

How Vertical Slice Architecture Eliminates "Project Hell"

From 15+ projects to a single monolith. How VSA keeps related code together, slashes compilation time, and makes onboarding instant.

Building Maintainable .NET Applications with MediatR and VSA

How MediatR enables CQRS within Vertical Slice Architecture. Pipeline behaviors for validation, logging, and transactions. Complete code examples.

Blazor Server Performance Optimization: Real-World Techniques

ShouldRender, virtualization, no-tracking queries, and server-side pagination for Blazor Server apps. Production-tested techniques used in Indotalent products.

MudBlazor: The Ultimate Component Library for Blazor Server

50+ Material Design components. Why MudBlazor is the de facto standard for Blazor enterprise apps. Pure C# components with native two-way binding.

Securing Your Blazor Server Application with JWT and ASP.NET Core Identity

Four-layer security for Blazor Server: ASP.NET Core Identity, JWT authentication for REST APIs, policy-based authorization, and SignalR protection. Complete guide.

From Clean Architecture to Vertical Slices: A Practical Migration Guide

Step-by-step approach to migrate from layered architecture to VSA, one feature at a time. Phase 1: pick one feature. Phase 2: extract validation. Phase 3: repeat.

Real-World VSA: Shipping Production-Ready .NET 10 Apps with Indotalent

How each Indotalent product is built. The complete stack, the architecture, and what you get for $21. Production-ready VSA source code with 50-100 feature slices each.

Vertical Slice Architecture vs Traditional Layered Architecture: Side-by-Side Code

7 files in 4 projects vs 1 file. A concrete code comparison of VSA and traditional layered architecture for the same 'Create Customer' feature.

ASP.NET Core Identity with JWT in MVC: Access Tokens and Refresh Rotation

Combine ASP.NET Core Identity with JWT in MVC: generate signed access tokens, validate them with AddJwtBearer, and rotate refresh tokens server-side in .NET 10.

Role-Based Authorization in ASP.NET Core MVC: Roles, Policies, and Claims

Implement role-based authorization in ASP.NET Core MVC: seed roles, assign users, protect controllers with [Authorize(Roles)], and layer on claims-based policies.

Firebase SSO with Google Sign-In in ASP.NET Core MVC: One-Click Authentication

Add one-click Google sign-in to ASP.NET Core MVC with Firebase SSO: client popup, server-side token verification, and auto-provisioned Identity users.

CQRS in ASP.NET Core MVC Without MediatR: Direct Handlers and Endpoints

Implement CQRS in ASP.NET Core MVC with plain handler classes — no MediatR. Commands and queries wired directly into controllers and per-feature endpoints.

Email Confirmation and Password Reset with ASP.NET Core Identity

Build the complete email confirmation and password reset flow with ASP.NET Core Identity: single-use tokens, SendGrid/SMTP delivery, and secure callbacks.

Background Jobs in ASP.NET Core MVC with Hangfire: Recurring and Fire-and-Forget

Add reliable background jobs to ASP.NET Core MVC with Hangfire: fire-and-forget, delayed, recurring cron jobs, and the built-in /hangfire dashboard.

ASP.NET Core Identity Best Practices: Secure Authentication Done Right

The production ASP.NET Core Identity checklist: password policy, account lockout, 2FA, email confirmation, secret handling, and least-privilege roles.

ASP.NET Core MVC VSA Folder Structure: One Folder per Feature in Practice

The practical MVC VSA folder structure: Controllers, Cqrs handlers, Endpoints, and Views inside one feature folder, with a real Currency slice in .NET 10.

The Freelance .NET Developer Stack: Source Code, Templates, and Tooling

Freelance .NET Developer Tools and the stack around them: owned source code, templates that skip setup, and tooling that makes solo delivery repeatable.

REST API with Swagger in .NET 10: Complete Documentation Guide

REST API with Swagger in .NET 10: AddSwaggerGen, XML comments, and Swagger UI setup, with complete minimal API code examples for production-ready docs.

How to Build a Single-Project Monolith with Vertical Slice Architecture

Single-Project Monolith with Vertical Slice Architecture: one project, feature folders, full cohesion — build clean, maintainable .NET 10 code with VSA.

EF Core 10 Migrations in Production: Idempotent Scripts and CI/CD

EF Core 10 Migrations in production: generate idempotent SQL scripts, apply them in a CI/CD pipeline, and keep deployments safe and repeatable on every release.

Freelance .NET Developer Tools: 10 Tools That Save 20 Hours a Week

Freelance .NET Developer Tools that save 20 hours a week: source templates, admin dashboards, scaffolding scripts, and automation for solo developers.

Single-Project Monolith vs Microservices: Rethinking Distributed Complexity

Single-Project Monolith vs Microservices: when a single app beats a fleet of services — lower operational cost, atomic transactions, and simpler debugging.

EF Core 10 Migrations vs Database First: Which Strategy Is Right?

EF Core 10 Migrations vs Database First: compare code-first with Scaffold-DbContext, learn when each fits, and choose the right schema strategy for your team.

Production-Ready .NET Apps: Security Hardening from Day One

Production-Ready .NET Apps require security hardening. Learn rate limiting, headers, JWT, and secrets management to secure ASP.NET Core 10 from day one.

Single-Project Monolith: Why Fewer Projects Mean Better Code

Single-Project Monolith: why fewer projects mean better code — faster compiles, simpler DI, fewer merge conflicts, easier refactoring in one .NET 10 project.

Beginner's Guide to .NET 10: From Console App to Enterprise Template

Beginner's Guide to .NET 10: turn a console app into an enterprise template with folder structure, Vertical Slice Architecture, EF Core, and authentication.

EF Core 10 Migrations: Writing Seamless Schema Evolutions

EF Core 10 Migrations give you a repeatable way to evolve a schema without downtime — write clean migrations, use the model snapshot, and roll back safely.

ASP.NET Core Identity with JWT in a Vertical Slice App

ASP.NET Core Identity with JWT inside a vertical slice app: design an auth slice with register, login, refresh, and roles features in .NET 10 Blazor apps.

How to Ship Production-Ready .NET Apps Without an Ops Team

Production-Ready .NET Apps are achievable solo. Learn how freelancers use Docker, health checks, error tracking, and CI/CD to operate apps without an ops team.

Beginner's Guide to .NET 10: How to Learn by Reading Real Source Code

Beginner's Guide to .NET 10: learn C# faster by reading real source code, from open-source repositories to the full source code of Indotalent .NET 10 products.

EF Core 10 Migrations: A Complete Guide from Add to Deploy

EF Core 10 Migrations made simple: create your first migration, apply it to a database, and ship schema changes to production safely with this walkthrough.

ASP.NET Core Identity with JWT vs Cookie Authentication: Choosing Wisely

ASP.NET Core Identity with JWT vs cookie authentication: compare security, CSRF, and SignalR, and choose the right approach for your Blazor Server apps.

Production-Ready .NET Apps: Configuration, Logging, and Observability

Production-Ready .NET Apps need configuration, logging, and observability. Learn IOptions binding, Serilog, OpenTelemetry, and health checks in .NET 10.

ASP.NET Core 10 Features: Minimal APIs and Performance Improvements

ASP.NET Core 10 Features: Minimal APIs and performance improvements explained — typed results, endpoint filters, tiered compilation, native AOT, and more.

Audit Trail Implementation: Logging Every Change in Your .NET App

Audit Trail Implementation in .NET: capture who changed what, before and after values, timestamps, and user identity with concrete C# code from a real app.

How Freelance .NET Developers Ship Blazor Projects Faster

Freelance .NET Developer Tools that let you ship Blazor Server projects faster from day one: MudBlazor admin UIs, reusable slices, and one-command deployment.

Multi-Tenant SaaS .NET: The Complete Architecture Guide

Multi-Tenant SaaS .NET: tenant isolation, tenant resolution, shared vs per-tenant databases, EF Core query filters, and tenant-aware DI in ASP.NET Core 10.

REST API with Swagger: Design First vs Code First

REST API with Swagger: compare design-first OpenAPI contracts with code-first Swashbuckle generation, and choose the right approach for your .NET 10 team.

Single-Project Monolith: Keeping a Large Codebase Maintainable

Single-Project Monolith: Keeping a Large Codebase Maintainable — boundaries, namespaces, and tests that keep one .NET project healthy at 50k+ lines for years.

ASP.NET Core 10 Features: Real-World Impact on Enterprise Apps

ASP.NET Core 10 Features: how the latest framework improvements impact real enterprise apps — DI, resilience, observability, and Blazor Server in production.

Audit Trail Implementation with EF Core: Interceptors That Do the Work

Audit Trail Implementation with EF Core: use SaveChangesInterceptor and ChangeTracker to log changes automatically. C# examples for before and after values.

Multi-Tenant SaaS .NET: Building It with Blazor Server and VSA

Multi-Tenant SaaS .NET with Blazor Server and Vertical Slice Architecture: tenant-aware scoped services, EF Core query filters, and feature slices in practice.

Beginner's Guide to .NET 10: Blazor, EF Core, and Minimal APIs Explained

Beginner's Guide to .NET 10: see how Blazor, EF Core, and Minimal APIs work together with tiny examples, from a Hello World endpoint to a data-driven page.

ASP.NET Core Identity with JWT: Refresh Tokens, Roles, and Claims

ASP.NET Core Identity with JWT: refresh token rotation, role-based authorization, and claims policies in .NET 10 for your Blazor Server app and REST APIs.

MudBlazor UI Components: Customization, Theming, and Dark Mode

MudBlazor UI Components: customize MudTheme, typography, spacing, and dark mode with MudThemeProvider. Make your Blazor app look exactly like your brand.

Production-Ready .NET Apps: The Checklist Every Developer Should Follow

Production-Ready .NET Apps need more than working code. Use this checklist: configuration, health checks, resilience, secrets, CI/CD, and tested backups.

Admin Dashboard Template vs Building from Scratch: The Real Cost

Admin Dashboard Template vs building from scratch: the real cost in hours, maintenance, and risk — and when rolling your own .NET admin UI makes sense.

Beginner's Guide to .NET 10: Understanding the .NET Ecosystem

Beginner's Guide to .NET 10: understand the difference between the .NET runtime, SDK, ASP.NET Core, Blazor, EF Core, NuGet, and popular IDEs like Visual Studio.

Building an Enterprise Blazor Template: Folder Structure, Auth, and Tooling

Enterprise Blazor Template construction: folder structure, authentication, and tooling decisions that turn a Blazor Server project into a production platform.

ASP.NET Core Identity with JWT: The Complete Setup for .NET 10

ASP.NET Core Identity with JWT: complete .NET 10 setup with AddIdentity, AddJwtBearer, token generation, and securing your Blazor Server UI plus REST APIs.

MudBlazor UI Components vs Bootstrap and Radzen: An Honest Comparison

MudBlazor UI Components vs Bootstrap and Radzen: an honest comparison of developer experience, theming, performance, and licensing for production Blazor apps.

Admin Dashboard Template: 10 Features That Matter in Production

Admin Dashboard Template: the 10 features that matter most — authentication, navigation, dark mode, CRUD grids, charts, forms, theming, and performance.

Beginner's Guide to .NET 10: Your First Week as a .NET Developer

Beginner's Guide to .NET 10: install the .NET 10 SDK, create your first console app, learn C# basics, and use git in your first week as a .NET developer.

How to Choose an Enterprise Blazor Template for Your Next Project

Enterprise Blazor Template selection guide: the criteria to evaluate templates for auth, VSA, EF Core, MudBlazor, REST APIs, and long-term maintainability.

MudBlazor UI Components in Production: Tables, Forms, and Dialogs

MudBlazor UI Components in production: how MudDataGrid, MudForm, and MudDialog behave in real Blazor Server apps, with validation and performance patterns.

Admin Dashboard Template with MudBlazor: Free Options Worth Using

Admin Dashboard Template with MudBlazor: the best free options — MudBlazor docs template, MudBlazor.Extensions, and community templates for .NET Blazor.

C# 14 Features: Upgrade Checklist from C# 12

C# 14 Features upgrade checklist from C# 12: LangVersion, breaking changes, code style, and a step-by-step path to modern .NET 10. Includes the field keyword.

Enterprise Blazor Template vs Default `dotnet new blazor`: Side-by-Side

Enterprise Blazor Template vs default dotnet new blazor: a side-by-side comparison of auth, architecture, tooling, and readiness for production .NET 10 apps.

MudBlazor UI Components: 15 Components Every Blazor App Needs

MudBlazor UI Components every Blazor app needs: buttons, forms, data grids, dialogs, and more. A practical tour of 15 components with Razor code examples.

Admin Dashboard Template: The Complete Buyer's Guide for .NET Developers

Admin Dashboard Template buyer's guide for .NET — what to look for: auth, responsive sidebar, dark mode, CRUD grids, charts, forms, theming, and performance.

Multi-Tenant SaaS .NET: Authentication, Claims, and Tenant Resolution

Multi-Tenant SaaS .NET: authentication with JWT tenant claims, tenant-aware Scoped services, and tenant resolution from subdomains and tokens in .NET 10.

Building a REST API with Swagger and EF Core 10: End-to-End Tutorial

REST API with Swagger and EF Core 10: build a full CRUD API with entities, DbContext, minimal API endpoints, migrations, and Swagger docs in one tutorial.

ASP.NET Core 10 Features: Everything New in the Latest Release

ASP.NET Core 10 Features: everything new in the latest release — runtime, Minimal APIs, DI, middleware, and Blazor Server improvements. Complete guide.

Freelance .NET Developer Tools: From Hello World to Client-Ready in Days

Freelance .NET Developer Tools turn a blank folder into a client-ready demo in days: scaffold, wire auth and CRUD, then deploy with automated workflows.

Multi-Tenant SaaS .NET: Shared Database vs Database per Tenant

Multi-Tenant SaaS .NET: compare shared database, schema-per-tenant, and database-per-tenant isolation, plus cost, migrations, and EF Core filter implementation.

REST API with Swagger: Authentication, Versioning, and Best Practices

REST API with Swagger authentication and versioning: add JWT bearer security, Swagger UI Authorize, versioning, and production best practices for .NET 10.