commit 72a9b3fea1b6ef041ff73c87844095582a75fdea Author: Ismail Hamzah Date: Tue Jul 21 10:12:35 2026 +0700 initial commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..83ac317 --- /dev/null +++ b/.gitignore @@ -0,0 +1,17 @@ +# OS files +Thumbs.db +.DS_Store +*.swp +*.swo + +# IDE +.vscode/ +.idea/ +*.sublime-project +*.sublime-workspace + +# Development +node_modules/ +package-lock.json +yarn.lock +*.zip \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..6e7f5d7 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,16 @@ +# ===================================================================== +# Dockerfile untuk Indotalent Webstore (HTML Statis) +# ===================================================================== +# Web app HTML statis yang di-serve oleh Nginx +# ===================================================================== + +FROM nginx:alpine + +# Copy semua file HTML, CSS, JS, gambar ke folder default nginx +COPY . /usr/share/nginx/html + +# Expose port 80 +EXPOSE 80 + +# Nginx akan jalan otomatis +CMD ["nginx", "-g", "daemon off;"] \ No newline at end of file diff --git a/blog.html b/blog.html new file mode 100644 index 0000000..8e67e15 --- /dev/null +++ b/blog.html @@ -0,0 +1,138 @@ + + + + + + + + Blog — .NET 10, Blazor & Vertical Slice Architecture | Indotalent + + + + + + + + + + + + + + + + + + + + + + +

Technical Blog

Blog: .NET 10, Blazor & VSA

Production-proven patterns for building enterprise .NET applications. Deep dives, case studies, and practical guides.

+ +

AI + VSAJuly 2026 · 9 min read

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

How VSA's feature-centric design makes AI tools dramatically more effective. 1 file, 1 prompt vs 7 files, 6+ prompts.

+ + +

CQRSVSAMediatRJuly 2026 · 14 min read

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

How CQRS and MediatR inside Vertical Slice Architecture eliminate spaghetti code. Before-and-after: tangled controller vs. clean VSA slices.

+ + +

VSAJune 2026 · 8 min read

Introduction to Vertical Slice Architecture in .NET 10

How VSA organizes code by business features, why it beats layered architecture, and a concrete .NET 10 Minimal API example.

+ + +

Blazor ServerJune 2026 · 7 min read

Blazor Server vs WebAssembly: Choosing the Right Hosting Model

Compare Blazor Server and WASM for enterprise applications. Why Indotalent products use Blazor Server.

+ + +

VSAMay 2026 · 6 min read

How Vertical Slice Architecture Eliminates "Project Hell"

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

+ + +

VSAMay 2026 · 9 min read

Building Maintainable .NET Applications with MediatR and VSA

How MediatR enables CQRS within VSA slices. Pipeline behaviors for validation, logging, and transactions.

+ + +

MudBlazorApril 2026 · 5 min read

MudBlazor: The Ultimate Component Library for Blazor Server

50+ Material Design components. Why MudBlazor is the de facto standard for Blazor enterprise apps.

+ + +

Blazor ServerApril 2026 · 7 min read

Blazor Server Performance Optimization: Real-World Techniques

ShouldRender, virtualization, no-tracking queries, and server-side pagination for Blazor Server apps.

+ + +

VSAMarch 2026 · 10 min read

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.

+ + +

Blazor ServerMarch 2026 · 8 min read

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

Four-layer security: Identity, JWT, policy-based authorization, and SignalR protection.

+ + +

VSAFeb 2026 · 8 min read

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

7 files in 4 projects vs 1 file. A concrete code comparison of both approaches.

+ + +

VSAFeb 2026 · 6 min read

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

How each Indotalent product is built. The stack, the architecture, and what you get for $21.

+ +

Ready to Apply These Patterns?

Every Indotalent product is built with VSA, Blazor Server, and MudBlazor. Complete source code — $21.

+ Explore Products +

+ + + + \ No newline at end of file diff --git a/blog/blazor-hosting-model.html b/blog/blazor-hosting-model.html new file mode 100644 index 0000000..dd406ea --- /dev/null +++ b/blog/blazor-hosting-model.html @@ -0,0 +1,64 @@ + + + + + + + Blazor Server vs WebAssembly: Choosing the Right Hosting Model | Indotalent Blog + + + + + + + + + + + + + + + + +

Blazor ServerJune 2026 · 7 min read

Blazor Server vs WebAssembly: Choosing the Right Hosting Model

TL;DR

For enterprise applications handling sensitive data, Blazor Server is the recommended choice. It keeps your code and data secure on the server, provides sub-second initial load times, and simplifies deployment. All Indotalent products use Blazor Server.

Blazor offers two primary hosting models, and choosing between them has significant implications for your application's architecture, performance, and security posture. Understanding the trade-offs is essential before starting any enterprise Blazor project.

Blazor Server: The Enterprise Choice

Blazor Server executes all C# code on the server. The browser receives a thin HTML document and maintains a persistent SignalR WebSocket connection. Every UI event — button clicks, form submissions, data grid interactions — is serialized over this connection, processed server-side, and the resulting UI diff is sent back. This architecture delivers sub-second initial load times, full access to server resources (database connections, file system, caching), and superior security because your source code, connection strings, and business logic never leave the server.

Blazor WebAssembly: Offline-First

Blazor WASM downloads the entire .NET runtime and your application DLLs to the browser. This enables fully offline operation and reduces server load, but the initial download can be 5-20 MB, leading to slow first-visit experiences. WASM applications must communicate with the backend exclusively through HTTP APIs, adding latency and complexity compared to Server's direct SignalR connection.

The Verdict for Enterprise Apps

For enterprise applications handling sensitive data — CRM systems with customer PII, HRM systems with employee records, WMS systems with inventory data — Blazor Server is the recommended choice. It keeps your intellectual property and sensitive data secure on the server, provides instant load times for internal users, and simplifies the deployment architecture to a single process. All Indotalent products use Blazor Server for exactly these reasons.

Key Takeaways

Blazor Server = sub-second loads, server-side security, simpler deployment
Blazor WASM = offline capability, reduced server load, larger initial download
Choose Server for enterprise apps with sensitive data
All 9 Indotalent products are built with Blazor Server

See Blazor Server in action

Every Indotalent product is a complete Blazor Server application. Complete source code — $21 each.

Explore Products

← Back to Blog

+ + + \ No newline at end of file diff --git a/blog/blazor-performance-optimization.html b/blog/blazor-performance-optimization.html new file mode 100644 index 0000000..f53d873 --- /dev/null +++ b/blog/blazor-performance-optimization.html @@ -0,0 +1,42 @@ + + + + + + Blazor Server Performance Optimization: Real-World Techniques | Indotalent Blog + + + + + + + + + + + + + +

Blazor ServerApril 2026 · 7 min read

Blazor Server Performance Optimization: Real-World Techniques

TL;DR

Four techniques that cut rendering overhead by 50%+: ShouldRender overrides, MudBlazor virtualization, EF Core no-tracking queries, and server-side pagination. All Indotalent products ship with these baked in.

Blazor Server's SignalR-based architecture means every UI interaction involves a network round-trip. While this is fast on local networks or within the same datacenter, applications must be optimized for scenarios with higher latency or large datasets.

1. ShouldRender() Overrides

By default, Blazor re-renders a component when any of its parameters change. For components with complex rendering trees, override ShouldRender() to return false when no visual change is needed. This can cut rendering overhead by 50%+ in data-heavy pages.

2. Virtualization

MudBlazor's Virtualize component renders only the visible rows in a list. For grids with 10,000+ rows, this reduces DOM nodes from thousands to dozens, keeping the UI responsive even with massive datasets.

3. EF Core No-Tracking Queries

Read-only queries should use .AsNoTracking() to avoid EF Core's change tracking overhead. This can improve query performance by 30-50% for list views, dashboards, and reports.

4. Server-Side Pagination

Never load entire tables into memory. Implement pagination at the database level using .Skip() and .Take(). MudBlazor's data grid supports server-side pagination out of the box with its ServerData property.

Key Takeaways

Override ShouldRender() to cut rendering overhead by 50%+
Use MudBlazor virtualization for large datasets
Apply AsNoTracking() for all read-only EF Core queries
Implement server-side pagination — never load full tables

See optimized Blazor code

All Indotalent products ship with these optimizations. $21 each.

Explore Products

← Back to Blog

+ + + \ No newline at end of file diff --git a/blog/blazor-server-security-jwt.html b/blog/blazor-server-security-jwt.html new file mode 100644 index 0000000..38f15a2 --- /dev/null +++ b/blog/blazor-server-security-jwt.html @@ -0,0 +1,42 @@ + + + + + + Securing Your Blazor Server Application with JWT and ASP.NET Core Identity | Indotalent Blog + + + + + + + + + + + + + +

Blazor ServerMarch 2026 · 8 min read

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

TL;DR

Four-layer security: ASP.NET Core Identity for user management, JWT for API endpoints, policy-based authorization for fine-grained control, and SignalR protection for real-time channels.

Security is a layered concern in Blazor Server applications. The framework provides multiple protection mechanisms that must be configured correctly.

Layer 1: ASP.NET Core Identity

Identity provides user management, password hashing, role management, and cookie-based authentication. For Blazor Server, the default cookie authentication is sufficient for internal page access.

Layer 2: JWT for API Endpoints

When your Blazor app also exposes a REST API, cookies aren't appropriate. JWT bearer tokens provide stateless authentication. Indotalent products configure both authentication schemes simultaneously: cookies for Razor components, JWT for Minimal API endpoints.

Layer 3: Policy-Based Authorization

Role-based authorization works for simple cases, but policy-based authorization provides finer control. Define policies like "CanApproveOrders" or "CanViewFinancialReports" and apply them declaratively.

Layer 4: Secure SignalR

SignalR hubs handle real-time UI updates. Ensure hubs are protected with the [Authorize] attribute. Never transmit sensitive data through hub methods without encryption.

Key Takeaways

Identity + JWT dual authentication for Razor components and API endpoints
Policy-based authorization for fine-grained access control
SignalR hubs must be protected with [Authorize]
All Indotalent products come with pre-configured security layers

Explore secure Blazor products

All Indotalent products ship with JWT + Identity pre-configured. $21 each.

Explore Products

← Back to Blog

+ + + \ No newline at end of file diff --git a/blog/clean-architecture-to-vsa-migration.html b/blog/clean-architecture-to-vsa-migration.html new file mode 100644 index 0000000..b76c1f5 --- /dev/null +++ b/blog/clean-architecture-to-vsa-migration.html @@ -0,0 +1,40 @@ + + + + + + From Clean Architecture to Vertical Slices: A Practical Migration Guide | Indotalent Blog + + + + + + + + + + + + + +

VSAMarch 2026 · 10 min read

From Clean Architecture to Vertical Slices: A Practical Migration Guide

TL;DR

You don't need to rewrite your entire application. Migrate feature by feature. VSA preserves the good parts of Clean Architecture while reorganizing by business capability.

You don't need to rewrite your entire application to adopt VSA. The migration can be gradual, feature by feature. Here's the step-by-step approach I've used on production systems.

Phase 1: Pick One Feature

Choose a self-contained business operation — creating an order, registering a customer, processing a payment. Create a new folder: Features/[FeatureName]/. Inside, create a single file containing: the Minimal API endpoint mapping, the MediatR command or query record, and the handler class. Move the existing controller action logic and service layer code into the handler.

Phase 2: Extract Validation

If you're using FluentValidation, add a validator class in the same folder. If not, this is the perfect time to introduce it. Register validators via assembly scanning so they're discovered automatically.

Phase 3: Repeat

Continue migrating features one at a time. You'll notice that as more features move to VSA, the old layered structure becomes thinner. Eventually, you can delete entire projects that are now empty.

Key Takeaways

Migration is additive, not destructive — VSA features run alongside layered code
Start with one self-contained business operation
Add validation in the same feature folder using FluentValidation
Gradually delete empty projects as more features migrate

Get VSA-ready source code

Every Indotalent product demonstrates a complete VSA migration target. $21 each.

Explore Products

← Back to Blog

+ + + \ No newline at end of file diff --git a/blog/cqrs-mediatr-no-spaghetti-code.html b/blog/cqrs-mediatr-no-spaghetti-code.html new file mode 100644 index 0000000..de055ed --- /dev/null +++ b/blog/cqrs-mediatr-no-spaghetti-code.html @@ -0,0 +1,488 @@ + + + + + + + CQRS + MediatR in VSA: Make Your Code Not Spaghetti Code | Indotalent Blog + + + + + + + + + + + + + + +

CQRSVSAMediatRJuly 2026 · 14 min read

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

🍝 Spaghetti Code Alert

We're exposing real spaghetti code — the kind that lives inside traditional layered architecture controllers. Then we'll show you how CQRS + MediatR, powered by Vertical Slice Architecture, eliminates it completely.

+ +

Let's call it what it is: spaghetti code. Every .NET developer has seen it. Every developer has probably written it at 11 PM on a Friday, promising to refactor later. That controller with 700 lines of business logic, validation, database access, email sending, and who-knows-what-else — all tangled together into one unmaintainable mess. That is spaghetti code. And in a traditional layered architecture, spaghetti code is not the exception. It is the inevitable destination.

+ +

Why does layered architecture breed spaghetti code? Because the architecture itself scatters related logic across multiple projects and layers. An order creation feature touches 7 files across 4 projects: OrderController.cs, IOrderService.cs, OrderService.cs, IOrderRepository.cs, OrderRepository.cs, Order.cs, CreateOrderDto.cs. To understand how an order is created, you must mentally stitch together code from all these files — like following individual strands of spaghetti across the entire plate. The architecture itself creates the tangle. Spaghetti code isn't a developer problem in layered architecture; it's an architectural problem.

+ +

But there is a way out. CQRS (Command Query Responsibility Segregation) combined with MediatR, inside a Vertical Slice Architecture (VSA), eliminates spaghetti code at the architectural level. Instead of organizing code by technical layer — all controllers together, all services together, all repositories together — VSA organizes code by business feature. Each feature slice contains everything that feature needs: the command, the handler, the validator, and any domain logic. One folder. One feature. Zero spaghetti code.

+ +

The Problem: How Layered Architecture Creates Spaghetti Code

+ +

Before we dive into the VSA solution, let's understand exactly how layered architecture produces spaghetti code. The fundamental issue is that layered architecture groups code by what things are technically — controllers, services, repositories — rather than what they do for the business. This means that any single business operation is spread across multiple layers and multiple projects. When you need to trace the flow of "creating an order," you jump from the presentation layer to the application layer to the domain layer to the infrastructure layer. Each jump is an opportunity for spaghetti code to creep in.

+ +

Adding a new feature in layered architecture means touching files in every layer. Adding validation? That goes in the controller, or maybe the service, or maybe a FluentValidation validator injected into the service — the decision is arbitrary, and that arbitrariness is what spawns spaghetti code. Need to send an email after order creation? Do you put it in the service? The controller? A domain event? There's no clear answer in layered architecture, so developers just stuff it wherever it fits, and the spaghetti code grows thicker with every commit.

+ +

Before: Spaghetti Code in a Layered Architecture

+ +

Here's what spaghetti code looks like in a typical layered .NET application. This is a single OrdersController that handles creating an order. Notice how validation, data access, discount calculation, tax logic, email sending, and logging are all mashed together. This is textbook spaghetti code — every concern entangled with every other concern.

+ +

+ 🍝 SPAGHETTI CODE — Layered Architecture (BEFORE) +

// Controllers/OrdersController.cs
+// Spaghetti code: 7 concerns in 1 method across 4+ projects
+
+[ApiController]
+[Route("api/[controller]")]
+public class OrdersController : ControllerBase
+{
+    private readonly AppDbContext _context;
+    private readonly IEmailService _emailService;
+    private readonly ILogger _logger;
+
+    [HttpPost]
+    public async Task Create(CreateOrderDto dto)
+    {
+        // Spaghetti concern #1: Validation mixed inline
+        if (string.IsNullOrWhiteSpace(dto.CustomerEmail))
+            return BadRequest("Email required");
+        if (dto.Items == null || dto.Items.Count == 0)
+            return BadRequest("No items");
+
+        // Spaghetti concern #2: Direct data access in controller
+        var customer = await _context.Customers
+            .FirstOrDefaultAsync(c => c.Email == dto.CustomerEmail);
+        if (customer == null) return BadRequest("Customer not found");
+
+        decimal subtotal = 0;
+        var orderItems = new List();
+
+        foreach (var item in dto.Items)
+        {
+            var product = await _context.Products.FindAsync(item.ProductId);
+            if (product == null)
+                return BadRequest($"Product {item.ProductId} not found");
+
+            // Spaghetti concern #3: Business rules tangled with DB
+            if (product.Stock < item.Quantity)
+                return BadRequest($"Out of stock: {product.Name}");
+
+            // Spaghetti concern #4: Discount logic hardcoded
+            decimal discount = 0;
+            if (customer.IsPremium && product.Category == "Electronics")
+                discount = product.Price * 0.10m;
+            else if (customer.IsPremium)
+                discount = product.Price * 0.05m;
+            else if (item.Quantity > 10)
+                discount = product.Price * 0.02m;
+
+            var lineTotal = (product.Price - discount) * item.Quantity;
+            subtotal += lineTotal;
+
+            orderItems.Add(new OrderItem
+            {
+                ProductId = product.Id,
+                Quantity = item.Quantity,
+                UnitPrice = product.Price,
+                Discount = discount,
+                LineTotal = lineTotal
+            });
+
+            product.Stock -= item.Quantity;
+        }
+
+        // Spaghetti concern #5: Tax logic mixed in
+        decimal taxRate = customer.Country switch
+        {
+            "US" => 0.07m,
+            "UK" => 0.20m,
+            "AU" => 0.10m,
+            _ => 0.10m
+        };
+        decimal tax = subtotal * taxRate;
+        decimal total = subtotal + tax;
+
+        var order = new Order
+        {
+            CustomerId = customer.Id,
+            Subtotal = subtotal,
+            Tax = tax,
+            Total = total,
+            Status = "Pending",
+            CreatedAt = DateTime.UtcNow,
+            Items = orderItems
+        };
+
+        _context.Orders.Add(order);
+        await _context.SaveChangesAsync();
+
+        // Spaghetti concern #6: Email sending inside controller
+        await _emailService.SendAsync(customer.Email,
+            "Order Confirmed",
+            $"Dear {customer.Name}, order #{order.Id} total: {total:C}");
+
+        // Spaghetti concern #7: Logging embedded
+        _logger.LogInformation("Order {Id} created for {Email}",
+            order.Id, customer.Email);
+
+        return Ok(new { order.Id, order.Total });
+    }
+}

+ +

Look at this spaghetti code carefully. Seven distinct concerns — validation, data access, business rules, discount calculation, tax calculation, email notification, and logging — are all entangled in a single method. This is what layered architecture produces over time. Each new requirement adds another strand of spaghetti to the plate. Need to support a new country's tax rate? You're editing the same method that also handles email sending. Want to change how premium discounts work? You're touching code that also validates email addresses. The spaghetti code entanglement means you cannot change one thing without risking everything else.

+ +

And testing this spaghetti code? Forget about it. The discount logic is buried inside a loop that's inside a method that directly instantiates AppDbContext. You can't unit-test the discount calculation without spinning up a database. You can't test the tax logic without mocking an email service — which has nothing to do with tax. Spaghetti code doesn't just look bad. It actively prevents you from writing tests, which means you can't refactor, which means the spaghetti code gets worse. It's a death spiral.

+ +

The Solution: VSA + CQRS + MediatR = No Spaghetti Code

+ +

Vertical Slice Architecture flips the script entirely. Instead of organizing code by technical layer, VSA organizes by business feature. Every feature lives in its own folder. Inside that folder, you'll find the command/query, the handler, the validator, and any domain logic — all in one place. CQRS, implemented through MediatR, provides the messaging backbone. Commands (writes) and Queries (reads) are clearly separated. Cross-cutting concerns like validation and logging are handled by MediatR pipeline behaviors — written once, applied everywhere.

+ +

In VSA, the folder structure for our order creation feature looks like this:

+ +

Features/
+└── Orders/
+    ├── CreateOrder/
+    │   ├── CreateOrderCommand.cs      ← The command (DTO)
+    │   ├── CreateOrderHandler.cs      ← Business logic only
+    │   ├── CreateOrderValidator.cs    ← Validation rules
+    │   └── CreateOrderEndpoint.cs     ← Minimal API endpoint
+    ├── GetOrderById/
+    │   ├── GetOrderByIdQuery.cs
+    │   └── GetOrderByIdHandler.cs
+    └── Shared/
+        ├── Order.cs                   ← Domain entity
+        └── OrderItem.cs

+ +

One feature, one folder. No jumping between projects. No hunting through layers. No spaghetti code. When you need to understand how an order is created, you open the CreateOrder folder and everything is right there. When you need to add a new field to orders, you change files in one folder — not across four projects. This is the architectural antidote to spaghetti code.

+ +

After: Clean Code with VSA, CQRS, and MediatR

+ +

Now let's see the same order creation feature rebuilt with CQRS + MediatR inside a Vertical Slice Architecture. Every concern is separated. Every class has a single responsibility. There is not a trace of spaghetti code anywhere.

+ +

+ ✅ CLEAN CODE — VSA + CQRS + MediatR (AFTER) +

+ +

1. The Command — A Simple, Focused DTO

The command is a plain record. It carries data. Nothing else. This is not spaghetti code; it's a single-purpose data structure.

+ +

+ ✅ Features/Orders/CreateOrder/CreateOrderCommand.cs +

public record CreateOrderCommand(
+    string CustomerEmail,
+    List Items
+) : IRequest;
+
+public record OrderItemDto(Guid ProductId, int Quantity);
+public record CreateOrderResult(Guid OrderId, decimal Total);

+ +

2. The Validator — Validation Lives in Its Own Class

Validation is extracted into a dedicated FluentValidation validator. No validation logic pollutes the handler or the controller. This is how you prevent spaghetti code: one class, one job.

+ +

+ ✅ Features/Orders/CreateOrder/CreateOrderValidator.cs +

public class CreateOrderValidator
+    : AbstractValidator
+{
+    public CreateOrderValidator()
+    {
+        RuleFor(x => x.CustomerEmail)
+            .NotEmpty()
+            .EmailAddress();
+        RuleFor(x => x.Items)
+            .NotEmpty()
+            .Must(items => items.Count > 0);
+        RuleForEach(x => x.Items).ChildRules(item =>
+        {
+            item.RuleFor(i => i.ProductId)
+                .NotEqual(Guid.Empty);
+            item.RuleFor(i => i.Quantity)
+                .InclusiveBetween(1, 1000);
+        });
+    }
+}

+ +

3. The Handler — Business Logic Only, Zero Spaghetti Code

The handler is the heart of the feature slice. It contains only business logic. No validation (that's already done by the pipeline). No logging (also in the pipeline). No email sending (that's a domain event). Just pure, focused business logic — the polar opposite of spaghetti code.

+ +

+ ✅ Features/Orders/CreateOrder/CreateOrderHandler.cs +

public class CreateOrderHandler
+    : IRequestHandler
+{
+    private readonly AppDbContext _context;
+
+    public CreateOrderHandler(AppDbContext context)
+        => _context = context;
+
+    public async Task Handle(
+        CreateOrderCommand cmd, CancellationToken ct)
+    {
+        var customer = await _context.Customers
+            .Where(c => c.Email == cmd.CustomerEmail)
+            .FirstOrDefaultAsync(ct);
+
+        if (customer is null)
+            throw new NotFoundException("Customer not found");
+
+        var order = Order.Create(customer.Id);
+
+        foreach (var item in cmd.Items)
+        {
+            var product = await _context.Products
+                .FindAsync([item.ProductId], ct);
+
+            if (product is null)
+                throw new NotFoundException(
+                    $"Product {item.ProductId}");
+
+            product.ReserveStock(item.Quantity);
+
+            var discount = customer.CalculateDiscount(
+                product, item.Quantity);
+
+            order.AddItem(product, item.Quantity, discount);
+        }
+
+        order.CalculateTotals(customer.Country);
+
+        _context.Orders.Add(order);
+        await _context.SaveChangesAsync(ct);
+
+        order.AddDomainEvent(
+            new OrderCreatedDomainEvent(order.Id, customer.Email));
+
+        return new CreateOrderResult(order.Id, order.Total);
+    }
+}

+ +

4. Domain Logic — Rich, Testable, No Spaghetti Code

Business rules live in the domain entities themselves — where they belong. The discount calculation and stock reservation are methods on the entity, not buried in a controller. This is how you eliminate spaghetti code: put logic where it's discoverable.

+ +

+ ✅ Features/Orders/Shared/Order.cs (Domain Entity) +

public class Order
+{
+    public Guid Id { get; private set; }
+    public Guid CustomerId { get; private set; }
+    public decimal Subtotal { get; private set; }
+    public decimal Tax { get; private set; }
+    public decimal Total { get; private set; }
+    public OrderStatus Status { get; private set; }
+    public List Items { get; private set; } = [];
+
+    public static Order Create(Guid customerId)
+        => new() { Id = Guid.NewGuid(), CustomerId = customerId,
+                   Status = OrderStatus.Pending };
+
+    public void AddItem(Product product, int quantity, decimal discount)
+    {
+        var lineTotal = (product.Price - discount) * quantity;
+        Items.Add(new OrderItem
+        {
+            ProductId = product.Id,
+            Quantity = quantity,
+            UnitPrice = product.Price,
+            Discount = discount,
+            LineTotal = lineTotal
+        });
+        Subtotal += lineTotal;
+    }
+
+    public void CalculateTotals(string country)
+    {
+        Tax = Subtotal * TaxRate.For(country);
+        Total = Subtotal + Tax;
+    }
+
+    // Rich domain behavior — no spaghetti code here
+    public void MarkAsShipped() =>
+        Status = OrderStatus.Shipped;
+    public void Cancel() =>
+        Status = OrderStatus.Cancelled;
+}

+ +

5. Pipeline Behaviors — Cross-Cutting Concerns, Applied Once

MediatR pipeline behaviors are the secret weapon against spaghetti code. Instead of copying validation and logging code into every handler (which is how spaghetti code starts), you write it once as a behavior and it applies to every handler automatically. This is the DRY principle at the architectural level.

+ +

+ ✅ Pipeline/ValidationBehavior.cs — applied to ALL handlers +

public class ValidationBehavior
+    : IPipelineBehavior
+    where TRequest : IRequest
+{
+    private readonly IServiceProvider _sp;
+
+    public async Task Handle(TRequest request,
+        RequestHandlerDelegate next,
+        CancellationToken ct)
+    {
+        var validator = _sp.GetService<
+            IValidator>();
+
+        if (validator is not null)
+        {
+            var result = await validator
+                .ValidateAsync(request, ct);
+            if (!result.IsValid)
+                throw new ValidationException(
+                    result.Errors);
+        }
+
+        return await next();
+    }
+}

+ +

+ ✅ Pipeline/LoggingBehavior.cs — applied to ALL handlers +

public class LoggingBehavior
+    : IPipelineBehavior
+    where TRequest : IRequest
+{
+    private readonly ILogger> _logger;
+
+    public async Task Handle(TRequest request,
+        RequestHandlerDelegate next,
+        CancellationToken ct)
+    {
+        var name = typeof(TRequest).Name;
+        _logger.LogInformation("➡️ {Name} started", name);
+        var sw = Stopwatch.StartNew();
+        var response = await next();
+        sw.Stop();
+        _logger.LogInformation(
+            "✅ {Name} completed in {Ms}ms", name, sw.ElapsedMilliseconds);
+        return response;
+    }
+}

+ +

6. Domain Events — Side Effects, Not Spaghetti Code

Email sending after order creation is a side effect — it doesn't belong in the handler. With domain events, the handler raises an event, and a separate handler sends the email. No spaghetti code entanglement between order creation and email sending.

+ +

+ ✅ Features/Orders/CreateOrder/OrderCreatedDomainEventHandler.cs +

public class OrderCreatedDomainEventHandler
+    : INotificationHandler
+{
+    private readonly IEmailService _email;
+    private readonly AppDbContext _context;
+
+    public async Task Handle(
+        OrderCreatedDomainEvent evt, CancellationToken ct)
+    {
+        var customer = await _context.Customers
+            .FindAsync([evt.CustomerId], ct);
+
+        await _email.SendAsync(customer!.Email,
+            "Order Confirmed ✅",
+            $"Your order #{evt.OrderId} is being processed.");
+    }
+}

+ +

7. The Endpoint — Thin, Clean, No Spaghetti Code

In VSA, the endpoint (whether a controller action or Minimal API) is razor-thin. It does exactly one thing: send the command through MediatR. That's it. This is what "no spaghetti code" looks like at the API surface.

+ +

+ ✅ Features/Orders/CreateOrder/CreateOrderEndpoint.cs +

public static class CreateOrderEndpoint
+{
+    public static void Map(IEndpointRouteBuilder app)
+    {
+        app.MapPost("/api/orders", async (
+            CreateOrderCommand cmd,
+            IMediator mediator,
+            CancellationToken ct) =>
+        {
+            var result = await mediator.Send(cmd, ct);
+            return Results.Created(
+                $"/api/orders/{result.OrderId}", result);
+        })
+        .WithName("CreateOrder")
+        .WithTags("Orders");
+    }
+}

+ +

The Spaghetti Code Comparison: Side by Side

+ +

Let's put it side by side so the difference is undeniable. On the left: the spaghetti code layered approach. On the right: the clean VSA + CQRS + MediatR approach.

+ +

+ + + + + + + + + + + + + +

🍝 Layered Spaghetti Code	✅ VSA + CQRS + MediatR
7 files across 4+ projects per feature	3-4 files in 1 folder per feature
Validation scattered across controllers and services	Single FluentValidation validator per command
Business logic mixed with data access	Handler = business logic only
Logging copied into every method	One LoggingBehavior for all handlers
Email sending embedded in controller	Decoupled domain event handler
Impossible to unit test individual concerns	Every class is independently testable
One change touches unrelated code	Changes stay within the feature folder

+ +

Why CQRS + MediatR + VSA Is the Spaghetti Code Antidote

+ +

The combination of these three patterns doesn't just reduce spaghetti code — it makes it architecturally impossible. Here's why each piece matters:

+ +

Vertical Slice Architecture groups code by feature, not by technical layer. Since all the code for "create an order" lives in one folder, there's no temptation to scatter logic across projects. The architecture itself enforces cohesion. You cannot create spaghetti code when everything for a feature is co-located.

+ +

CQRS forces you to separate reads from writes. A command handler only handles commands. A query handler only handles queries. You can't accidentally mix read logic into a write operation because the interfaces are different: IRequest for commands, IRequest for queries. The type system itself prevents spaghetti code.

+ +

MediatR provides the pipeline that handles cross-cutting concerns. Validation, logging, transaction management, authorization — these are all behaviors that execute before and after your handler. Your handler doesn't know about them. They don't know about your handler. This is the separation of concerns that spaghetti code violates, enforced by the framework.

+ +

🔥 Indotalent Insight

Every Indotalent product — from the CRM to the WMS, from the HRM to the CMS — is built with exactly this architecture: VSA + CQRS + MediatR. Not a single line of spaghetti code. You get the complete source code for $21, and you can see for yourself how a production-grade .NET 10 application looks when it's clean from the ground up.

+ +

Key Takeaways

Layered architecture breeds spaghetti code by scattering related logic across multiple projects and layers — 7 files in 4 projects for one feature.
VSA eliminates spaghetti code by grouping all code for a feature in a single folder — 3-4 files, one place, full cohesion.
CQRS prevents concerns from mixing — commands and queries are different types, so you can't accidentally blend read and write logic.
MediatR pipeline behaviors handle cross-cutting concerns once, stopping the copy-paste spaghetti code cycle dead in its tracks.
Domain events decouple side effects — email sending, audit logging, and cache invalidation live in their own handlers, not tangled into business logic.
The result is fully testable code — every class has one responsibility, making unit testing trivial compared to the spaghetti code alternative.

+ +

Stop Writing Spaghetti Code. Start with VSA.

+ +

Spaghetti code isn't a personality trait. It's not something you're doomed to write because you're a "messy" developer. Spaghetti code is a symptom of the wrong architecture. When your architecture scatters related code across layers and projects, it rewards tangling. When your architecture groups code by feature, it rewards cleanliness. VSA + CQRS + MediatR is that clean architecture — and once you try it, you'll wonder how you ever tolerated spaghetti code.

+ +

The next time you open a controller and find 700 lines of intertwined logic, remember: it's not your fault. But it is your responsibility to fix it. And the fix has a name: CQRS + MediatR, inside a Vertical Slice Architecture. No more spaghetti code. Just clean, maintainable, testable .NET applications that make you proud to call yourself a developer.

+ +

Explore VSA + CQRS + MediatR in Production

See how Indotalent products implement this exact architecture. Zero spaghetti code. Complete source — $21 each.

Explore Products

← Back to Blog

+ + + +Write file to 'blog/cqrs-mediatr-no-spaghetti-code.html'. \ No newline at end of file diff --git a/blog/index.html b/blog/index.html new file mode 100644 index 0000000..7701d41 --- /dev/null +++ b/blog/index.html @@ -0,0 +1,128 @@ + + + + + + + + Blog — .NET 10, Blazor & Vertical Slice Architecture | Indotalent + + + + + + + + + + + + + + + + + + + + + + +

Technical Blog

Blog: .NET 10, Blazor & VSA

Production-proven patterns for building enterprise .NET applications. Deep dives, case studies, and practical guides.

+ +

VSAJune 2026 · 8 min read

Introduction to Vertical Slice Architecture in .NET 10

How VSA organizes code by business features, why it beats layered architecture, and a concrete .NET 10 Minimal API example.

+ + +

Blazor ServerJune 2026 · 7 min read

Blazor Server vs WebAssembly: Choosing the Right Hosting Model

Compare Blazor Server and WASM for enterprise applications. Why Indotalent products use Blazor Server.

+ + +

VSAMay 2026 · 6 min read

How Vertical Slice Architecture Eliminates "Project Hell"

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

+ + +

VSAMay 2026 · 9 min read

Building Maintainable .NET Applications with MediatR and VSA

How MediatR enables CQRS within VSA slices. Pipeline behaviors for validation, logging, and transactions.

+ + +

MudBlazorApril 2026 · 5 min read

MudBlazor: The Ultimate Component Library for Blazor Server

50+ Material Design components. Why MudBlazor is the de facto standard for Blazor enterprise apps.

+ + +

Blazor ServerApril 2026 · 7 min read

Blazor Server Performance Optimization: Real-World Techniques

ShouldRender, virtualization, no-tracking queries, and server-side pagination for Blazor Server apps.

+ + +

VSAMarch 2026 · 10 min read

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.

+ + +

Blazor ServerMarch 2026 · 8 min read

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

Four-layer security: Identity, JWT, policy-based authorization, and SignalR protection.

+ + +

VSAFeb 2026 · 8 min read

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

7 files in 4 projects vs 1 file. A concrete code comparison of both approaches.

+ + +

VSAFeb 2026 · 6 min read

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

How each Indotalent product is built. The stack, the architecture, and what you get for $21.

+ +

Ready to Apply These Patterns?

Every Indotalent product is built with VSA, Blazor Server, and MudBlazor. Complete source code — $21.

+ Explore Products +

+ + + + \ No newline at end of file diff --git a/blog/mudblazor-component-library.html b/blog/mudblazor-component-library.html new file mode 100644 index 0000000..8d31a6a --- /dev/null +++ b/blog/mudblazor-component-library.html @@ -0,0 +1,39 @@ + + + + + + MudBlazor: The Ultimate Component Library for Blazor Server | Indotalent Blog + + + + + + + + + + + + + + +

MudBlazorApril 2026 · 5 min read

MudBlazor: The Ultimate Component Library for Blazor Server

TL;DR

MudBlazor provides 50+ Material Design components written in pure C# and Razor. With native two-way binding and a unified theming system, the MudDataGrid alone saves days of development.

MudBlazor has become the de facto standard component library for Blazor enterprise applications. It provides over 50 Material Design components — from simple buttons and inputs to complex data grids, charts, and date pickers — all designed specifically for Blazor's component model.

Why MudBlazor Wins

Unlike wrapping JavaScript libraries, MudBlazor components are written in pure C# and Razor. This means two-way binding works natively, event callbacks are type-safe, and components compose naturally through cascading parameters. The MudDataGrid alone handles sorting, filtering, pagination, and inline editing with minimal configuration — functionality that would take days to build from scratch. For enterprise apps like CRM or WMS systems that are data-grid heavy, MudBlazor's grid component is a massive productivity multiplier.

Consistent Theming

MudBlazor's theming system provides consistent typography, spacing, and color across all components. You define your brand colors once in MudTheme, and every component respects it. This ensures the 50+ pages in a typical Indotalent product look cohesive without writing custom CSS for each page.

Key Takeaways

50+ components written in pure C# — no JavaScript wrappers
MudDataGrid handles sorting, filtering, pagination, and inline editing out of the box
Unified theming ensures visual consistency across entire applications
All Indotalent products are built with MudBlazor 9

See MudBlazor in production

Every Indotalent product uses MudBlazor for its UI. $21 each.

Explore Products

← Back to Blog

+ + + \ No newline at end of file diff --git a/blog/real-world-vsa-net10.html b/blog/real-world-vsa-net10.html new file mode 100644 index 0000000..da7bc68 --- /dev/null +++ b/blog/real-world-vsa-net10.html @@ -0,0 +1,40 @@ + + + + + + Real-World VSA: Shipping Production-Ready .NET 10 Apps with Indotalent | Indotalent Blog + + + + + + + + + + + + + +

VSAFeb 2026 · 6 min read

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

TL;DR

Every Indotalent product is a complete .NET 10 application with 50-100 VSA feature slices, ready to deploy or customize. Clone, configure connection string, press F5 — running in 60 seconds.

Every Indotalent product is a complete, production-ready .NET 10 application built on Vertical Slice Architecture. These aren't templates or starter kits — they're full enterprise applications with 50-100 feature slices each, ready to deploy or customize.

The Production Stack

Each product runs on an identical, battle-tested stack: .NET 10 + ASP.NET Core 10 Minimal APIs for the backend, Blazor Server + MudBlazor 9 for the UI, MediatR for CQRS within VSA slices, FluentValidation for request validation, Entity Framework Core + SQL Server for data access with migrations and seed data, and JWT + ASP.NET Core Identity for authentication and role-based authorization.

What You Get

A single Visual Studio solution that compiles in seconds. You clone the repo, configure your SQL Server connection string, run EF Core migrations (which automatically seed demo data), and press F5. The entire application — backend API, Blazor Server UI, database — runs locally in under 60 seconds from clone to working app.

The Price

Every product is priced at $21 (regularly $49) — accessible pricing for individual developers, freelancers, and small agencies. You get the complete, unrestricted source code with lifetime access. Study the architecture, extend it for clients, or deploy it as-is. Your purchase directly supports ongoing open-source development and keeps these products affordable for the .NET community.

Key Takeaways

9 complete .NET 10 applications, each with 50-100 VSA feature slices
Identical production stack across all products for skill transferability
Clone → configure connection string → F5 = running app in 60 seconds
$21 each, lifetime access, complete unrestricted source code

Get production-ready VSA source code

9 products. Complete source code. $21 each.

Explore Products

← Back to Blog

+ + + \ No newline at end of file diff --git a/blog/vsa-ai-assisted-development.html b/blog/vsa-ai-assisted-development.html new file mode 100644 index 0000000..85465f6 --- /dev/null +++ b/blog/vsa-ai-assisted-development.html @@ -0,0 +1,196 @@ + + + + + + + Why Vertical Slice Architecture is the Best Architecture for AI-Assisted Development | Indotalent Blog + + + + + + + + + + + + + + + + + + + + + + + + +

+ AI + VSA + July 2026 · 9 min read +

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

+ +

TL;DR

VSA organizes every feature — from API endpoint to database query — in a single folder. This means AI tools like GitHub Copilot, Cursor, and ChatGPT have all the context they need in one place. No jumping between 7 projects. No missing abstractions. Just one folder, one feature, one perfect context window for AI. This is the architecture that makes AI-assisted development actually work.

+ +

The Problem: AI Doesn't Understand Your Project Structure

Here's what happens when you use AI coding tools with traditional Clean Architecture:

You ask Copilot to "add a validation rule to the Create Order endpoint." Copilot looks at the file you're in — maybe CreateOrderCommand.cs in the Application project. It generates code. But the code is wrong because Copilot can't see that the validation should also check a business rule in the Domain project, a permission defined in the Infrastructure project, and an existing query in the Persistence project. Those are in different folders, different projects, different context windows.

You end up playing ping-pong with the AI: "No, also check this..." — "Wait, there's another rule in..." — "The repository interface is actually..." Each round-trip is a context switch. Each context switch is a chance for the AI to hallucinate.

+ +

🔑 The Core Insight

AI tools work best when all relevant code is visible within a single context window. VSA puts all feature code in one folder. Traditional architecture scatters it across 5-7 projects. Guess which one produces better AI-generated code?

+ +

How VSA Makes AI 10x More Effective

+ +

❌ Layered Architecture + AI

• AI sees 1 of 7 files in context
• Generated code misses cross-project dependencies
• Developer must manually assemble context
• Every prompt needs 5+ files as reference
• High hallucination rate

✅ VSA + AI

• AI sees endpoint + handler + DTOs + queries
• Single file has complete feature context
• Developer opens 1 file, AI understands everything
• One prompt = complete feature modification
• Dramatically lower hallucination rate

+ +

A Real Scenario: Adding a Field with AI

Let's walk through a concrete example. You need to add a DiscountCode field to the Create Order feature.

+ +

In Layered Architecture (The Painful Way)

Open Controllers/OrdersController.cs — tell AI about the endpoint
Open Application/Orders/CreateOrderCommand.cs — tell AI about the DTO
Open Application/Orders/CreateOrderHandler.cs — tell AI about the business logic
Open Domain/Entities/Order.cs — tell AI about the domain model
Open Infrastructure/Persistence/AppDbContext.cs — tell AI about the EF configuration
Run EF Core migration — another context switch

7 files. 4 projects. 6+ AI prompts. Each prompt is a new context window. Each context window is a chance for the AI to forget what you told it 3 prompts ago. This is why AI-generated code in layered projects is notoriously unreliable.

+ +

In Vertical Slice Architecture (The Elegant Way)

Open Features/Orders/CreateOrder.cs
Tell AI: "Add a DiscountCode string property. Validate it's max 20 chars. Save it to the Order entity. Return it in the response DTO."
AI sees the endpoint, command, handler, and validation — all in one file. Generates correct code in one shot.

1 file. 1 folder. 1 prompt. This is the difference between fighting your AI tools and flowing with them.

+ +

The Context Window is Everything

Modern AI coding assistants — GitHub Copilot, Cursor, Claude, ChatGPT — all operate on a context window. They can "see" the file you're editing plus some surrounding context (open tabs, recently viewed files). The quality of their output is directly proportional to the quality and completeness of that context.

VSA maximizes context quality by design:

Endpoint + Handler + DTOs in one file: The AI sees the HTTP contract, business logic, and data shapes simultaneously. It won't generate a handler that returns a DTO the endpoint can't serialize.
Validation in the same folder: The AI knows the validation rules exist. It won't generate business logic that bypasses validation.
EF Core queries inline: The AI sees exactly how data is fetched. It won't hallucinate repository methods that don't exist.

+ +

AI-Friendly Means Developer-Friendly

Here's the beautiful symmetry: what makes code AI-friendly is exactly what makes it human-friendly. Maximum cohesion. Minimum scattering. One concept per folder. No abstractions between you and the business logic.

When a new developer joins your team and you say "add a discount code to order creation," they should be able to do it by reading one file. That same principle applies to AI tools. The architecture that's best for humans is also best for machines. VSA delivers both.

+ +

Indotalent Products: Built for the AI Era

Every Indotalent product is a single .NET 10 Blazor Server project built with Vertical Slice Architecture. Each feature — 50 to 100 per application — lives in its own folder Features/[FeatureName]/ with its endpoint, MediatR handler, FluentValidation validator, and EF Core queries all in one place.

This means:

GitHub Copilot generates accurate code because all context is in one file
Cursor AI understands complete features in a single tab
ChatGPT & Claude can be given one file as reference and generate correct modifications
You spend less time debugging AI hallucinations and more time shipping features

+ +

Key Takeaways

VSA keeps all feature code in one folder — the perfect context window for AI tools
Layered architecture forces AI to work with fragmented context → high hallucination rate
Adding a field in VSA: 1 file, 1 prompt. In layered: 7 files, 6+ prompts
AI-friendly architecture = human-friendly architecture = Vertical Slice Architecture
All 9 Indotalent products are VSA monoliths — ready for AI-assisted customization

+ +

Stop fighting your AI tools. Start using VSA.

Every Indotalent product is a complete VSA application — the perfect foundation for AI-assisted development. $21 each.

+ Explore Products +

+ +

← Back to Blog

+ + + + \ No newline at end of file diff --git a/blog/vsa-eliminates-project-hell.html b/blog/vsa-eliminates-project-hell.html new file mode 100644 index 0000000..4f50923 --- /dev/null +++ b/blog/vsa-eliminates-project-hell.html @@ -0,0 +1,44 @@ + + + + + + + How Vertical Slice Architecture Eliminates "Project Hell" | Indotalent Blog + + + + + + + + + + + + + + +

VSAMay 2026 · 6 min read

How Vertical Slice Architecture Eliminates "Project Hell"

TL;DR

Organizing by technical concern scatters related code across the codebase. VSA reorganizes around business capabilities. Every Indotalent product is a single .NET project where all code for a feature lives in one folder.

I've worked on enterprise .NET solutions with 15+ projects in a single solution. The cognitive overhead was staggering. To implement a new feature, you'd touch files in Application/, Domain/, Infrastructure/, Persistence/, Web/, SharedKernel/, and Contracts/. Compilation times climbed past 30 seconds. New developers took weeks to become productive. This is what I call "Project Hell."

The Root Cause

The problem isn't Clean Architecture's principles — dependency inversion, separation of concerns, and testability are all good things. The problem is that organizing by technical concern (all controllers here, all services there) scatters related code across the codebase. When a feature changes, you must hunt across multiple projects to understand the impact.

The VSA Solution

VSA reorganizes the same principles around business capabilities. Every Indotalent product is a single .NET project. All code for a feature lives in one folder. The API endpoint, MediatR handler, validation, and EF Core queries sit together. Compilation takes seconds. Adding a feature means creating one folder with one file. Need to understand how Sales Orders work? Open Features/SalesOrders/ and read through. Everything is there.

Key Takeaways

Layered architecture scatters related code across 5-15 projects
Single-project VSA monolith compiles in seconds with zero cognitive overhead
New developers become productive on day one by reading one feature slice
All 9 Indotalent products demonstrate this architecture in production code

See Single-Project VSA in action

Every Indotalent product is a single .NET project with VSA. $21 each.

Explore Products

← Back to Blog

+ + + \ No newline at end of file diff --git a/blog/vsa-introduction.html b/blog/vsa-introduction.html new file mode 100644 index 0000000..c31a731 --- /dev/null +++ b/blog/vsa-introduction.html @@ -0,0 +1,147 @@ + + + + + + + + Introduction to Vertical Slice Architecture in .NET 10 | Indotalent Blog + + + + + + + + + + + + + + + + + + + + + + + + +

VSAJune 2026 · 8 min read

Introduction to Vertical Slice Architecture in .NET 10

+ +

TL;DR

Vertical Slice Architecture organizes code by business features instead of technical layers. In .NET 10, you can define an entire feature — endpoint, DTOs, validation, and handler — in a single C# file. This maximizes cohesion, reduces cognitive overhead, and lets you add features without touching 7 different projects.

+ +

Vertical Slice Architecture (VSA) is a software design approach that organizes code by business features rather than technical layers. In a traditional layered architecture, implementing a "Create Order" feature means working across Controllers/, Services/, Repositories/, Domain/, and DTOs/ — often spread across 5+ separate projects. VSA flips this on its head: everything for "Create Order" lives in one folder, one file, or at most a small cluster of files within a single project.

+ +

Why VSA Matters in .NET 10

.NET 10's Minimal APIs make VSA more natural than ever. You can define an entire feature — endpoint, request/response DTOs, validation, and handler logic — in a single C# file using top-level statements and MediatR. The result is maximum cohesion: everything you need to understand a feature is in one place. No more jumping between 7 projects in Solution Explorer just to trace a single user action.

+ +

Key Benefits

Maximum Cohesion: All code for a feature lives together. When you need to modify "Create Order," you open one file.
Faster Onboarding: New developers understand a feature by reading a single file, not tracing through 5 projects.
Reduced Merge Conflicts: Teams working on different features rarely touch the same files.
Easier Testing: Each slice is self-contained and can be tested in isolation.

+ +

A Concrete Example

// Features/Orders/CreateOrder.cs
+public static class CreateOrderEndpoint
+{
+    public static void Map(IEndpointRouteBuilder app) =>
+        app.MapPost("/api/orders", async (CreateOrderCommand cmd, IMediator m) =>
+            Results.Ok(await m.Send(cmd)));
+}
+
+public record CreateOrderCommand(string CustomerId, List Items) : IRequest;
+
+public class CreateOrderHandler : IRequestHandler
+{
+    readonly AppDbContext _db;
+    public CreateOrderHandler(AppDbContext db) => _db = db;
+    public async Task Handle(CreateOrderCommand cmd, CancellationToken ct)
+    {
+        var order = Order.Create(cmd.CustomerId, cmd.Items);
+        _db.Orders.Add(order);
+        await _db.SaveChangesAsync(ct);
+        return OrderDto.FromEntity(order);
+    }
+}

That's it. One file contains the API endpoint, the command, the handler, and the result DTO. When you need to modify how orders are created, you open this file. When a new developer joins, they read this file and understand the entire flow. This is the power of VSA.

+ +

Key Takeaways

VSA organizes by business capability, not technical concern
.NET 10 Minimal APIs + MediatR make VSA natural and concise
Every Indotalent product uses this architecture — study real production code
One file = one feature = zero confusion

+ +

Ready to study real VSA code?

Every Indotalent product is a complete .NET 10 application built with Vertical Slice Architecture. Complete source code — $21 each.

+ Explore Products +

+ +

← Back to Blog

+ + + + \ No newline at end of file diff --git a/blog/vsa-mediatr.html b/blog/vsa-mediatr.html new file mode 100644 index 0000000..c992b64 --- /dev/null +++ b/blog/vsa-mediatr.html @@ -0,0 +1,52 @@ + + + + + + + Building Maintainable .NET Applications with MediatR and VSA | Indotalent Blog + + + + + + + + + + + + + + +

VSAMay 2026 · 9 min read

Building Maintainable .NET Applications with MediatR and VSA

TL;DR

MediatR is the backbone of VSA in .NET. It implements the Mediator pattern with IRequest and pipeline behaviors for cross-cutting concerns like validation, logging, and transactions.

MediatR is more than just a mediator library — it's the backbone of effective Vertical Slice Architecture in .NET. It implements the Mediator pattern with two key abstractions: IRequest for commands/queries and IRequestHandler for their handlers.

Commands, Queries, and CQRS

In VSA, each feature slice exposes its API through MediatR. Commands (which mutate state) are separate from Queries (which read state). This is CQRS — Command Query Responsibility Segregation — and it maps naturally onto VSA. A CreateOrderCommand and its handler live in Features/Orders/. The handler uses EF Core to persist the order. A GetOrderByIdQuery also lives in the same folder, optimized for reads with EF Core's no-tracking queries.

Pipeline Behaviors: Cross-Cutting Concerns

MediatR's pipeline behaviors handle cross-cutting concerns without cluttering business logic. Logging, validation, and transaction management are implemented once as behaviors and applied to all handlers automatically:

public class ValidationBehavior 
+    : IPipelineBehavior
+{
+    public async Task Handle(TRequest req, 
+        RequestHandlerDelegate next, CancellationToken ct)
+    {
+        var validator = _validators.GetValidator();
+        if (validator != null) await validator.ValidateAsync(req, ct);
+        return await next();
+    }
+}

This keeps your handlers clean — they focus purely on business logic while behaviors handle the plumbing.

Key Takeaways

MediatR provides the CQRS backbone for VSA feature slices
Pipeline behaviors eliminate duplicated cross-cutting code
Indotalent products ship with pre-configured MediatR pipelines

Explore VSA Products

Every Indotalent product uses MediatR + VSA. Complete source code — $21 each.

Explore Products

← Back to Blog

+ + + \ No newline at end of file diff --git a/blog/vsa-vs-layered-architecture.html b/blog/vsa-vs-layered-architecture.html new file mode 100644 index 0000000..afba22b --- /dev/null +++ b/blog/vsa-vs-layered-architecture.html @@ -0,0 +1,40 @@ + + + + + + Vertical Slice Architecture vs Traditional Layered Architecture: Side-by-Side Code | Indotalent Blog + + + + + + + + + + + + + +

VSAFeb 2026 · 8 min read

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

TL;DR

Traditional approach: 7 files across 4 projects for one feature. VSA: 1 file in 1 folder. Same functionality, zero cognitive overhead for VSA.

Let's compare how the same "Create Customer" feature looks in both architectures.

Traditional Layered Approach

Files you must touch across a typical Clean Architecture solution:

Controllers/CustomersController.cs — HTTP endpoint
Application/Customers/CreateCustomerCommand.cs — DTO
Application/Customers/CreateCustomerHandler.cs — business logic
Application/Common/Interfaces/IAppDbContext.cs — abstraction
Domain/Entities/Customer.cs — domain entity
Infrastructure/Persistence/AppDbContext.cs — EF Core context
Web/Program.cs — DI registration

Seven files across four projects. When a bug is reported in customer creation, you must trace the flow through all of them.

VSA Approach

One file in one folder Features/Customers/CreateCustomer.cs contains: the Minimal API endpoint, the MediatR command, the handler with all business logic, the EF Core query, and the response DTO. When a bug is reported, you open one file. When you need to add a field to customer creation, you edit one file. This is the essence of VSA: maximum cohesion, minimum scattering.

Key Takeaways

Layered: 7 files, 4 projects. VSA: 1 file, 1 folder.
Bug tracing: hours vs minutes
Feature addition: touch 7 files vs touch 1 file
All Indotalent products demonstrate this VSA pattern in production code

Compare with Indotalent VSA code

Every product demonstrates VSA in a real, working application. $21 each.

Explore Products

← Back to Blog

+ + + \ No newline at end of file diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..124476b --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,34 @@ +# ===================================================================== +# Indotalent Webstore - Docker Compose untuk Portainer Stack +# ===================================================================== +# Web app statis, routing via Nginx Proxy Manager (container name) +# Tidak perlu expose port ke host! +# ===================================================================== + +services: + indotalent-webstore: + build: + context: . + dockerfile: Dockerfile + container_name: indotalent-webstore + restart: unless-stopped + # TIDAK PERLU ports: - routing via NPM ke container name + expose: + - 80 + networks: + - indotalent-network + # ================================================================= + # RESOURCE LIMITS + # ================================================================= + # Nginx ringan, tapi tetap dibatasi + mem_limit: 64m # Max 64 MB RAM + mem_reservation: 32m # Minimal 32 MB RAM + cpus: '0.1' # Max 10% dari 1 CPU core + labels: + - "indotalent.service=indotalent-webstore" + - "indotalent.description=Indotalent Webstore HTML Static" + +networks: + indotalent-network: + external: true + name: indotalent-network \ No newline at end of file diff --git a/favicon.ico b/favicon.ico new file mode 100644 index 0000000..6ca26be Binary files /dev/null and b/favicon.ico differ diff --git a/for-beginners.html b/for-beginners.html new file mode 100644 index 0000000..281ac37 --- /dev/null +++ b/for-beginners.html @@ -0,0 +1,200 @@ + + + + + + + + Learn .NET 10 & Blazor from Scratch with Complete Source Code | Indotalent + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

For Beginners & Students

Learn .NET 10 & Blazor from Scratch

Stop watching tutorials. Start studying real, production-grade enterprise source code that compiles and runs in 60 seconds.

+ + +

Why Source Code Beats Tutorials

Tutorials Show Fragments

Blog posts and videos show isolated code snippets. They never show how authentication connects to the database, how the API plugs into the UI, or how 50 features coexist in one project.

Source Code Shows the Whole Picture

Clone one Indotalent repo and you see everything: project structure, middleware pipeline, EF Core configuration, MudBlazor component composition, JWT auth flow, and database seed data — all working together.

Tutorials Go Outdated

A YouTube tutorial from 2023 uses .NET 7 patterns that don't compile on .NET 10. Indotalent products are updated for the latest .NET release with modern APIs and patterns.

You Can Ship It

The best part: after studying the code, you can use it as a foundation for your own project. It's a working app you can customize, extend, and deploy — not just a learning exercise.

+ + +

What You'll Learn from Each Product

🔷 .NET 10 & C# Fundamentals

See how professional C# code is structured: records, LINQ, dependency injection, async/await patterns, and minimal API endpoints.

🔷 Blazor Server UI

Learn component-based UI development with MudBlazor. Study data grids, forms, dialogs, and navigation patterns used in real apps.

🔷 Database Design & EF Core

Understand entity relationships, migrations, seed data, and LINQ queries through a working SQL Server database.

🔷 Authentication & Security

Study a complete JWT + ASP.NET Core Identity implementation with role-based authorization, user management, and secure API endpoints.

🔷 REST API Design

Explore clean REST API patterns with Swagger/OpenAPI documentation, proper HTTP status codes, and request validation.

🔷 Project Architecture

Grasp Vertical Slice Architecture — a modern alternative to layered design. See how features are organized for maximum cohesion.

+ + +

Getting Started in 3 Steps

Choose Your Product

Pick any of the 9 products — CRM, HRM, WMS, CMS, SCM, OMS, SWM, or SaaS editions. Every product uses the same architecture, so skills transfer across all of them. $21 each.

Clone & Run in 60 Seconds

You'll need Visual Studio 2022+ and SQL Server (LocalDB or Express works). Clone the repo, update the connection string in appsettings.json, run EF Core migrations, and press F5. The app launches with seeded demo data ready to explore.

Study, Modify, Learn

Open any feature folder — for example Features/SalesOrders/ — and read through the endpoint, handler, and query in one place. Set breakpoints, trace the flow, modify the UI. Learn by doing with a real codebase.

+ + +

Beginner FAQ

Absolutely. Every Indotalent product includes complete source code with EF Core migrations, seed data, and clear project structure. Clone the repo, set your connection string, press F5, and the entire application runs locally. You can study real production patterns — authentication, CRUD operations, API endpoints, database design — all in one project.

Basic C# knowledge (variables, loops, classes) is helpful but not required. The source code follows clean coding patterns with clear naming conventions. You can read the code alongside online C# tutorials and learn by seeing how professionals structure enterprise applications.

You need Visual Studio 2022 or newer (the free Community edition works) and SQL Server (LocalDB or Express, both free). That's it. The project restores all NuGet packages automatically on first build.

Yes. Each product comes with built-in Swagger/OpenAPI documentation for the REST API. The codebase is self-documenting with clear class names, method names, and folder structure. Our blog also provides in-depth technical articles covering VSA, Blazor Server, and .NET 10 concepts.

Yes! You can study the code, learn from it, and use it as a reference for your own projects. For portfolio purposes, we recommend building your own features on top of the architecture rather than submitting the code as-is. The learning value is in understanding the patterns and applying them yourself.

+ + +

Start Your .NET Journey Today

9 enterprise applications. Complete source code. $21 each. Learn by studying real, production-grade code.

Explore Products Read the Blog

+ + + + \ No newline at end of file diff --git a/for-freelancers.html b/for-freelancers.html new file mode 100644 index 0000000..8f1cf91 --- /dev/null +++ b/for-freelancers.html @@ -0,0 +1,141 @@ + + + + + + + + .NET Source Code for Freelancers & Agencies — Build Client Projects Faster | Indotalent + + + + + + + + + + + + + + + + + + + + + + + + + + +

For Freelancers & Agencies

Ship Client Projects in Days, Not Months

Stop building CRUD from scratch. Start with a complete, production-ready .NET 10 Blazor application and customize it for your clients. $21 per license.

+ + +

The Freelancer's Dilemma

Clients Want Enterprise Features

Your clients expect authentication, role-based access, data grids with pagination, search, export, dashboards, and audit trails. Building these from scratch takes weeks — unpaid weeks.

Every Project Starts with CRUD

90% of business applications are CRUD with business rules. Yet every freelancer rewrites the same user management, data tables, and form validation for every new client.

The Indotalent Solution

For $21 per license, you get a complete, working .NET 10 application. Copy it, configure the connection string, and you have a running app in 60 seconds. Spend your time on custom business logic, not boilerplate.

Charge for Implementation, Not Foundation

Your clients pay you to customize and deploy. The $21 source code is your foundation — the working foundation you'd otherwise spend 80+ hours building. Your ROI is immediate.

+ + +

Your ROI as a Freelancer

+ + + + + + + + + + +

Task	From Scratch	With Indotalent
Project Setup & Architecture	2-3 days	0 minutes
Authentication & Authorization	3-5 days	0 minutes
CRUD Pages (List, Create, Edit, Delete)	2-4 weeks	Already built
Database Design & Migrations	1 week	Already designed
REST API + Swagger Docs	1 week	Already included
Total Time Saved	5-8 weeks	Cost: $21

+ + +

Real Use Cases for Freelancers

🚀 Startup MVP

A client needs a customer portal. Buy Blazor CRM for $21, rebrand it, add 3 custom fields, and deliver in 2 days instead of 6 weeks. Charge $3,000-$5,000 for implementation.

🏢 Internal Tool

A manufacturing company needs an inventory system. Buy Blazor WMS for $21, customize the schema, and deploy. Deliver an enterprise-grade tool at a fraction of custom development cost.

🎓 Learning Investment

Study the VSA patterns once, then apply them to all future projects. The $21 investment pays off every time you use the same architecture pattern for a new client.

+ + +

License: Client-Ready

Each license covers one end product per client project. You can charge your clients for customization, implementation, and deployment. Each new client project requires a separate $21 license — still the best ROI in enterprise development. See our full license terms.

Explore Products View License

+ + + + \ No newline at end of file diff --git a/img/Lemon-Squeezy-Logo-Purple-600.jpg b/img/Lemon-Squeezy-Logo-Purple-600.jpg new file mode 100644 index 0000000..ef65921 Binary files /dev/null and b/img/Lemon-Squeezy-Logo-Purple-600.jpg differ diff --git a/img/Logo-lemon-squeezy-Black-Text.png b/img/Logo-lemon-squeezy-Black-Text.png new file mode 100644 index 0000000..cc67e91 Binary files /dev/null and b/img/Logo-lemon-squeezy-Black-Text.png differ diff --git a/img/admintemplate-html.png b/img/admintemplate-html.png new file mode 100644 index 0000000..79d846d Binary files /dev/null and b/img/admintemplate-html.png differ diff --git a/img/admintemplate-mvc.png b/img/admintemplate-mvc.png new file mode 100644 index 0000000..18864c3 Binary files /dev/null and b/img/admintemplate-mvc.png differ diff --git a/img/admintemplate-razor.png b/img/admintemplate-razor.png new file mode 100644 index 0000000..648f149 Binary files /dev/null and b/img/admintemplate-razor.png differ diff --git a/img/cms-clinic-management-system-01.png b/img/cms-clinic-management-system-01.png new file mode 100644 index 0000000..465c227 Binary files /dev/null and b/img/cms-clinic-management-system-01.png differ diff --git a/img/cms-clinic-management-system-02.png b/img/cms-clinic-management-system-02.png new file mode 100644 index 0000000..8986d26 Binary files /dev/null and b/img/cms-clinic-management-system-02.png differ diff --git a/img/cms-clinic-management-system-03.png b/img/cms-clinic-management-system-03.png new file mode 100644 index 0000000..383c139 Binary files /dev/null and b/img/cms-clinic-management-system-03.png differ diff --git a/img/cms-clinic-management-system-04.png b/img/cms-clinic-management-system-04.png new file mode 100644 index 0000000..b009e46 Binary files /dev/null and b/img/cms-clinic-management-system-04.png differ diff --git a/img/cms-clinic-management-system-05.png b/img/cms-clinic-management-system-05.png new file mode 100644 index 0000000..89b5979 Binary files /dev/null and b/img/cms-clinic-management-system-05.png differ diff --git a/img/cms-clinic-management-system-06.png b/img/cms-clinic-management-system-06.png new file mode 100644 index 0000000..1564cad Binary files /dev/null and b/img/cms-clinic-management-system-06.png differ diff --git a/img/crm-customer-relationship-management-01.png b/img/crm-customer-relationship-management-01.png new file mode 100644 index 0000000..f5fe71d Binary files /dev/null and b/img/crm-customer-relationship-management-01.png differ diff --git a/img/crm-customer-relationship-management-02.png b/img/crm-customer-relationship-management-02.png new file mode 100644 index 0000000..22bee56 Binary files /dev/null and b/img/crm-customer-relationship-management-02.png differ diff --git a/img/crm-customer-relationship-management-03.png b/img/crm-customer-relationship-management-03.png new file mode 100644 index 0000000..0746dd7 Binary files /dev/null and b/img/crm-customer-relationship-management-03.png differ diff --git a/img/crm-customer-relationship-management-04.png b/img/crm-customer-relationship-management-04.png new file mode 100644 index 0000000..31f69d7 Binary files /dev/null and b/img/crm-customer-relationship-management-04.png differ diff --git a/img/crm-customer-relationship-management-05.png b/img/crm-customer-relationship-management-05.png new file mode 100644 index 0000000..379d9a6 Binary files /dev/null and b/img/crm-customer-relationship-management-05.png differ diff --git a/img/crm-customer-relationship-management-06.png b/img/crm-customer-relationship-management-06.png new file mode 100644 index 0000000..4cf1fc4 Binary files /dev/null and b/img/crm-customer-relationship-management-06.png differ diff --git a/img/crm-multi-tenant-01.png b/img/crm-multi-tenant-01.png new file mode 100644 index 0000000..98dd380 Binary files /dev/null and b/img/crm-multi-tenant-01.png differ diff --git a/img/crm-multi-tenant-02.png b/img/crm-multi-tenant-02.png new file mode 100644 index 0000000..9515db7 Binary files /dev/null and b/img/crm-multi-tenant-02.png differ diff --git a/img/crm-multi-tenant-03.png b/img/crm-multi-tenant-03.png new file mode 100644 index 0000000..fc77a80 Binary files /dev/null and b/img/crm-multi-tenant-03.png differ diff --git a/img/crm-multi-tenant-04.png b/img/crm-multi-tenant-04.png new file mode 100644 index 0000000..d38b5fd Binary files /dev/null and b/img/crm-multi-tenant-04.png differ diff --git a/img/crm-multi-tenant-05.png b/img/crm-multi-tenant-05.png new file mode 100644 index 0000000..df2c061 Binary files /dev/null and b/img/crm-multi-tenant-05.png differ diff --git a/img/crm-multi-tenant-06.png b/img/crm-multi-tenant-06.png new file mode 100644 index 0000000..6fe0bcb Binary files /dev/null and b/img/crm-multi-tenant-06.png differ diff --git a/img/crm-multi-tenant-07.png b/img/crm-multi-tenant-07.png new file mode 100644 index 0000000..8674eed Binary files /dev/null and b/img/crm-multi-tenant-07.png differ diff --git a/img/hrm-human-resource-management-01.png b/img/hrm-human-resource-management-01.png new file mode 100644 index 0000000..5969fda Binary files /dev/null and b/img/hrm-human-resource-management-01.png differ diff --git a/img/hrm-human-resource-management-02.png b/img/hrm-human-resource-management-02.png new file mode 100644 index 0000000..df3e0ae Binary files /dev/null and b/img/hrm-human-resource-management-02.png differ diff --git a/img/hrm-human-resource-management-03.png b/img/hrm-human-resource-management-03.png new file mode 100644 index 0000000..cf5878c Binary files /dev/null and b/img/hrm-human-resource-management-03.png differ diff --git a/img/hrm-human-resource-management-04.png b/img/hrm-human-resource-management-04.png new file mode 100644 index 0000000..1042057 Binary files /dev/null and b/img/hrm-human-resource-management-04.png differ diff --git a/img/hrm-human-resource-management-05.png b/img/hrm-human-resource-management-05.png new file mode 100644 index 0000000..634b5b1 Binary files /dev/null and b/img/hrm-human-resource-management-05.png differ diff --git a/img/hrm-human-resource-management-06.png b/img/hrm-human-resource-management-06.png new file mode 100644 index 0000000..1b59b62 Binary files /dev/null and b/img/hrm-human-resource-management-06.png differ diff --git a/img/hrm-multi-tenant-saas-01.png b/img/hrm-multi-tenant-saas-01.png new file mode 100644 index 0000000..916474e Binary files /dev/null and b/img/hrm-multi-tenant-saas-01.png differ diff --git a/img/hrm-multi-tenant-saas-02.png b/img/hrm-multi-tenant-saas-02.png new file mode 100644 index 0000000..d603349 Binary files /dev/null and b/img/hrm-multi-tenant-saas-02.png differ diff --git a/img/hrm-multi-tenant-saas-03.png b/img/hrm-multi-tenant-saas-03.png new file mode 100644 index 0000000..89b230c Binary files /dev/null and b/img/hrm-multi-tenant-saas-03.png differ diff --git a/img/hrm-multi-tenant-saas-04.png b/img/hrm-multi-tenant-saas-04.png new file mode 100644 index 0000000..5f46e47 Binary files /dev/null and b/img/hrm-multi-tenant-saas-04.png differ diff --git a/img/hrm-multi-tenant-saas-05.png b/img/hrm-multi-tenant-saas-05.png new file mode 100644 index 0000000..234e0fe Binary files /dev/null and b/img/hrm-multi-tenant-saas-05.png differ diff --git a/img/hrm-multi-tenant-saas-06.png b/img/hrm-multi-tenant-saas-06.png new file mode 100644 index 0000000..9f1c119 Binary files /dev/null and b/img/hrm-multi-tenant-saas-06.png differ diff --git a/img/hrm-multi-tenant-saas-07.png b/img/hrm-multi-tenant-saas-07.png new file mode 100644 index 0000000..ee4ed32 Binary files /dev/null and b/img/hrm-multi-tenant-saas-07.png differ diff --git a/img/ismail.jpg b/img/ismail.jpg new file mode 100644 index 0000000..dfd0244 Binary files /dev/null and b/img/ismail.jpg differ diff --git a/img/logo-indotalent-dark.svg b/img/logo-indotalent-dark.svg new file mode 100644 index 0000000..2ebf59e --- /dev/null +++ b/img/logo-indotalent-dark.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/img/logo-indotalent-light.svg b/img/logo-indotalent-light.svg new file mode 100644 index 0000000..a532974 --- /dev/null +++ b/img/logo-indotalent-light.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/img/oms-order-management-system-01.png b/img/oms-order-management-system-01.png new file mode 100644 index 0000000..cc164b7 Binary files /dev/null and b/img/oms-order-management-system-01.png differ diff --git a/img/oms-order-management-system-02.png b/img/oms-order-management-system-02.png new file mode 100644 index 0000000..06f9dd9 Binary files /dev/null and b/img/oms-order-management-system-02.png differ diff --git a/img/oms-order-management-system-03.png b/img/oms-order-management-system-03.png new file mode 100644 index 0000000..4097dea Binary files /dev/null and b/img/oms-order-management-system-03.png differ diff --git a/img/oms-order-management-system-04.png b/img/oms-order-management-system-04.png new file mode 100644 index 0000000..a2e5564 Binary files /dev/null and b/img/oms-order-management-system-04.png differ diff --git a/img/oms-order-management-system-05.png b/img/oms-order-management-system-05.png new file mode 100644 index 0000000..4495e43 Binary files /dev/null and b/img/oms-order-management-system-05.png differ diff --git a/img/oms-order-management-system-06.png b/img/oms-order-management-system-06.png new file mode 100644 index 0000000..db7f26b Binary files /dev/null and b/img/oms-order-management-system-06.png differ diff --git a/img/scm-supply-chain-management-01.png b/img/scm-supply-chain-management-01.png new file mode 100644 index 0000000..598ba96 Binary files /dev/null and b/img/scm-supply-chain-management-01.png differ diff --git a/img/scm-supply-chain-management-02.png b/img/scm-supply-chain-management-02.png new file mode 100644 index 0000000..9ff39b6 Binary files /dev/null and b/img/scm-supply-chain-management-02.png differ diff --git a/img/scm-supply-chain-management-03.png b/img/scm-supply-chain-management-03.png new file mode 100644 index 0000000..5bec6fb Binary files /dev/null and b/img/scm-supply-chain-management-03.png differ diff --git a/img/scm-supply-chain-management-04.png b/img/scm-supply-chain-management-04.png new file mode 100644 index 0000000..ac0d4da Binary files /dev/null and b/img/scm-supply-chain-management-04.png differ diff --git a/img/scm-supply-chain-management-05.png b/img/scm-supply-chain-management-05.png new file mode 100644 index 0000000..7fec049 Binary files /dev/null and b/img/scm-supply-chain-management-05.png differ diff --git a/img/scm-supply-chain-management-06.png b/img/scm-supply-chain-management-06.png new file mode 100644 index 0000000..4d87c0f Binary files /dev/null and b/img/scm-supply-chain-management-06.png differ diff --git a/img/swm-spa-and-wellness-management-01.png b/img/swm-spa-and-wellness-management-01.png new file mode 100644 index 0000000..6cad962 Binary files /dev/null and b/img/swm-spa-and-wellness-management-01.png differ diff --git a/img/swm-spa-and-wellness-management-02.png b/img/swm-spa-and-wellness-management-02.png new file mode 100644 index 0000000..ec93fd9 Binary files /dev/null and b/img/swm-spa-and-wellness-management-02.png differ diff --git a/img/swm-spa-and-wellness-management-03.png b/img/swm-spa-and-wellness-management-03.png new file mode 100644 index 0000000..45a8fcf Binary files /dev/null and b/img/swm-spa-and-wellness-management-03.png differ diff --git a/img/swm-spa-and-wellness-management-04.png b/img/swm-spa-and-wellness-management-04.png new file mode 100644 index 0000000..26f3fa4 Binary files /dev/null and b/img/swm-spa-and-wellness-management-04.png differ diff --git a/img/swm-spa-and-wellness-management-05.png b/img/swm-spa-and-wellness-management-05.png new file mode 100644 index 0000000..6767781 Binary files /dev/null and b/img/swm-spa-and-wellness-management-05.png differ diff --git a/img/swm-spa-and-wellness-management-06.png b/img/swm-spa-and-wellness-management-06.png new file mode 100644 index 0000000..6f65cb4 Binary files /dev/null and b/img/swm-spa-and-wellness-management-06.png differ diff --git a/img/wms-warehouse-inventory-management-system-01.png b/img/wms-warehouse-inventory-management-system-01.png new file mode 100644 index 0000000..96b32b7 Binary files /dev/null and b/img/wms-warehouse-inventory-management-system-01.png differ diff --git a/img/wms-warehouse-inventory-management-system-02.png b/img/wms-warehouse-inventory-management-system-02.png new file mode 100644 index 0000000..a2e65a8 Binary files /dev/null and b/img/wms-warehouse-inventory-management-system-02.png differ diff --git a/img/wms-warehouse-inventory-management-system-03.png b/img/wms-warehouse-inventory-management-system-03.png new file mode 100644 index 0000000..76c474c Binary files /dev/null and b/img/wms-warehouse-inventory-management-system-03.png differ diff --git a/img/wms-warehouse-inventory-management-system-04.png b/img/wms-warehouse-inventory-management-system-04.png new file mode 100644 index 0000000..d3ba055 Binary files /dev/null and b/img/wms-warehouse-inventory-management-system-04.png differ diff --git a/img/wms-warehouse-inventory-management-system-05.png b/img/wms-warehouse-inventory-management-system-05.png new file mode 100644 index 0000000..36cdb04 Binary files /dev/null and b/img/wms-warehouse-inventory-management-system-05.png differ diff --git a/img/wms-warehouse-inventory-management-system-06.png b/img/wms-warehouse-inventory-management-system-06.png new file mode 100644 index 0000000..28c3c07 Binary files /dev/null and b/img/wms-warehouse-inventory-management-system-06.png differ diff --git a/index.html b/index.html new file mode 100644 index 0000000..c0bafa3 --- /dev/null +++ b/index.html @@ -0,0 +1,916 @@ + + + + + + + + Enterprise .NET 10 Source Code for Learning and Commercial Projects | INDOTALENT + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + Creator's open source: 1.3K+ GitHub Stars + · + Production-Ready Source Code +

+ Enterprise .NET 10 Source Code
for Learning and Commercial Projects +

+ Built with .NET 10 + + Blazor Server + + ASP.NET Core Minimal APIs + + Vertical Slice Architecture + + CQRS via MediatR + + MudBlazor UI + + EF Core + + JWT + Identity + — all in a single-project monolith with + dozens of working features per application. +

+ Back End + Front End in one solution. +

Stop debugging AI hallucinations. Ship real apps today.

+ Explore Products +Read Blog +

+ +

Traditional (Layered)

Organized by technical concerns

Controllers / API

Services

Repositories

Database

Vertical Slice Architecture

Organized by features (end-to-end)

Create
Order

Get
Order

Update
Order

Cancel
Order

.NET 10 · Blazor Server · Vertical Slice Architecture · MudBlazor · Single-Project Monolith

+ + +

Products

1.3K+

GitHub Stars

500+

Forks

50+

Features

Years of Refinement

+ + +

Secure checkout via Lemon Squeezy

Instant digital delivery

Lifetime access

+ + +

Complete Source Code

Enterprise .NET 10 Products

9 production-ready Blazor Server apps with MudBlazor UI, REST API, and Vertical Slice Architecture. All source code $21 each.

Blazor CRM

Customer Relationship Management

$21 $49

View Details →

Blazor CRM Multitenant SaaS

CRM with Multi-Tenancy

$21 $49

View Details →

Blazor CMS

Clinic Management System

$21 $49

View Details →

Blazor HRM

Human Resource Management

$21 $49

View Details →

Blazor HRM Multitenant SaaS

HRM with Multi-Tenancy

$21 $49

View Details →

Blazor OMS

Order Management System

$21 $49

View Details →

Blazor SCM

Supply Chain Management

$21 $49

View Details →

Blazor SWM

Spa & Wellness Management

$21 $49

View Details →

Blazor WMS

Warehouse Management System

$21 $49

View Details →

+ + +

Bonus - FREE

Clean, Professional Admin Templates

A modern, light, minimalist admin template built with Tailwind CSS and Alpine.js. Explore ten business-grade dashboards, each available in five carefully crafted color themes.

100% FREE — yours on every product purchase, no extra cost.

+ +

A complete front-end foundation

The admin template is a building block of the Enterprise Development Kit — a clean, professional UI layer for line-of-business applications.

Lightweight & Fast

Built on Tailwind CSS and Alpine.js — no heavy build step, no framework lock-in, just clean composable markup.

Modular Components

Reusable cards, tables, forms, auth pages and widgets crafted for consistent, professional enterprise layouts.

+ +

Admin Template HTML

Tailwind CSS + Alpine.js

Live Demo →

Admin Template MVC

ASP.NET Core MVC

Live Demo →

Admin Template Razor

ASP.NET Core Razor Pages

Live Demo →

+ +

Get All 3 Admin Templates Absolutely FREE

These three professional admin templates are included free with every product purchase.

+ Browse Products & Claim Your Free Bonus +

+ + +

Tech Stack

Built on the Proven Stack

Every product uses the same battle-tested architecture.

+ .NET 10 + ASP.NET Core + Blazor Server + MudBlazor + REST API + EF Core + VSA +

Production Ready

Clone, configure connection string, run. No complex build pipelines.

Clean Code

Vertical Slice Architecture. Add features in one folder, not 5 projects.

Monolith Done Right

Single project. No distributed complexity until you need it.

Auth & Security

Identity, JWT, role-based authorization. Pre-configured.

REST API + Swagger

Minimal APIs with OpenAPI docs and JWT authentication.

EF Core + SQL Server

Migrations, seed data, compiled queries. Instant testing.

+ + +

What You Get

Enterprise .NET Source Code, Explained

When we say enterprise .NET source code, we mean a complete, production-grade application — not a template, not a starter kit, not a tutorial project. Each Indotalent product is a fully working business application with 50 to 100 end-to-end features, ready to run on your machine in under 60 seconds.

You receive the unrestricted C# source code for the entire solution. This includes the Blazor Server UI layer, the REST API endpoints, the business logic handlers, the Entity Framework Core data access layer, the database migrations, and the seed data — all in a single Visual Studio project that compiles and runs immediately.

No obfuscation. No missing pieces. No hidden dependencies. You can study every line of code, modify any feature, extend the application for your own needs, and deploy it as you see fit. This is professional C# code written by a developer with 5+ years of .NET experience, following industry best practices.

What's Included in Every Product

Complete Blazor Server Front End — Responsive UI with MudBlazor components, data grids, forms, dialogs, and dashboards
REST Web API — Minimal API endpoints with Swagger/OpenAPI documentation and JWT authentication
Business Logic Layer — MediatR handlers with CQRS pattern, FluentValidation, and clean domain logic
EF Core Data Access — Migrations, seed data, compiled queries, and SQL Server database design
Authentication & Authorization — ASP.NET Core Identity, JWT tokens, role-based and policy-based access control
Audit Trail & Security — User activity logging, data change tracking, and secure data handling

+ + +

Learning Path

What You'll Learn from This Source Code

Each product is a complete enterprise application. Study real-world implementations of these production patterns.

Authentication

ASP.NET Core Identity with secure password hashing, login, registration, and password reset. Study how cookies and JWT tokens coexist for dual UI + API authentication.

Authorization

Role-based (RBAC) and policy-based access control. Learn how Admin, Manager, and User roles map to feature access, and how declarative policies protect sensitive operations.

CQRS + MediatR

Command Query Responsibility Segregation via MediatR. Study how pipeline behaviors handle validation, logging, and transactions without cluttering business logic.

REST API

ASP.NET Core Minimal APIs with Swagger/OpenAPI docs. Learn proper HTTP status codes, request/response DTOs, JWT-protected endpoints, and API versioning patterns.

Audit Trail

Every data modification is tracked with user ID, timestamp, and change details. Study how to implement compliance-ready logging without polluting business logic.

Reporting

Built-in dashboards with charts, summary cards, and data grids. Learn how MudBlazor components compose into analytics views with EF Core aggregation queries.

Deployment

Standard ASP.NET Core project — deploy on Azure, IIS, or Docker in minutes. Single-project monolith means zero distributed complexity. Works on Windows, Linux, and macOS.

Multi-Tenant SaaS

Two products include full multi-tenancy with tenant isolation. Study how to design a SaaS architecture where multiple organizations share one database with zero data leakage.

+ + +

The Difference

Why This Is Different from CRUD Templates

The internet is full of "Blazor CRUD tutorials." Here's what they never include — and what every Indotalent product ships with.

+ + + + + + + + + + + + + + + + + +

Feature	Typical CRUD Tutorial	Indotalent Source Code
Authentication & Login	None or hardcoded	Full Identity + JWT
Role-Based Authorization	Not included	Admin, Manager, User roles
Audit Trail	Not included	Every action logged
REST API + Swagger	Not included	Full OpenAPI docs
Seed Data	None	Complete demo dataset
Database Migrations	Manual scripts	EF Core migrations
Validation	Basic or none	FluentValidation
Error Handling	Try-catch everywhere	Global exception middleware
Architecture Pattern	No pattern	VSA + CQRS
Dashboard & Reporting	Not included	Charts and KPIs
Multi-Tenant (SaaS)	Not included	2 SaaS products
Deployment-Ready	No	Azure, IIS, Docker
Number of Features	3-5 CRUD pages	50-100 end-to-end features

CRUD tutorials teach you syntax. Indotalent teaches you architecture.

+ + +

Architecture

Architecture That Developers Love

Every Indotalent product uses the same production-proven patterns: Vertical Slice Architecture, CQRS via MediatR, and secure REST APIs.

Vertical Slice Architecture

Instead of scattering code across Controller, Service, Repository, and Domain layers, VSA organizes every feature in a single folder. Each slice contains its own endpoint, MediatR handler, FluentValidation validator, and EF Core queries — all in one place. This maximizes cohesion, minimizes cognitive overhead, and makes every feature self-contained and easy to understand. Add a feature without touching 5 different projects.

CQRS via MediatR

Commands (writes) and Queries (reads) are separated into distinct MediatR handlers. This CQRS pattern keeps your code clean, testable, and optimized — read queries use EF Core no-tracking for maximum performance, while command handlers encapsulate business logic with full change tracking. Pipeline behaviors handle cross-cutting concerns like validation, logging, and transactions without cluttering your business code.

REST API + Identity

Every product exposes a complete REST Web API with Swagger/OpenAPI documentation. The API is secured with JWT bearer token authentication on top of ASP.NET Core Identity. You get user registration, login, role management, and policy-based authorization out of the box. Backend and frontend share the same authentication — cookies for Razor pages, JWT for API clients. Ready for mobile apps, third-party integrations, or microservices.

+ + +

Security

Enterprise-Grade Security Built In

Security is not an afterthought in Indotalent products — it is baked into the architecture from the ground up. Every application ships with a fully configured authentication and authorization system that you would otherwise spend weeks implementing from scratch.

The security stack includes ASP.NET Core Identity for user and role management with secure password hashing. JWT (JSON Web Token) authentication protects all REST API endpoints, while cookie-based authentication handles Blazor Server UI access. Both schemes run simultaneously — your Razor components and API endpoints are protected with zero additional configuration.

Role-based access control (RBAC) restricts features by user role. Policy-based authorization provides fine-grained control — define policies like "CanApproveOrders" or "CanViewFinancialReports" and apply them declaratively. Every data modification is tracked with user ID and timestamp, creating a complete audit trail for compliance and debugging.

Security Features in Every Product

Authentication — ASP.NET Core Identity with secure password hashing, login, registration, and password reset flows
JWT Token Auth — Stateless API authentication with configurable token expiration and refresh
Role-Based Access Control — Predefined roles (Admin, Manager, User) with granular permission sets
Policy-Based Authorization — Declarative access policies for fine-grained feature control
Audit Trail — Every create, update, and delete operation logged with user, timestamp, and change details
SignalR Protection — Real-time Blazor Server connections secured with [Authorize] attributes

+ + +

Who It's For

Built for Every Developer

Whether you're writing your first line of C# or architecting enterprise systems, Indotalent products meet you where you are.

Students & Beginners

Learn .NET the right way — by studying real, working enterprise code. See how authentication connects to the database, how the UI calls the API, and how 50+ features coexist in one project. Skip the tutorial rabbit hole and study code that actually ships.

Freelancers & Agencies

Stop building CRUD from scratch for every client. For $21 per license, you get a complete working application you can rebrand, customize, and deploy. Charge clients for implementation, not foundation. Save 5-8 weeks per project.

Experienced Developers

Study a complete Vertical Slice Architecture implementation in a production .NET 10 app. See how CQRS, MediatR pipeline behaviors, FluentValidation, and EF Core come together in a clean monolith. Apply these patterns to your own projects immediately.

Teams & Startups

Launch your MVP in days, not months. Each product is a fully functional application you can deploy as-is or extend. Single-project structure means zero infrastructure complexity. Onboard new developers in hours, not weeks — one feature, one folder, zero confusion.

Find Your Product →

+ + +

The Truth

AI-Generated Code vs Indotalent

Why copying prompts into ChatGPT won't ship your enterprise app.

+ + + + + + + + + + + +

Requirement	AI-Generated	Indotalent
End-to-End Features
Secure Authentication
Clean Architecture
Compiles & Runs First Try
Database Migrations
Seed Data Included
Just $21

+ + +

Pricing

Fair Pricing for Developers

Without Support

Complete Source Code

$49 $21

Complete Source Code
Instant Download
Lifetime Access
Admin Template HTML (Free Bonus)
Admin Template MVC (Free Bonus)
Admin Template Razor (Free Bonus)

Get Started

With Support

Source Code + Support

$49

Complete Source Code
Instant Download
Email Support
Admin Template HTML (Free Bonus)
Admin Template MVC (Free Bonus)
Admin Template Razor (Free Bonus)

Get Started

Enterprise

Source + Custom Dev

$2200 $1200

Complete Source Code
Priority Support
Custom Development — 1 FTE / month, unlimited requests
Admin Template HTML (Free Bonus)
Admin Template MVC (Free Bonus)
Admin Template Razor (Free Bonus)

+ Best Value Bundle +

Freelancer & Developer Suite

$149

+ Buy Freelancer & Developer Suite +

Complete Source Code
CRM (Customer Relationship Management)
HRM (Human Resource Management)
CMS (Clinic Management System)
OMS (Order Management System)
SCM (Supply Chain Management)
SWM (Spa & Wellness Management)
WMS (Warehouse Management System)

Multitenant CRM
Multitenant HRM
Instant Download
Email Support
Admin Template HTML (Free Bonus)
Admin Template Razor (Free Bonus)
Admin Template MVC (Free Bonus)

+ +

+ Free Bonus +

3 Admin Templates Included Free

Every purchase — at any tier — comes with the Admin Template HTML, Admin Template MVC, and Admin Template Razor at no extra cost.

+ View Free Bonus +

+ + +

FAQ

Frequently Asked Questions

You get the complete, unrestricted source code of the entire application. A single .NET 10 project with all features, Vertical Slice Architecture implementation, EF Core migrations, seed data, and full configuration. Clone, set your connection string, press F5, and it runs immediately. No missing pieces. No hidden dependencies.

Absolutely! The code is clean, well-structured, and self-documenting. Beginners can learn by studying real production patterns — authentication flows, CRUD operations, REST API endpoints, and database design — all in a single project. You'll need Visual Studio 2022+ and SQL Server (LocalDB or Express, both free). See our Beginner's Guide.

Yes! Each license covers one end product per client project. You can charge clients for customization, implementation, and deployment. Freelancers and agencies save 5-8 weeks per project. Each new client project requires a separate $21 license. See our License page and Freelancer Guide.

Yes! Every product exposes a complete REST Web API built with ASP.NET Core Minimal APIs. The API includes Swagger/OpenAPI documentation, JWT authentication, and proper HTTP status codes. You can use the API for mobile apps, third-party integrations, or a separate frontend — it's fully functional and documented.

Yes — it's fully pre-configured. You get ASP.NET Core Identity for user management with secure password hashing, JWT (JSON Web Token) authentication for the REST API, role-based access control (RBAC) with Admin/Manager/User roles, and policy-based authorization for fine-grained access. Both the Blazor UI and REST API are protected out of the box.

SQL Server is fully tested and ready to use with EF Core migrations and seed data included. PostgreSQL support is already scaffolded in the codebase — the EF Core provider and connection string configuration are set up — but it has not been fully tested yet. You can switch between databases by changing the connection string and provider in Program.cs.

Yes! The application is a standard ASP.NET Core project and can be deployed anywhere .NET 10 runs: Azure App Service, IIS (Internet Information Services), or Docker containers. It's a single-project monolith — no distributed complexity. Build the project, publish the output, configure your connection string, and deploy. Works on Windows, Linux, and macOS.

Security is baked into the architecture. The application includes: ASP.NET Core Identity with password hashing, JWT + cookie dual authentication, role-based and policy-based authorization, audit trail (every create/update/delete is logged with user ID and timestamp), and SignalR connection protection with [Authorize] attributes. Source code and connection strings never leave the server with Blazor Server. This is enterprise-grade security ready for production use.

All products use Vertical Slice Architecture (VSA) — the modern alternative to traditional layered architecture. Each feature (Create Order, Get Customer, etc.) lives in its own folder with its endpoint, MediatR handler, FluentValidation validator, and EF Core queries all in one place. We also implement CQRS via MediatR for clean separation of commands and queries. This architecture is AI-friendly, beginner-friendly, and production-proven. Read our VSA Introduction.

No trial, no limits. You get the full, unrestricted source code. The $21 price is intentional to make enterprise-grade architecture accessible to every developer, freelancer, and small agency. The original price is $49.

All payments are processed securely through Lemon Squeezy, a trusted payment platform for digital products. We never see or store your credit card details. After payment, you get instant access to download.

Due to the digital nature of source code, we have a strict no-refund policy. That's why we provide live demos for every product. Test thoroughly before you buy. Full policy here.

+ + +

+ + Open Source +

1.3K+ Stars on GitHub
& Counting

Built by a Developer, for Developers.

I'm the engineer behind these products. My open-source work has been trusted by 1,300+ developers on GitHub with 500+ forks.

Every product is priced at just $21 $49 accessible pricing for freelancers and corporate engineers alike.

Each product is a .NET 10 Blazor solution built with Vertical Slice Architecture. No distributed complexity. Just clean, working code.

Your purchase directly supports my open-source work. Thank you for being part of this journey.

+ + GitHub Stars +

1,300+ Stars500+ Forks

go2ismailCreator & Maintainer

+ + +

Get Started Today

Ship Your .NET 10 App Today

Save months of development. Production-ready Blazor apps with MudBlazor UI, REST API, and VSA.

Explore Products Read Blog

+ + + + + + + + + + + + diff --git a/license.html b/license.html new file mode 100644 index 0000000..23b903d --- /dev/null +++ b/license.html @@ -0,0 +1,34 @@ + + + + + + + + License | Indotalent + + + + + + + + + +

Licensing

Choose Your License

Single Instant License — perfect for freelancers and agencies building one end product per client.

Single License

Without Support

$21

Use in one end product only

Freelancers/agencies can charge clients

Not allowed in sold end products

Not allowed for multiple products

Not allowed to re-sale or sublicense

Email Support

No Refund Policy

Recommended

Single License

With Support

$49

Use in one end product only

Freelancers/agencies can charge clients

Not allowed in sold end products

Not allowed for multiple products

Not allowed to re-sale or sublicense

Email Support

No Refund Policy

Developer License

With Support

$149

Allowed to use in unlimited end products

Allowed to deploy for multiple clients and multiple projects

Allowed for freelancers and agencies to charge clients for the final end product

Allowed to modify and customize the source code

Not allowed to sell the source code, template, or software as a competing product

Not allowed to redistribute, repackage, sublicense, or rent the source code

Not allowed to include the source code in any marketplace, starter kit, framework, boilerplate, or template intended for resale or redistribution

Email Support

No Refund Policy: Due to the downloadable nature of this product, all sales are final and non-refundable. An online demo is provided for your convenience; please try the demo to ensure the product meets your requirements before making a purchase.

+ +

Important for Freelancers & Agencies

You can charge your client for your services in creating the end product. However, this license cannot be applied to multiple clients or projects. Each new client or project necessitates the procurement of a new license.

+ \ No newline at end of file diff --git a/no-refund-policy.html b/no-refund-policy.html new file mode 100644 index 0000000..dd4e28f --- /dev/null +++ b/no-refund-policy.html @@ -0,0 +1,18 @@ + + + + + + + + No Refund Policy | Indotalent + + + + + + + + + +

Policy

No Refund Policy

Thank you for considering purchasing our digital products, particularly our source code. We appreciate your interest and trust in our offerings. However, before proceeding with your purchase, we would like to outline our No Refund Policy to ensure transparency and clarity regarding your transactions with us.

1. Understanding Digital Products

Our products, specifically our source code, are digital in nature. Once purchased and downloaded, they cannot be physically returned. Unlike tangible goods, digital products cannot be "returned" in the traditional sense. Therefore, it is essential to carefully consider your purchase decision before proceeding.

2. No Refund Policy

Due to the intangible and irreversible nature of digital products, we operate under a strict No Refund Policy. Once a purchase is made and the product is downloaded or accessed, we are unable to offer refunds, exchanges, or returns.

3. Live Demo Availability

To assist our customers in making informed purchasing decisions, we provide access to live demos of our products whenever possible. We encourage all potential buyers to thoroughly explore the live demos to ensure that the features and functionalities meet their requirements and expectations.

4. Commitment to Quality

We are committed to delivering high-quality digital products that meet industry standards and customer expectations. However, in the unlikely event that you encounter any issues or discrepancies with our products, please do not hesitate to reach out to our customer support team for assistance. We are here to address any concerns and provide necessary support to ensure your satisfaction.

5. Your Responsibility

As a customer, it is your responsibility to carefully review product descriptions, features, and demos before making a purchase. By proceeding with a purchase, you acknowledge that you have reviewed the product information and understand the terms of our No Refund Policy.

6. Contact Us

If you have any questions, concerns, or require further clarification regarding our No Refund Policy or any other aspect of our products and services, please feel free to contact us. Our customer support team is readily available to assist you and address any inquiries you may have.

Thank you for your understanding and cooperation. We look forward to serving you.

\ No newline at end of file diff --git a/privacy-policy.html b/privacy-policy.html new file mode 100644 index 0000000..bb98b1a --- /dev/null +++ b/privacy-policy.html @@ -0,0 +1,18 @@ + + + + + + + + Privacy Policy | Indotalent + + + + + + + + + +

Policy

Privacy Policy

Welcome to INDOTALENT STORE. We are committed to protecting your personal information and your right to privacy. This Privacy Policy explains how we collect, use, and safeguard your information when you visit our website and use our services, including payment processing via Lemon Squeezy.

1. Information We Collect

We collect personal information that you provide to us when you:

Place an order
Sign up for our newsletter
Contact us via email or contact form

This information may include:

Full Name
Email Address
Billing and Shipping Address
Phone Number
Payment Information (processed securely via Lemon Squeezy)

2. How We Use Your Information

We use your information to:

Process and fulfill your orders
Communicate with you about your purchase
Provide customer support
Send promotional emails (if you opt-in)

3. Payment Processing

All payments are processed securely via Lemon Squeezy. We do not store or have access to your full credit card information. Lemon Squeezy is a fully compliant payment provider that handles all sensitive payment data. Please refer to Lemon Squeezy's Privacy Policy for more details on how they handle your payment data.

4. Sharing of Information

We do not sell, rent, or trade your personal information to third parties. We may share your data with trusted service providers to help us operate our store, such as:

Payment gateways (e.g., Lemon Squeezy)
Email marketing platforms

These parties are required to keep your data confidential.

5. Cookies and Tracking

We may use basic cookies to enable essential website functionality such as shopping cart and login. If additional tracking or analytics tools are used in the future, this policy will be updated accordingly.

6. Your Rights

You have the right to:

Access and review your personal data
Request corrections or deletions
Withdraw consent for marketing communications

To exercise these rights, please contact us at hi@indotalent.com.

7. Data Retention

We retain your personal information only as long as necessary to fulfill the purposes outlined in this policy unless a longer retention period is required by law.

8. Third-Party Links

Our website may contain links to other websites. We are not responsible for the privacy practices of those sites.

9. Changes to This Policy

We may update this Privacy Policy from time to time. Changes will be posted on this page with an updated effective date.

10. Contact Us

If you have any questions about this Privacy Policy, please contact us at:

INDOTALENT STORE

Email: hi@indotalent.com

Thank you for trusting INDOTALENT STORE with your information.

\ No newline at end of file diff --git a/products/blazor-cms.html b/products/blazor-cms.html new file mode 100644 index 0000000..bfa91b8 --- /dev/null +++ b/products/blazor-cms.html @@ -0,0 +1,544 @@ + + + + + + + +Blazor CMS — Clinic Management System .NET 10 Source Code | Indotalent + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ .NET 10 · Blazor Server · VSA · MudBlazor +

Blazor CRM

Clinic Management System — Complete Source Code

A production-ready clinic management application to manage patients, medical records, appointments, and billing. Built with .NET 10, ASP.NET Core, Blazor Server, MudBlazor, and Vertical Slice Architecture.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy + Live Demo +

Blazor CMS Dashboard — Clinic Management System .NET 10 Blazor Server

+ + +

+ + +

The Problem

Business Problems Solved

Clinics and medical practices struggle with fragmented patient records, manual appointment scheduling, and disconnected billing — leading to errors, delays, and poor patient care.

Scattered Patient Records

Patient information is scattered across paper files, spreadsheets, and disconnected systems. Blazor CMS centralizes all patient data — demographics, medical history, prescriptions, and visit records — in one searchable system with complete audit trail.

Manual Appointment & Scheduling

Paper-based appointment booking causes double bookings, no-shows, and administrative chaos. Blazor CMS includes a booking module with resource scheduling, availability management, and appointment tracking to keep your clinic running smoothly.

Disconnected Medical Records & Billing

Medical records, prescriptions, and billing are often managed in separate systems causing data mismatch. Blazor CMS integrates medical records with sales orders, invoices, and payments — one system for clinical and financial operations.

No Clinical Analytics

Without dashboards, clinic owners cannot track patient volume, revenue, commission, or inventory usage. Blazor CMS includes KPI dashboards with charts and reports showing key clinical and financial metrics.

+ + +

Business Features

What's Included in Blazor CMS

Complete end-to-end business features — every module is a complete vertical slice with endpoint, handler, validator, and EF Core queries.

Profile

Personal Info, Password, Avatar, Session

Third Party

Patient Group, Patient Category, Patient, Patient Contact, Vendor Group, Vendor Category, Vendor, Vendor Contact

Organization

Employee, Employee Group, Employee Category

Medical

Medical Record, Medical Record Group, Medical Record Category

Sales

Sales Order, Sales Group, Invoice, Payment, Sales Report, Commission Report, Invoice Report, Payment Report

Purchase

Purchase Order, Bill, Payment, Purchase Report, Bill Report, Payment Report

Inventory

Unit Measure, Product Group, Product, Warehouse

Utilities

Booking Group, Booking Resource, Booking Manager, Scheduler, To-Do List

System Logs

Database log, File log

App Settings

Users, Currencies, Auto Number

System Settings

full inspection mode for appsettings.json

+ + +

Technology

Technologies Used

Blazor CMS is built on the modern .NET ecosystem with production-grade libraries and tools.

+ .NET 10 + ASP.NET Core 10 + Blazor Server + MudBlazor + ASP.NET Core Minimal APIs + Entity Framework Core 10 + MediatR + CQRS + FluentValidation + Swagger / OpenAPI + SignalR +

+ + + + + + + + + + + + + + + + +

Layer	Technology
Framework	.NET 10
Web Framework	ASP.NET Core 10
UI Rendering	Blazor Server (SignalR-based real-time UI)
UI Component Library	MudBlazor (Material Design components for Blazor)
Architecture Pattern	Vertical Slice Architecture (VSA) + CQRS via MediatR
API Style	ASP.NET Core Minimal APIs with Swagger/OpenAPI
Data Access	Entity Framework Core 10 (Code-First, Migrations, Compiled Queries)
Database	SQL Server (fully tested) / PostgreSQL (scaffolded)
Validation	FluentValidation
Authentication	ASP.NET Core Identity + JWT Bearer Token
Authorization	Role-Based (RBAC) + Policy-Based Authorization
Real-Time	SignalR (built into Blazor Server)

+ + +

Architecture

Application Architecture

Blazor CMS uses Vertical Slice Architecture (VSA) with CQRS via MediatR — the modern, maintainable approach to building .NET applications.

Vertical Slice Architecture

Each feature (Create Contact, Get Deal, Update Lead, etc.) lives in its own folder with its Minimal API endpoint, MediatR handler (Command or Query), FluentValidation validator, and EF Core queries all in one place. Zero coupling between features. Add a feature without touching unrelated code.

Folder structure: Features/Patients/CreateContact/ contains endpoint, handler, validator, DTO, and mapping — everything for that single operation.

CQRS via MediatR

Commands (writes) and Queries (reads) are separated into distinct MediatR handlers. Read queries use EF Core no-tracking for maximum performance. Command handlers encapsulate business logic with full change tracking. Pipeline behaviors handle cross-cutting concerns like validation, logging, and transactions.

Example: GetContactByIdQuery uses .AsNoTracking(). CreateContactCommand uses full change tracking with validation pipeline behavior.

Single-Project Monolith

The entire application — Blazor UI, REST API, business logic, data access, and authentication — lives in one .NET 10 project. No distributed complexity, no microservice overhead. Single F5 to run. Deploy as one unit to Azure, IIS, or Docker. Perfect for teams that value simplicity and velocity.

Project Structure Overview

BlazorCMS/
+├── Features/                    # Vertical Slices (one folder per feature)
+│   ├── Patients/
+│   │   ├── CreateContact/       # Endpoint + Handler + Validator + DTO
+│   │   ├── GetContactById/
+│   │   ├── GetContactList/
+│   │   ├── UpdateContact/
+│   │   └── DeleteContact/
+│   ├── Doctors/
+│   ├── Appointments/
+│   ├── Prescriptions/
+│   ├── Billing/
+│   └── Dashboard/
+├── Infrastructure/              # Cross-cutting: Auth, Audit, EF Core
+├── Migrations/                  # EF Core migrations
+├── SeedData/                    # Initial seed data (demo users, sample data)
+├── Components/                  # Shared Blazor components
+├── wwwroot/                     # Static assets
+└── Program.cs                   # Single entry point with full configuration

+ + +

Security

Security & Authorization

Security is baked into the architecture from the ground up — not bolted on as an afterthought.

Blazor CMS ships with a fully configured authentication and authorization system. ASP.NET Core Identity manages users and roles with secure password hashing. JWT (JSON Web Token) authentication protects all REST API endpoints, while cookie-based authentication handles Blazor Server UI access. Both schemes run simultaneously.

Role-based access control (RBAC) restricts features by user role: Admin (full access), Manager (team-level access), and User (self-service). Policy-based authorization provides fine-grained control for sensitive operations like deal approval or financial reports.

With Blazor Server, source code and connection strings never leave the server. All data access happens server-side via SignalR — zero exposure of database credentials or business logic to the client.

Security Features

ASP.NET Core Identity — User registration, login, password hashing, password reset
JWT + Cookie Dual Auth — Cookies for Blazor UI, JWT for REST API
Role-Based Access Control — Admin, Manager, User roles with granular permissions
Policy-Based Authorization — Declarative policies for fine-grained feature access
Audit Trail — Every create/update/delete logged with user ID and timestamp
SignalR Protection — Blazor Server connections secured with [Authorize]
Server-Side Code — Source code and DB credentials never leave the server

+ + +

Integration

REST API & Integration

Blazor CMS exposes a complete REST Web API for all entities — ready for mobile apps, third-party integrations, and external systems.

API Endpoints

Every feature exposes REST endpoints via ASP.NET Core Minimal APIs. All endpoints are JWT-protected and return proper HTTP status codes.

GET/api/contacts— List contacts with pagination, search, sort

GET/api/contacts/{id}— Get contact by ID

POST/api/contacts— Create new contact

PUT/api/contacts/{id}— Update contact

DELETE/api/contacts/{id}— Delete contact

Same pattern applies to all entities: Companies, Deals, Leads, Activities, and Dashboard aggregations.

API Features

Swagger/OpenAPI Docs — Interactive API documentation at /swagger
JWT Authentication — All endpoints require Bearer token
Request/Response DTOs — Clean separation from domain models
FluentValidation — Input validation on all endpoints
Pagination & Filtering — Built-in query parameters for list endpoints
Mobile-Ready — Use the API to build mobile apps or integrate with external systems

+ + +

Database & Deployment

EF Core migrations, seed data, and flexible deployment options — ready to run in under 60 seconds.

Database

SQL Server — Fully tested with EF Core migrations and seed data included
PostgreSQL — Scaffolded in codebase (provider + connection string config ready, not fully tested)
EF Core Migrations — Code-first approach with full migration history
Seed Data — Demo users (admin, manager, user), sample business records
Compiled Queries — Performance-optimized EF Core queries

Deployment Options

Azure App Service — Deploy directly from Visual Studio or GitHub Actions
IIS (Windows Server) — Standard ASP.NET Core publish to IIS
Docker — Containerize and deploy anywhere Docker runs
Windows / Linux / macOS — .NET 10 runs everywhere
Single Project — No distributed complexity. One publish, one deploy
Setup Time: Clone repo → set connection string → F5 → running in under 60 seconds

+ + +

Application Screenshots

Explore the Blazor CMS interface — dashboards, data management, workflow management, and more.

+ + +

Try the Live Demo

Test every feature before you buy. No registration required.

URL: https://blazor-cms.csharpasp.net/

Email: admin@root.com

Password: 123456

+ + +

Get Blazor CMS Source Code

Complete, unrestricted C# source code. Single .NET 10 project. Clone, F5, run.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy +

Secure checkout via Lemon Squeezy. Lifetime access. No subscription.

+ + +

FAQ

Frequently Asked Questions

+ +

You get the complete, unrestricted C# source code of the entire Blazor CMS application. A single .NET 10 project with all features, Vertical Slice Architecture implementation, EF Core migrations, seed data, and full configuration. Clone, set your connection string, press F5, and it runs immediately. Includes Blazor Server UI, REST API, authentication, authorization, audit trail, and all CRM features.

+ +

Yes! Each license covers one end product per client project. You can rebrand, customize, add features, and deploy for your clients. Freelancers and agencies save weeks of development. Each new client project requires a separate $21 license. See our License page.

+ +

SQL Server is fully tested and ready to use. PostgreSQL support is scaffolded in the codebase — the EF Core provider and connection string configuration are set up — but has not been fully tested yet. Switch between databases by changing the connection string and provider in Program.cs.

+ +

Blazor CMS uses Vertical Slice Architecture (VSA) with CQRS via MediatR. Each feature (Create Contact, Get Deal, etc.) lives in its own folder with endpoint, MediatR handler, FluentValidation validator, and EF Core queries. This pattern is AI-friendly, beginner-friendly, and production-proven. Read our VSA Introduction.

+ +

Absolutely! The code is clean, well-structured, and self-documenting. Beginners can study real production patterns — authentication flows, VSA feature organization, REST API endpoints, and database design — all in a single project. You'll need Visual Studio 2022+ and SQL Server (LocalDB or Express, both free).

+ +

Due to the digital nature of source code, we have a strict no-refund policy. That's why we provide a fully functional live demo — test every feature before you buy. Full policy here.

+ + + + + + \ No newline at end of file diff --git a/products/blazor-crm-multitenant.html b/products/blazor-crm-multitenant.html new file mode 100644 index 0000000..757f766 --- /dev/null +++ b/products/blazor-crm-multitenant.html @@ -0,0 +1,546 @@ + + + + + + + +Blazor CRM Multi-Tenant — SaaS CRM with Multi-Tenancy .NET 10 Source Code | Indotalent + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ SaaS · Multi-Tenant · .NET 10 · Blazor Server · VSA +

Blazor CRM Multi-Tenant

SaaS CRM with Multi-Tenancy — Complete Source Code

A production-ready multi-tenant SaaS CRM application to serve multiple organizations from a single deployment. Built with .NET 10, ASP.NET Core, Blazor Server, MudBlazor, and Vertical Slice Architecture. Complete tenant isolation, shared database with global query filters.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy + Live Demo +

Blazor CRM Multi-Tenant Dashboard — SaaS CRM with Multi-Tenancy .NET 10 Blazor Server

+ + +

+ + +

The Problem

Business Problems Solved by Blazor CRM Multi-Tenant

SaaS businesses need to serve multiple organizations from one deployment — but building secure tenant isolation, managing separate customer data, and scaling multi-tenant infrastructure is complex and expensive.

Serving Multiple Organizations from One Instance

Building separate CRM instances for each client is prohibitively expensive in infrastructure and maintenance. Blazor CRM Multi-Tenant allows multiple organizations to share one database and one deployment with complete data isolation via TenantId global query filters. Add new tenants in seconds without provisioning new servers.

Data Leakage Between Tenants

Without proper tenant isolation, customer data can leak between organizations — a catastrophic security and compliance failure. EF Core global query filters automatically scope every query to the current tenant. Tenant A's contacts, deals, and activities are completely invisible to Tenant B. Zero data leakage by design.

Scattered Customer Data Across Tenants

Each tenant needs their own contacts, companies, and deals — but managing this separation manually is error-prone. Blazor CRM Multi-Tenant centralizes all tenant data with automatic scoping. Every API call, every database query, every UI interaction is tenant-aware.

No Tenant-Aware Sales Pipeline

Each tenant needs their own sales pipeline and reporting — but building per-tenant analytics is complex. Blazor CRM Multi-Tenant provides fully tenant-aware dashboards with KPI cards, pipeline charts, and win/loss rates scoped to each organization.

+ + + +

Business Features

What's Included in Blazor CRM Multi-Tenant

Complete end-to-end business features with multi-tenant isolation — every module is a complete vertical slice with endpoint, handler, validator, and EF Core queries.

Profile

Personal Info, Password, Avatar, Session

Pipeline

Campaign, Budget, Expense, Lead, Lead Contacts, Lead Activities, Sales Team, Sales Representative

Third Party

Customer Group, Customer Category, Customer, Customer Contact, Vendor Group, Vendor Category, Vendor, Vendor Contact

Sales

Quotation, Sales Order, Delivery Order, Sales Return, Invoice, Credit Note, Payment, Sales Report, Delivery Report, Return Report, Invoice Report, Payment Report

Purchase

Requisition, Purchase Order, Goods Receive, Purchase Return, Bill, Debit Note, Payment, Purchase Report, Receive Report, Return Report, Bill Report, Payment Report

Inventory

Unit Measure, Product Group, Product, Warehouse, Transfer Out, Transfer In, Positive/Negative Adjustment, Scrapping, Stock Count, Transaction Report, Stock Report, Movement Report

Utilities

Booking Group, Booking Resource, Booking Manager, Scheduler, Program Resource, Program Manager, To-Do List

System Logs

Database log, File log

App Settings

Users, Currencies, Auto Number

System Settings

full inspection mode for appsettings.json

+ + +

Technology

Technologies Used

Blazor CRM Multi-Tenant is built on the modern .NET ecosystem with production-grade libraries and tools.

+ .NET 10 + ASP.NET Core 10 + Blazor Server + MudBlazor + ASP.NET Core Minimal APIs + Entity Framework Core 10 + MediatR + CQRS + FluentValidation + Swagger / OpenAPI + SignalR +

+ + + + + + + + + + + + + + + + + +

Layer	Technology
Framework	.NET 10
Web Framework	ASP.NET Core 10
UI Rendering	Blazor Server (SignalR-based real-time UI)
UI Component Library	MudBlazor (Material Design components for Blazor)
Architecture Pattern	Vertical Slice Architecture (VSA) + CQRS via MediatR
Multi-Tenancy	EF Core Global Query Filters with TenantId isolation
API Style	ASP.NET Core Minimal APIs with Swagger/OpenAPI
Data Access	Entity Framework Core 10 (Code-First, Migrations, Compiled Queries)
Database	SQL Server (fully tested) / PostgreSQL (scaffolded)
Validation	FluentValidation
Authentication	ASP.NET Core Identity + JWT Bearer Token
Authorization	Role-Based (RBAC) + Policy-Based Authorization
Real-Time	SignalR (built into Blazor Server)

+ + +

Architecture

Application Architecture

Blazor CRM Multi-Tenant uses Vertical Slice Architecture (VSA) with CQRS via MediatR and EF Core global query filters for complete tenant isolation.

Vertical Slice Architecture

Each feature (Create Tenant, Get Contact, Update Deal, etc.) lives in its own folder with its Minimal API endpoint, MediatR handler, FluentValidation validator, and EF Core queries all in one place. Zero coupling between features. Every handler automatically applies tenant filtering.

Folder structure: Features/Tenants/CreateTenant/ contains endpoint, handler, validator, DTO — everything for that single operation with tenant awareness built in.

Multi-Tenant Isolation

Tenant isolation is implemented at the EF Core level using global query filters. Every entity has a TenantId property, and EF Core automatically applies .Where(e => e.TenantId == currentTenantId) to all queries. Zero data leakage by design — no developer can accidentally query across tenants.

Tenant resolution: Determined from the authenticated user's claims, applied to DbContext at request scope.

Single-Project Monolith

The entire multi-tenant application — Blazor UI, REST API, tenant management, business logic, data access, and authentication — lives in one .NET 10 project. No distributed complexity, no microservice overhead. Single F5 to run. Deploy as one unit to Azure, IIS, or Docker. Perfect for SaaS startups that value velocity.

Project Structure Overview

BlazorCRMMultiTenant/
+├── Features/                    # Vertical Slices (one folder per feature)
+│   ├── Tenants/
+│   │   ├── CreateTenant/        # Endpoint + Handler + Validator + DTO
+│   │   ├── GetTenantList/
+│   │   └── UpdateTenant/
+│   ├── Contacts/
+│   ├── Companies/
+│   ├── Deals/
+│   ├── Leads/
+│   ├── Activities/
+│   └── Dashboard/
+├── Infrastructure/              # Cross-cutting: Auth, Audit, Tenant Resolution, EF Core
+├── Migrations/                  # EF Core migrations
+├── SeedData/                    # Initial seed data (demo tenants, users, sample data)
+├── Components/                  # Shared Blazor components
+├── wwwroot/                     # Static assets
+└── Program.cs                   # Single entry point with tenant-aware configuration

+ + +

Security

Security & Authorization

Security is baked into the architecture — multi-tenant isolation, Identity, JWT, RBAC, and audit trail.

Blazor CRM Multi-Tenant ships with tenant-aware authentication and authorization. ASP.NET Core Identity manages users per tenant with secure password hashing. JWT authentication protects all REST API endpoints, while cookie-based authentication handles Blazor Server UI. Both schemes run simultaneously and are tenant-scoped.

Role-based access control (RBAC) is fully tenant-scoped: each tenant has their own Admin, Manager, and User roles. Policy-based authorization provides fine-grained control. EF Core global query filters guarantee that Tenant A's data never leaks to Tenant B — enforced at the database level.

With Blazor Server, source code, database credentials, and tenant resolution logic never leave the server. All data access happens server-side via SignalR.

Security Features

Tenant Isolation — EF Core global query filters prevent data leakage between tenants
ASP.NET Core Identity — User registration, login, password hashing, password reset per tenant
JWT + Cookie Dual Auth — Cookies for Blazor UI, JWT for REST API, both tenant-scoped
Role-Based Access Control — Tenant-scoped Admin, Manager, User roles
Policy-Based Authorization — Declarative policies for fine-grained feature access
Audit Trail — Every create/update/delete logged with tenant, user ID, and timestamp
Server-Side Code — Source code, DB credentials, and tenant logic never leave the server

+ + +

Integration

REST API & Integration

Blazor CRM Multi-Tenant exposes a complete tenant-aware REST Web API — ready for mobile apps, third-party integrations, and external systems.

API Endpoints (Tenant-Aware)

Every feature exposes REST endpoints via ASP.NET Core Minimal APIs. All endpoints are JWT-protected and automatically scoped to the authenticated user's tenant.

GET/api/tenants— List tenants (admin only)

GET/api/contacts— List contacts (tenant-scoped)

GET/api/contacts/{id}— Get contact by ID (tenant-scoped)

POST/api/contacts— Create new contact (auto-assigned to tenant)

PUT/api/contacts/{id}— Update contact (tenant-scoped)

DELETE/api/contacts/{id}— Delete contact (tenant-scoped)

Same tenant-aware pattern applies to all entities: Companies, Deals, Leads, Activities, and Dashboard aggregations.

API Features

Swagger/OpenAPI Docs — Interactive API documentation at /swagger
JWT Authentication — All endpoints require Bearer token with tenant claim
Automatic Tenant Scoping — API returns only data belonging to authenticated user's tenant
FluentValidation — Input validation on all endpoints
Pagination & Filtering — Built-in query parameters for list endpoints
Mobile-Ready — Use the API to build mobile apps or integrate with external systems

+ + +

Database & Deployment

EF Core migrations, seed data with demo tenants, and flexible deployment options — ready to run in under 60 seconds.

Database

SQL Server — Fully tested with EF Core migrations and seed data included
PostgreSQL — Scaffolded in codebase (provider + connection string config ready, not fully tested)
EF Core Migrations — Code-first approach with full migration history
Seed Data — Demo tenants with full user sets (admin, manager, user), sample contacts, companies, deals
Compiled Queries — Performance-optimized EF Core queries with tenant filtering

Deployment Options

Azure App Service — Deploy directly from Visual Studio or GitHub Actions
IIS (Windows Server) — Standard ASP.NET Core publish to IIS
Docker — Containerize and deploy anywhere Docker runs
Windows / Linux / macOS — .NET 10 runs everywhere
Single Project — No distributed complexity. One publish, one deploy, serve all tenants
Setup Time: Clone repo → set connection string → F5 → serving multiple tenants in under 60 seconds

+ + +

Application Screenshots

Explore the Blazor CRM Multi-Tenant interface — tenant management, dashboards, contact management, sales pipeline, and more.

Blazor CRM Multi-Tenant Dashboard Overview

Blazor CRM Multi-Tenant Contact Management

Blazor CRM Multi-Tenant Tenant Management

Blazor CRM Multi-Tenant Reporting & Analytics

+ + +

Try the Live Demo

Test every feature — including multi-tenant isolation — before you buy. No registration required.

URL: https://blazor-saas-crm.csharpasp.net/

Email: admin@root.com

Password: 123456

+ + +

Get Blazor CRM Multi-Tenant Source Code

Complete, unrestricted C# source code with full multi-tenant SaaS architecture. Single .NET 10 project. Clone, F5, serve multiple tenants.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy +

Secure checkout via Lemon Squeezy. Lifetime access. No subscription.

+ + +

FAQ

Frequently Asked Questions

+ +

You get the complete, unrestricted C# source code of the entire Blazor CRM Multi-Tenant application. A single .NET 10 project with all features, multi-tenant architecture with EF Core global query filters, Vertical Slice Architecture, EF Core migrations, seed data with demo tenants, and full configuration. Clone, set connection string, press F5, and serve multiple tenants immediately.

+ +

Multi-tenancy uses EF Core global query filters with a TenantId on every entity. When a user authenticates, their tenant is resolved from claims. EF Core automatically applies .Where(e => e.TenantId == currentTenantId) to all queries. Zero data leakage between tenants. Each tenant has isolated users, contacts, deals, and dashboards — all in one database.

+ +

Absolutely! You receive the complete source code. You can rebrand, add custom features, modify the multi-tenant architecture, and deploy as your own SaaS product. Each license covers one end product per client project. See our License page.

+ +

Absolutely! The code is clean, well-structured, and self-documenting. Beginners can study real multi-tenant SaaS patterns, EF Core global query filters, authentication flows, VSA feature organization, and REST API design — all in a single project.

+ +

Due to the digital nature of source code, we have a strict no-refund policy. That's why we provide a fully functional live demo with multi-tenant testing — test every feature before you buy. Full policy here.

+ + + + + + \ No newline at end of file diff --git a/products/blazor-crm.html b/products/blazor-crm.html new file mode 100644 index 0000000..ce174a4 --- /dev/null +++ b/products/blazor-crm.html @@ -0,0 +1,543 @@ + + + + + + + +Blazor CRM — Customer Relationship Management .NET 10 Source Code | Indotalent + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ .NET 10 · Blazor Server · VSA · MudBlazor +

Blazor CRM

Customer Relationship Management — Complete Source Code

A production-ready CRM application to manage contacts, companies, sales pipeline, leads, and customer relationships. Built with .NET 10, ASP.NET Core, Blazor Server, MudBlazor, and Vertical Slice Architecture.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy + Live Demo +

Blazor CRM Dashboard — Customer Relationship Management .NET 10 Blazor Server

+ + +

+ + +

The Problem

Business Problems Solved by Blazor CRM

Every business needs to manage customer relationships — but fragmented tools, manual tracking, and disconnected data cost time and revenue.

Scattered Customer Data

Sales teams store contacts in spreadsheets, email inboxes, and personal notes. No central source of truth means missed follow-ups, duplicate entries, and lost opportunities. Blazor CRM centralizes all contact, company, and deal data in one searchable, organized system with complete history tracking.

No Sales Pipeline Visibility

Without a structured pipeline, managers cannot forecast revenue or identify bottlenecks. Deals get stuck without anyone noticing. Blazor CRM provides a visual sales pipeline with deal stages (Prospecting, Qualification, Proposal, Negotiation, Closed Won/Lost) so you always know where every deal stands.

Missed Follow-Ups & No Activity Tracking

Critical follow-ups slip through the cracks when there is no logging system. Blazor CRM tracks every activity — calls, emails, meetings, notes — and links them to contacts and deals. Complete activity timeline for every customer relationship.

No Actionable Insights

Without dashboards and reports, management flies blind. Blazor CRM includes KPI dashboards with charts and summary cards showing pipeline value, win rate, conversion metrics, and sales performance — all powered by EF Core aggregation queries.

+ + +

Business Features

What's Included in Blazor CRM

Complete end-to-end business features — every module is a complete vertical slice with endpoint, handler, validator, and EF Core queries.

Profile

Personal Info, Password, Avatar, Session

Pipeline

Campaign, Budget, Expense, Lead, Lead Contacts, Lead Activities, Sales Team, Sales Representative

Third Party

Customer Group, Customer Category, Customer, Customer Contact, Vendor Group, Vendor Category, Vendor, Vendor Contact

Sales

Quotation, Sales Order, Delivery Order, Sales Return, Invoice, Credit Note, Payment, Sales Report, Delivery Report, Return Report, Invoice Report, Payment Report

Purchase

Requisition, Purchase Order, Goods Receive, Purchase Return, Bill, Debit Note, Payment, Purchase Report, Receive Report, Return Report, Bill Report, Payment Report

Inventory

Unit Measure, Product Group, Product, Warehouse, Transfer Out, Transfer In, Positive/Negative Adjustment, Scrapping, Stock Count, Transaction Report, Stock Report, Movement Report

Utilities

Booking Group, Booking Resource, Booking Manager, Scheduler, Program Resource, Program Manager, To-Do List

System Logs

Database log, File log

App Settings

Users, Currencies, Auto Number

System Settings

full inspection mode for appsettings.json

+ + +

Technology

Technologies Used

Blazor CRM is built on the modern .NET ecosystem with production-grade libraries and tools.

+ .NET 10 + ASP.NET Core 10 + Blazor Server + MudBlazor + ASP.NET Core Minimal APIs + Entity Framework Core 10 + MediatR + CQRS + FluentValidation + Swagger / OpenAPI + SignalR +

+ + + + + + + + + + + + + + + + +

Layer	Technology
Framework	.NET 10
Web Framework	ASP.NET Core 10
UI Rendering	Blazor Server (SignalR-based real-time UI)
UI Component Library	MudBlazor (Material Design components for Blazor)
Architecture Pattern	Vertical Slice Architecture (VSA) + CQRS via MediatR
API Style	ASP.NET Core Minimal APIs with Swagger/OpenAPI
Data Access	Entity Framework Core 10 (Code-First, Migrations, Compiled Queries)
Database	SQL Server (fully tested) / PostgreSQL (scaffolded)
Validation	FluentValidation
Authentication	ASP.NET Core Identity + JWT Bearer Token
Authorization	Role-Based (RBAC) + Policy-Based Authorization
Real-Time	SignalR (built into Blazor Server)

+ + +

Architecture

Application Architecture

Blazor CRM uses Vertical Slice Architecture (VSA) with CQRS via MediatR — the modern, maintainable approach to building .NET applications.

Vertical Slice Architecture

Folder structure: Features/Contacts/CreateContact/ contains endpoint, handler, validator, DTO, and mapping — everything for that single operation.

CQRS via MediatR

Example: GetContactByIdQuery uses .AsNoTracking(). CreateContactCommand uses full change tracking with validation pipeline behavior.

Single-Project Monolith

Project Structure Overview

BlazorCRM/
+├── Features/                    # Vertical Slices (one folder per feature)
+│   ├── Contacts/
+│   │   ├── CreateContact/       # Endpoint + Handler + Validator + DTO
+│   │   ├── GetContactById/
+│   │   ├── GetContactList/
+│   │   ├── UpdateContact/
+│   │   └── DeleteContact/
+│   ├── Companies/
+│   ├── Deals/
+│   ├── Leads/
+│   ├── Activities/
+│   └── Dashboard/
+├── Infrastructure/              # Cross-cutting: Auth, Audit, EF Core
+├── Migrations/                  # EF Core migrations
+├── SeedData/                    # Initial seed data (demo users, sample data)
+├── Components/                  # Shared Blazor components
+├── wwwroot/                     # Static assets
+└── Program.cs                   # Single entry point with full configuration

+ + +

Security

Security & Authorization

Security is baked into the architecture from the ground up — not bolted on as an afterthought.

Blazor CRM ships with a fully configured authentication and authorization system. ASP.NET Core Identity manages users and roles with secure password hashing. JWT (JSON Web Token) authentication protects all REST API endpoints, while cookie-based authentication handles Blazor Server UI access. Both schemes run simultaneously.

Security Features

ASP.NET Core Identity — User registration, login, password hashing, password reset
JWT + Cookie Dual Auth — Cookies for Blazor UI, JWT for REST API
Role-Based Access Control — Admin, Manager, User roles with granular permissions
Policy-Based Authorization — Declarative policies for fine-grained feature access
Audit Trail — Every create/update/delete logged with user ID and timestamp
SignalR Protection — Blazor Server connections secured with [Authorize]
Server-Side Code — Source code and DB credentials never leave the server

+ + +

Integration

REST API & Integration

Blazor CRM exposes a complete REST Web API for all entities — ready for mobile apps, third-party integrations, and external systems.

API Endpoints

Every feature exposes REST endpoints via ASP.NET Core Minimal APIs. All endpoints are JWT-protected and return proper HTTP status codes.

GET/api/contacts— List contacts with pagination, search, sort

GET/api/contacts/{id}— Get contact by ID

POST/api/contacts— Create new contact

PUT/api/contacts/{id}— Update contact

DELETE/api/contacts/{id}— Delete contact

Same pattern applies to all entities: Companies, Deals, Leads, Activities, and Dashboard aggregations.

API Features

Swagger/OpenAPI Docs — Interactive API documentation at /swagger
JWT Authentication — All endpoints require Bearer token
Request/Response DTOs — Clean separation from domain models
FluentValidation — Input validation on all endpoints
Pagination & Filtering — Built-in query parameters for list endpoints
Mobile-Ready — Use the API to build mobile apps or integrate with external systems

+ + +

Database & Deployment

EF Core migrations, seed data, and flexible deployment options — ready to run in under 60 seconds.

Database

SQL Server — Fully tested with EF Core migrations and seed data included
PostgreSQL — Scaffolded in codebase (provider + connection string config ready, not fully tested)
EF Core Migrations — Code-first approach with full migration history
Seed Data — Demo users (admin, manager, user), sample contacts, companies, deals
Compiled Queries — Performance-optimized EF Core queries

Deployment Options

Azure App Service — Deploy directly from Visual Studio or GitHub Actions
IIS (Windows Server) — Standard ASP.NET Core publish to IIS
Docker — Containerize and deploy anywhere Docker runs
Windows / Linux / macOS — .NET 10 runs everywhere
Single Project — No distributed complexity. One publish, one deploy
Setup Time: Clone repo → set connection string → F5 → running in under 60 seconds

+ + +

Application Screenshots

Explore the Blazor CRM interface — dashboards, contact management, sales pipeline, and more.

+ + +

Try the Live Demo

Test every feature before you buy. No registration required.

URL: https://blazor-crm.csharpasp.net/

Email: admin@root.com

Password: 123456

+ + +

Get Blazor CRM Source Code

Complete, unrestricted C# source code. Single .NET 10 project. Clone, F5, run.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy +

Secure checkout via Lemon Squeezy. Lifetime access. No subscription.

+ + +

FAQ

Frequently Asked Questions

+ +

You get the complete, unrestricted C# source code of the entire Blazor CRM application. A single .NET 10 project with all features, Vertical Slice Architecture implementation, EF Core migrations, seed data, and full configuration. Clone, set your connection string, press F5, and it runs immediately. Includes Blazor Server UI, REST API, authentication, authorization, audit trail, and all CRM features.

+ +

Blazor CRM uses Vertical Slice Architecture (VSA) with CQRS via MediatR. Each feature (Create Contact, Get Deal, etc.) lives in its own folder with endpoint, MediatR handler, FluentValidation validator, and EF Core queries. This pattern is AI-friendly, beginner-friendly, and production-proven. Read our VSA Introduction.

+ +

Due to the digital nature of source code, we have a strict no-refund policy. That's why we provide a fully functional live demo — test every feature before you buy. Full policy here.

+ + + + + + \ No newline at end of file diff --git a/products/blazor-hrm-multitenant.html b/products/blazor-hrm-multitenant.html new file mode 100644 index 0000000..fcd839a --- /dev/null +++ b/products/blazor-hrm-multitenant.html @@ -0,0 +1,448 @@ + + + + + + + +Blazor HRM Multi-Tenant — SaaS HRM with Multi-Tenancy .NET 10 Source Code | Indotalent + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ SaaS · Multi-Tenant · .NET 10 · Blazor Server · VSA +

Blazor HRM Multi-Tenant

SaaS HRM with Multi-Tenancy — Complete Source Code

A production-ready multi-tenant SaaS HRM application to manage workforce across multiple organizations from a single deployment. Built with .NET 10, ASP.NET Core, Blazor Server, MudBlazor, and Vertical Slice Architecture. Complete tenant isolation with EF Core global query filters.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy + Live Demo +

Blazor HRM Multi-Tenant Dashboard — SaaS HRM .NET 10 Blazor Server

+ +

+ +

The Problem

Business Problems Solved by Blazor HRM Multi-Tenant

HRM Multitenant: The Next-Gen People Engine: Built for Scale, Engineered for Excellence.

Managing Multiple Client Workforces

Running separate HRM instances for each client is costly. Blazor HRM Multi-Tenant allows multiple organizations to share one deployment with complete workforce data isolation via TenantId global query filters. Add new client organizations in seconds.

Confidential Employee Data Leakage

Employee data is highly confidential. Without proper isolation, one client's workforce data could leak to another. EF Core global query filters automatically scope every query. Tenant A's employees, salaries, and leave records are invisible to Tenant B.

Disconnected Leave & Attendance Per Tenant

Each tenant needs their own leave policies and attendance tracking. Blazor HRM Multi-Tenant provides tenant-scoped leave management with approval workflows, attendance logging, and calendar views — all isolated per organization.

No Tenant-Aware Workforce Analytics

HR service providers need per-tenant dashboards and reports. Blazor HRM Multi-Tenant includes tenant-aware workforce dashboards with headcount, department distribution, leave balances, and attendance metrics — all scoped per organization.

+ + +

Business Features

What's Included in Blazor HRM Multi-Tenant

Complete end-to-end business features with multi-tenant isolation — every module is a complete vertical slice with endpoint, handler, validator, and EF Core queries.

Profile

Personal Info, Password, Avatar, Session

Leave Management

Leave Request, Leave Categories, Leave Balance

Performance

Evaluation, Appraisal, Promotion, Transfer

Organization

Branches, Departments, Designations, Employees

Payroll Process

Salary Grades, Income, Deduction

System Logs

Database log, File log

App Settings

Users, Currencies, Auto Number

System Settings

full inspection mode for appsettings.json

+ +

Technology

Technologies Used

+ .NET 10 + ASP.NET Core 10 + Blazor Server + MudBlazor + ASP.NET Core Minimal APIs + Entity Framework Core 10 + MediatR + CQRS + FluentValidation + Swagger / OpenAPI + SignalR +

+ + + + + + + + + + + + + + + + +

Layer	Technology
Framework	.NET 10
Web Framework	ASP.NET Core 10
UI Rendering	Blazor Server (SignalR-based real-time UI)
UI Library	MudBlazor (Material Design for Blazor)
Architecture	Vertical Slice Architecture (VSA) + CQRS via MediatR
Multi-Tenancy	EF Core Global Query Filters with TenantId isolation
API Style	ASP.NET Core Minimal APIs with Swagger/OpenAPI
Data Access	Entity Framework Core 10 (Code-First, Migrations, Compiled Queries)
Database	SQL Server (fully tested) / PostgreSQL (scaffolded)
Validation	FluentValidation
Authentication	ASP.NET Core Identity + JWT Bearer Token
Authorization	Role-Based (RBAC) + Policy-Based Authorization
Real-Time	SignalR (built into Blazor Server)

+ +

Architecture

Application Architecture

Blazor HRM Multi-Tenant uses Vertical Slice Architecture (VSA) with CQRS via MediatR and EF Core global query filters for complete tenant isolation across all workforce features.

Vertical Slice Architecture

Each feature (Create Employee, Approve Leave, etc.) lives in its own folder with endpoint, MediatR handler, validator, and EF Core queries — all in one place. Every handler automatically applies tenant filtering.

Multi-Tenant Isolation

Tenant isolation via EF Core global query filters. Every entity has TenantId; EF Core auto-applies .Where(e => e.TenantId == currentTenantId) to all queries. Zero data leakage by design.

Single-Project Monolith

The entire multi-tenant HRM application lives in one .NET 10 project. No distributed complexity. Single F5 to run. Deploy as one unit. Perfect for SaaS HR service providers.

Project Structure Overview

BlazorHRMMultiTenant/
+├── Features/
+│   ├── Tenants/
+│   ├── Employees/
+│   ├── Departments/
+│   ├── Designations/
+│   ├── LeaveManagement/
+│   ├── Attendance/
+│   ├── Payroll/
+│   └── Dashboard/
+├── Infrastructure/              # Auth, Audit, Tenant Resolution, EF Core
+├── Migrations/
+├── SeedData/                    # Demo tenants, users, employee sample data
+├── Components/
+└── Program.cs

+ +

Security

Security & Authorization

Blazor HRM Multi-Tenant ships with tenant-aware security. ASP.NET Core Identity manages users per tenant. JWT protects REST API, cookies protect Blazor UI. Both are tenant-scoped.

Role-based access control is fully tenant-scoped — each tenant has their own Admin, Manager, and User roles. EF Core global query filters guarantee employee data never leaks between tenants.

With Blazor Server, all employee data, source code, and database credentials never leave the server.

Security Features

Tenant Isolation — EF Core global query filters prevent data leakage
ASP.NET Core Identity — Per-tenant user management
JWT + Cookie Dual Auth — Tenant-scoped authentication
RBAC — Tenant-scoped Admin, Manager, User roles
Policy-Based Authorization — Fine-grained HR access control
Audit Trail — Every HR action logged with tenant + user ID
Server-Side Code — Employee data never leaves the server

+ +

Integration

REST API & Integration

API Endpoints (Tenant-Aware)

GET/api/employees— List employees (tenant-scoped)

GET/api/employees/{id}— Get employee (tenant-scoped)

POST/api/employees— Create employee (auto-assigned to tenant)

PUT/api/employees/{id}— Update employee

DELETE/api/employees/{id}— Delete employee

Same pattern for: Departments, Designations, Leave Requests, Attendance, Payroll.

API Features

Swagger/OpenAPI — Interactive docs at /swagger
JWT Authentication — Bearer token with tenant claim
Auto Tenant Scoping — Only tenant-owned data returned
FluentValidation — Input validation on all endpoints
Pagination & Filtering — Built-in query parameters
Mobile-Ready — Build mobile HR apps with this API

+ +

Database & Deployment

Database

SQL Server — Fully tested with EF Core migrations and seed data
PostgreSQL — Scaffolded (provider ready, not fully tested)
EF Core Migrations — Code-first with full migration history
Seed Data — Demo tenants, employees, departments, leave types
Compiled Queries — Optimized EF Core queries with tenant filtering

Deployment Options

Azure App Service — Deploy from Visual Studio or CI/CD
IIS — Standard ASP.NET Core publish
Docker — Containerize for any platform
Windows / Linux / macOS
Setup: Clone → connection string → F5 → multi-tenant running in 60s

+ +

Application Screenshots

Blazor HRM Multi-Tenant Employee Management

Blazor HRM Multi-Tenant Tenant Management

Blazor HRM Multi-Tenant Leave Management

Blazor HRM Multi-Tenant Attendance Tracking

+ +

Try the Live Demo

URL: https://blazor-saas-hrm.csharpasp.net/

Email: admin@root.com

Password: 123456

+ +

Get Blazor HRM Multi-Tenant Source Code

Complete, unrestricted C# source code. Single .NET 10 project. Clone, F5, serve multiple organizations.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy +

Secure checkout via Lemon Squeezy. Lifetime access. No subscription.

+ +

FAQ

Frequently Asked Questions

Complete, unrestricted C# source code of the entire multi-tenant HRM application. Single .NET 10 project with VSA, EF Core global query filters, migrations, seed data with demo tenants. Clone, F5, serve multiple organizations immediately.

EF Core global query filters with TenantId on every entity. Each tenant sees only their employees, departments, and leave data. Zero data leakage — enforced at the database level.

Absolutely! Rebrand, add custom HR features, modify leave policies, integrate payroll systems. Deploy as your own SaaS platform. Each license covers one end product per client project. License details.

SQL Server fully tested. PostgreSQL scaffolded in codebase (provider + connection string ready, not fully tested).

Yes! Study real multi-tenant SaaS patterns, EF Core global query filters, VSA feature organization, and HRM domain design.

No refund due to digital nature. Test the fully functional live demo before buying. Full policy.

+ + + + + \ No newline at end of file diff --git a/products/blazor-hrm.html b/products/blazor-hrm.html new file mode 100644 index 0000000..ebc886f --- /dev/null +++ b/products/blazor-hrm.html @@ -0,0 +1,541 @@ + + + + + + + +Blazor HRM — Human Resource Management .NET 10 Source Code | Indotalent + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ .NET 10 · Blazor Server · VSA · MudBlazor +

Blazor CRM

Human Resource Management — Complete Source Code

A production-ready HRM application to manage employees, departments, leave, attendance, and payroll. Built with .NET 10, ASP.NET Core, Blazor Server, MudBlazor, and Vertical Slice Architecture.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy + Live Demo +

Blazor HRM Dashboard — Human Resource Management .NET 10 Blazor Server

+ + +

+ + +

The Problem

Business Problems Solved

Managing workforce data with spreadsheets and disconnected tools leads to errors, compliance issues, and wasted administrative time.

Scattered Employee Records

HR teams manage employees across spreadsheets, paper files, and email — leading to outdated records, duplicate entries, and compliance risks. Blazor HRM centralizes all employee data in one searchable, organized system with complete employment history and document storage.

Manual Leave & Attendance Tracking

Paper-based leave requests and manual attendance logs cause delays, lost forms, and payroll errors. Blazor HRM provides digital leave management with approval workflows, balance tracking, calendar views, and automated attendance logging — eliminating paperwork.

No Performance Management System

Without structured evaluations, appraisals, and promotion workflows, employee growth stalls. Blazor HRM includes a complete performance module with evaluation forms, appraisal tracking, promotion requests, and transfer management.

No Workforce Analytics

Without dashboards, management cannot track headcount, turnover, leave trends, or department distribution. Blazor HRM includes KPI dashboards with charts and summary cards — all powered by EF Core aggregation queries.

+ + +

Business Features

What's Included in Blazor HRM

Complete end-to-end business features — every module is a complete vertical slice with endpoint, handler, validator, and EF Core queries.

Profile

Personal Info, Password, Avatar, Session

Leave Management

Leave Request, Leave Categories, Leave Balance

Performance

Evaluation, Appraisal, Promotion, Transfer

Organization

Branches, Departments, Designations, Employees

Payroll Process

Salary Grades, Income, Deduction

System Logs

Database log, File log

App Settings

Users, Currencies, Auto Number

System Settings

full inspection mode for appsettings.json

+ + +

Technology

Technologies Used

Blazor HRM is built on the modern .NET ecosystem with production-grade libraries and tools.

+ .NET 10 + ASP.NET Core 10 + Blazor Server + MudBlazor + ASP.NET Core Minimal APIs + Entity Framework Core 10 + MediatR + CQRS + FluentValidation + Swagger / OpenAPI + SignalR +

+ + + + + + + + + + + + + + + + +

Layer	Technology
Framework	.NET 10
Web Framework	ASP.NET Core 10
UI Rendering	Blazor Server (SignalR-based real-time UI)
UI Component Library	MudBlazor (Material Design components for Blazor)
Architecture Pattern	Vertical Slice Architecture (VSA) + CQRS via MediatR
API Style	ASP.NET Core Minimal APIs with Swagger/OpenAPI
Data Access	Entity Framework Core 10 (Code-First, Migrations, Compiled Queries)
Database	SQL Server (fully tested) / PostgreSQL (scaffolded)
Validation	FluentValidation
Authentication	ASP.NET Core Identity + JWT Bearer Token
Authorization	Role-Based (RBAC) + Policy-Based Authorization
Real-Time	SignalR (built into Blazor Server)

+ + +

Architecture

Application Architecture

Blazor HRM uses Vertical Slice Architecture (VSA) with CQRS via MediatR — the modern, maintainable approach to building .NET applications.

Vertical Slice Architecture

Folder structure: Features/Employees/CreateContact/ contains endpoint, handler, validator, DTO, and mapping — everything for that single operation.

CQRS via MediatR

Example: GetContactByIdQuery uses .AsNoTracking(). CreateContactCommand uses full change tracking with validation pipeline behavior.

Single-Project Monolith

Project Structure Overview

BlazorHRM/
+├── Features/                    # Vertical Slices (one folder per feature)
+│   ├── Employees/
+│   │   ├── CreateContact/       # Endpoint + Handler + Validator + DTO
+│   │   ├── GetContactById/
+│   │   ├── GetContactList/
+│   │   ├── UpdateContact/
+│   │   └── DeleteContact/
+│   ├── Departments/
+│   ├── LeaveManagement/
+│   ├── Attendance/
+│   ├── Payroll/
+│   └── Dashboard/
+├── Infrastructure/              # Cross-cutting: Auth, Audit, EF Core
+├── Migrations/                  # EF Core migrations
+├── SeedData/                    # Initial seed data (demo users, sample data)
+├── Components/                  # Shared Blazor components
+├── wwwroot/                     # Static assets
+└── Program.cs                   # Single entry point with full configuration

+ + +

Security

Security & Authorization

Security is baked into the architecture from the ground up — not bolted on as an afterthought.

Blazor HRM ships with a fully configured authentication and authorization system. ASP.NET Core Identity manages users and roles with secure password hashing. JWT (JSON Web Token) authentication protects all REST API endpoints, while cookie-based authentication handles Blazor Server UI access. Both schemes run simultaneously.

Security Features

ASP.NET Core Identity — User registration, login, password hashing, password reset
JWT + Cookie Dual Auth — Cookies for Blazor UI, JWT for REST API
Role-Based Access Control — Admin, Manager, User roles with granular permissions
Policy-Based Authorization — Declarative policies for fine-grained feature access
Audit Trail — Every create/update/delete logged with user ID and timestamp
SignalR Protection — Blazor Server connections secured with [Authorize]
Server-Side Code — Source code and DB credentials never leave the server

+ + +

Integration

REST API & Integration

Blazor HRM exposes a complete REST Web API for all entities — ready for mobile apps, third-party integrations, and external systems.

API Endpoints

Every feature exposes REST endpoints via ASP.NET Core Minimal APIs. All endpoints are JWT-protected and return proper HTTP status codes.

GET/api/contacts— List contacts with pagination, search, sort

GET/api/contacts/{id}— Get contact by ID

POST/api/contacts— Create new contact

PUT/api/contacts/{id}— Update contact

DELETE/api/contacts/{id}— Delete contact

Same pattern applies to all entities: Companies, Deals, Leads, Activities, and Dashboard aggregations.

API Features

Swagger/OpenAPI Docs — Interactive API documentation at /swagger
JWT Authentication — All endpoints require Bearer token
Request/Response DTOs — Clean separation from domain models
FluentValidation — Input validation on all endpoints
Pagination & Filtering — Built-in query parameters for list endpoints
Mobile-Ready — Use the API to build mobile apps or integrate with external systems

+ + +

Database & Deployment

EF Core migrations, seed data, and flexible deployment options — ready to run in under 60 seconds.

Database

SQL Server — Fully tested with EF Core migrations and seed data included
PostgreSQL — Scaffolded in codebase (provider + connection string config ready, not fully tested)
EF Core Migrations — Code-first approach with full migration history
Seed Data — Demo users (admin, manager, user), sample business records
Compiled Queries — Performance-optimized EF Core queries

Deployment Options

Azure App Service — Deploy directly from Visual Studio or GitHub Actions
IIS (Windows Server) — Standard ASP.NET Core publish to IIS
Docker — Containerize and deploy anywhere Docker runs
Windows / Linux / macOS — .NET 10 runs everywhere
Single Project — No distributed complexity. One publish, one deploy
Setup Time: Clone repo → set connection string → F5 → running in under 60 seconds

+ + +

Application Screenshots

Explore the Blazor HRM interface — dashboards, data management, workflow management, and more.

+ + +

Try the Live Demo

Test every feature before you buy. No registration required.

URL: https://blazor-hrm.csharpasp.net/

Email: admin@root.com

Password: 123456

+ + +

Get Blazor HRM Source Code

Complete, unrestricted C# source code. Single .NET 10 project. Clone, F5, run.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy +

Secure checkout via Lemon Squeezy. Lifetime access. No subscription.

+ + +

FAQ

Frequently Asked Questions

+ +

You get the complete, unrestricted C# source code of the entire Blazor HRM application. A single .NET 10 project with all features, Vertical Slice Architecture implementation, EF Core migrations, seed data, and full configuration. Clone, set your connection string, press F5, and it runs immediately. Includes Blazor Server UI, REST API, authentication, authorization, audit trail, and all CRM features.

+ +

Blazor HRM uses Vertical Slice Architecture (VSA) with CQRS via MediatR. Each feature (Create Contact, Get Deal, etc.) lives in its own folder with endpoint, MediatR handler, FluentValidation validator, and EF Core queries. This pattern is AI-friendly, beginner-friendly, and production-proven. Read our VSA Introduction.

+ +

Due to the digital nature of source code, we have a strict no-refund policy. That's why we provide a fully functional live demo — test every feature before you buy. Full policy here.

+ + + + + + \ No newline at end of file diff --git a/products/blazor-oms.html b/products/blazor-oms.html new file mode 100644 index 0000000..9bbcd06 --- /dev/null +++ b/products/blazor-oms.html @@ -0,0 +1,542 @@ + + + + + + + +Blazor OMS — Order Management System .NET 10 Source Code | Indotalent + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ .NET 10 · Blazor Server · VSA · MudBlazor +

Blazor CRM

Order Management System — Complete Source Code

A production-ready order management application to manage sales orders, purchase orders, inventory, and customers. Built with .NET 10, ASP.NET Core, Blazor Server, MudBlazor, and Vertical Slice Architecture.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy + Live Demo +

Blazor OMS Dashboard — Order Management System .NET 10 Blazor Server

+ + +

+ + +

The Problem

Business Problems Solved

Businesses struggle with fragmented order processing, disconnected sales and purchase cycles, and manual inventory tracking — leading to errors, delays, and lost revenue.

Disconnected Sales & Purchase Cycles

Sales orders and purchase orders are managed in separate systems, causing stockouts, over-ordering, and cash flow issues. Blazor OMS unifies the entire order-to-cash and procure-to-pay cycle in one integrated system.

Manual Inventory Tracking

Without real-time inventory visibility, businesses overstock or run out of critical products. Blazor OMS provides complete inventory management with product groups, unit measures, warehouse tracking, and stock reports.

No Centralized Customer & Vendor Data

Customer and vendor information is scattered across emails and spreadsheets. Blazor OMS centralizes all third-party data — customer groups, vendor categories, contacts — with full search and history.

No Order Analytics

Without dashboards, management cannot track sales performance, purchase efficiency, or inventory levels. Blazor OMS includes KPI dashboards with sales reports, purchase reports, and payment summaries.

+ + +

Business Features

What's Included in Blazor OMS

Complete end-to-end business features — every module is a complete vertical slice with endpoint, handler, validator, and EF Core queries.

Profile

Personal Info, Password, Avatar, Session

Third Party

Customer Group, Customer Category, Customer, Customer Contact, Vendor Group, Vendor Category, Vendor, Vendor Contact

Sales

Sales Order, Invoice, Payment, Sales Report, Invoice Report, Payment Report

Purchase

Purchase Order, Bill, Payment, Purchase Report, Bill Report, Payment Report

Inventory

Unit Measure, Product Group, Product, Warehouse

Utilities

Booking Group, Booking Resource, Booking Manager, Scheduler, Program Resource, Program Manager, To-Do List

System Logs

Database log, File log

App Settings

Users, Currencies, Auto Number

System Settings

full inspection mode for appsettings.json

+ + +

Technology

Technologies Used

Blazor OMS is built on the modern .NET ecosystem with production-grade libraries and tools.

+ .NET 10 + ASP.NET Core 10 + Blazor Server + MudBlazor + ASP.NET Core Minimal APIs + Entity Framework Core 10 + MediatR + CQRS + FluentValidation + Swagger / OpenAPI + SignalR +

+ + + + + + + + + + + + + + + + +

Layer	Technology
Framework	.NET 10
Web Framework	ASP.NET Core 10
UI Rendering	Blazor Server (SignalR-based real-time UI)
UI Component Library	MudBlazor (Material Design components for Blazor)
Architecture Pattern	Vertical Slice Architecture (VSA) + CQRS via MediatR
API Style	ASP.NET Core Minimal APIs with Swagger/OpenAPI
Data Access	Entity Framework Core 10 (Code-First, Migrations, Compiled Queries)
Database	SQL Server (fully tested) / PostgreSQL (scaffolded)
Validation	FluentValidation
Authentication	ASP.NET Core Identity + JWT Bearer Token
Authorization	Role-Based (RBAC) + Policy-Based Authorization
Real-Time	SignalR (built into Blazor Server)

+ + +

Architecture

Application Architecture

Blazor OMS uses Vertical Slice Architecture (VSA) with CQRS via MediatR — the modern, maintainable approach to building .NET applications.

Vertical Slice Architecture

Folder structure: Features/Orders/CreateContact/ contains endpoint, handler, validator, DTO, and mapping — everything for that single operation.

CQRS via MediatR

Example: GetContactByIdQuery uses .AsNoTracking(). CreateContactCommand uses full change tracking with validation pipeline behavior.

Single-Project Monolith

Project Structure Overview

BlazorOMS/
+├── Features/                    # Vertical Slices (one folder per feature)
+│   ├── Orders/
+│   │   ├── CreateContact/       # Endpoint + Handler + Validator + DTO
+│   │   ├── GetContactById/
+│   │   ├── GetContactList/
+│   │   ├── UpdateContact/
+│   │   └── DeleteContact/
+│   ├── Customers/
+│   ├── Products/
+│   ├── Inventory/
+│   ├── Shipments/
+│   └── Dashboard/
+├── Infrastructure/              # Cross-cutting: Auth, Audit, EF Core
+├── Migrations/                  # EF Core migrations
+├── SeedData/                    # Initial seed data (demo users, sample data)
+├── Components/                  # Shared Blazor components
+├── wwwroot/                     # Static assets
+└── Program.cs                   # Single entry point with full configuration

+ + +

Security

Security & Authorization

Security is baked into the architecture from the ground up — not bolted on as an afterthought.

Blazor OMS ships with a fully configured authentication and authorization system. ASP.NET Core Identity manages users and roles with secure password hashing. JWT (JSON Web Token) authentication protects all REST API endpoints, while cookie-based authentication handles Blazor Server UI access. Both schemes run simultaneously.

Security Features

ASP.NET Core Identity — User registration, login, password hashing, password reset
JWT + Cookie Dual Auth — Cookies for Blazor UI, JWT for REST API
Role-Based Access Control — Admin, Manager, User roles with granular permissions
Policy-Based Authorization — Declarative policies for fine-grained feature access
Audit Trail — Every create/update/delete logged with user ID and timestamp
SignalR Protection — Blazor Server connections secured with [Authorize]
Server-Side Code — Source code and DB credentials never leave the server

+ + +

Integration

REST API & Integration

Blazor OMS exposes a complete REST Web API for all entities — ready for mobile apps, third-party integrations, and external systems.

API Endpoints

Every feature exposes REST endpoints via ASP.NET Core Minimal APIs. All endpoints are JWT-protected and return proper HTTP status codes.

GET/api/contacts— List contacts with pagination, search, sort

GET/api/contacts/{id}— Get contact by ID

POST/api/contacts— Create new contact

PUT/api/contacts/{id}— Update contact

DELETE/api/contacts/{id}— Delete contact

Same pattern applies to all entities: Companies, Deals, Leads, Activities, and Dashboard aggregations.

API Features

Swagger/OpenAPI Docs — Interactive API documentation at /swagger
JWT Authentication — All endpoints require Bearer token
Request/Response DTOs — Clean separation from domain models
FluentValidation — Input validation on all endpoints
Pagination & Filtering — Built-in query parameters for list endpoints
Mobile-Ready — Use the API to build mobile apps or integrate with external systems

+ + +

Database & Deployment

EF Core migrations, seed data, and flexible deployment options — ready to run in under 60 seconds.

Database

SQL Server — Fully tested with EF Core migrations and seed data included
PostgreSQL — Scaffolded in codebase (provider + connection string config ready, not fully tested)
EF Core Migrations — Code-first approach with full migration history
Seed Data — Demo users (admin, manager, user), sample business records
Compiled Queries — Performance-optimized EF Core queries

Deployment Options

Azure App Service — Deploy directly from Visual Studio or GitHub Actions
IIS (Windows Server) — Standard ASP.NET Core publish to IIS
Docker — Containerize and deploy anywhere Docker runs
Windows / Linux / macOS — .NET 10 runs everywhere
Single Project — No distributed complexity. One publish, one deploy
Setup Time: Clone repo → set connection string → F5 → running in under 60 seconds

+ + +

Application Screenshots

Explore the Blazor OMS interface — dashboards, data management, workflow management, and more.

+ + +

Try the Live Demo

Test every feature before you buy. No registration required.

URL: https://blazor-oms.csharpasp.net/

Email: admin@root.com

Password: 123456

+ + +

Get Blazor OMS Source Code

Complete, unrestricted C# source code. Single .NET 10 project. Clone, F5, run.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy +

Secure checkout via Lemon Squeezy. Lifetime access. No subscription.

+ + +

FAQ

Frequently Asked Questions

+ +

You get the complete, unrestricted C# source code of the entire Blazor OMS application. A single .NET 10 project with all features, Vertical Slice Architecture implementation, EF Core migrations, seed data, and full configuration. Clone, set your connection string, press F5, and it runs immediately. Includes Blazor Server UI, REST API, authentication, authorization, audit trail, and all CRM features.

+ +

Blazor OMS uses Vertical Slice Architecture (VSA) with CQRS via MediatR. Each feature (Create Contact, Get Deal, etc.) lives in its own folder with endpoint, MediatR handler, FluentValidation validator, and EF Core queries. This pattern is AI-friendly, beginner-friendly, and production-proven. Read our VSA Introduction.

+ +

Due to the digital nature of source code, we have a strict no-refund policy. That's why we provide a fully functional live demo — test every feature before you buy. Full policy here.

+ + + + + + \ No newline at end of file diff --git a/products/blazor-scm.html b/products/blazor-scm.html new file mode 100644 index 0000000..408fb87 --- /dev/null +++ b/products/blazor-scm.html @@ -0,0 +1,542 @@ + + + + + + + +Blazor SCM — Supply Chain Management .NET 10 Source Code | Indotalent + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ .NET 10 · Blazor Server · VSA · MudBlazor +

Blazor CRM

Supply Chain Management — Complete Source Code

A production-ready supply chain management application to manage procurement, sales, inventory, and vendors. Built with .NET 10, ASP.NET Core, Blazor Server, MudBlazor, and Vertical Slice Architecture.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy + Live Demo +

Blazor SCM Dashboard — Supply Chain Management .NET 10 Blazor Server

+ + +

+ + +

The Problem

Business Problems Solved

Supply chain inefficiencies — fragmented procurement, manual inventory tracking, and disconnected logistics — cost businesses time, money, and competitive advantage.

Fragmented Procurement Process

Requisitions, purchase orders, goods receipts, and vendor bills are managed across emails and spreadsheets. Blazor SCM unifies the entire procure-to-pay cycle with full traceability from requisition to payment.

No Real-Time Inventory Visibility

Without real-time stock tracking across warehouses, businesses face stockouts, overstocking, and write-offs. Blazor SCM provides complete inventory management with transfers, adjustments, stock counts, and movement reports.

Disconnected Sales & Delivery

Sales orders, delivery orders, and returns are tracked in separate systems causing fulfillment delays. Blazor SCM integrates the full order-to-cash cycle — quotation to invoice, delivery to return — with complete audit trail.

No Supply Chain Analytics

Without dashboards, supply chain managers cannot identify bottlenecks, analyze vendor performance, or optimize inventory. Blazor SCM includes KPI dashboards with purchase reports, sales reports, inventory reports, and payment summaries.

+ + +

Business Features

What's Included in Blazor SCM

Complete end-to-end business features — every module is a complete vertical slice with endpoint, handler, validator, and EF Core queries.

Profile

Personal Info, Password, Avatar, Session

Third Party

Customer Group, Customer Category, Customer, Customer Contact, Vendor Group, Vendor Category, Vendor, Vendor Contact

Sales

Quotation, Sales Order, Delivery Order, Sales Return, Invoice, Credit Note, Payment, Sales Report, Delivery Report, Return Report, Invoice Report, Payment Report

Purchase

Requisition, Purchase Order, Goods Receive, Purchase Return, Bill, Debit Note, Payment, Purchase Report, Receive Report, Return Report, Bill Report, Payment Report

Inventory

Unit Measure, Product Group, Product, Warehouse

Utilities

Booking Group, Booking Resource, Booking Manager, Scheduler, Program Resource, Program Manager, To-Do List

System Logs

Database log, File log

App Settings

Users, Currencies, Auto Number

System Settings

full inspection mode for appsettings.json

+ + +

Technology

Technologies Used

Blazor SCM is built on the modern .NET ecosystem with production-grade libraries and tools.

+ .NET 10 + ASP.NET Core 10 + Blazor Server + MudBlazor + ASP.NET Core Minimal APIs + Entity Framework Core 10 + MediatR + CQRS + FluentValidation + Swagger / OpenAPI + SignalR +

+ + + + + + + + + + + + + + + + +

Layer	Technology
Framework	.NET 10
Web Framework	ASP.NET Core 10
UI Rendering	Blazor Server (SignalR-based real-time UI)
UI Component Library	MudBlazor (Material Design components for Blazor)
Architecture Pattern	Vertical Slice Architecture (VSA) + CQRS via MediatR
API Style	ASP.NET Core Minimal APIs with Swagger/OpenAPI
Data Access	Entity Framework Core 10 (Code-First, Migrations, Compiled Queries)
Database	SQL Server (fully tested) / PostgreSQL (scaffolded)
Validation	FluentValidation
Authentication	ASP.NET Core Identity + JWT Bearer Token
Authorization	Role-Based (RBAC) + Policy-Based Authorization
Real-Time	SignalR (built into Blazor Server)

+ + +

Architecture

Application Architecture

Blazor SCM uses Vertical Slice Architecture (VSA) with CQRS via MediatR — the modern, maintainable approach to building .NET applications.

Vertical Slice Architecture

Folder structure: Features/Products/CreateContact/ contains endpoint, handler, validator, DTO, and mapping — everything for that single operation.

CQRS via MediatR

Example: GetContactByIdQuery uses .AsNoTracking(). CreateContactCommand uses full change tracking with validation pipeline behavior.

Single-Project Monolith

Project Structure Overview

BlazorSCM/
+├── Features/                    # Vertical Slices (one folder per feature)
+│   ├── Products/
+│   │   ├── CreateContact/       # Endpoint + Handler + Validator + DTO
+│   │   ├── GetContactById/
+│   │   ├── GetContactList/
+│   │   ├── UpdateContact/
+│   │   └── DeleteContact/
+│   ├── Warehouses/
+│   ├── StockMovements/
+│   ├── Inventory/
+│   ├── Transfers/
+│   └── Dashboard/
+├── Infrastructure/              # Cross-cutting: Auth, Audit, EF Core
+├── Migrations/                  # EF Core migrations
+├── SeedData/                    # Initial seed data (demo users, sample data)
+├── Components/                  # Shared Blazor components
+├── wwwroot/                     # Static assets
+└── Program.cs                   # Single entry point with full configuration

+ + +

Security

Security & Authorization

Security is baked into the architecture from the ground up — not bolted on as an afterthought.

Blazor SCM ships with a fully configured authentication and authorization system. ASP.NET Core Identity manages users and roles with secure password hashing. JWT (JSON Web Token) authentication protects all REST API endpoints, while cookie-based authentication handles Blazor Server UI access. Both schemes run simultaneously.

Security Features

ASP.NET Core Identity — User registration, login, password hashing, password reset
JWT + Cookie Dual Auth — Cookies for Blazor UI, JWT for REST API
Role-Based Access Control — Admin, Manager, User roles with granular permissions
Policy-Based Authorization — Declarative policies for fine-grained feature access
Audit Trail — Every create/update/delete logged with user ID and timestamp
SignalR Protection — Blazor Server connections secured with [Authorize]
Server-Side Code — Source code and DB credentials never leave the server

+ + +

Integration

REST API & Integration

Blazor SCM exposes a complete REST Web API for all entities — ready for mobile apps, third-party integrations, and external systems.

API Endpoints

Every feature exposes REST endpoints via ASP.NET Core Minimal APIs. All endpoints are JWT-protected and return proper HTTP status codes.

GET/api/contacts— List contacts with pagination, search, sort

GET/api/contacts/{id}— Get contact by ID

POST/api/contacts— Create new contact

PUT/api/contacts/{id}— Update contact

DELETE/api/contacts/{id}— Delete contact

Same pattern applies to all entities: Companies, Deals, Leads, Activities, and Dashboard aggregations.

API Features

Swagger/OpenAPI Docs — Interactive API documentation at /swagger
JWT Authentication — All endpoints require Bearer token
Request/Response DTOs — Clean separation from domain models
FluentValidation — Input validation on all endpoints
Pagination & Filtering — Built-in query parameters for list endpoints
Mobile-Ready — Use the API to build mobile apps or integrate with external systems

+ + +

Database & Deployment

EF Core migrations, seed data, and flexible deployment options — ready to run in under 60 seconds.

Database

SQL Server — Fully tested with EF Core migrations and seed data included
PostgreSQL — Scaffolded in codebase (provider + connection string config ready, not fully tested)
EF Core Migrations — Code-first approach with full migration history
Seed Data — Demo users (admin, manager, user), sample business records
Compiled Queries — Performance-optimized EF Core queries

Deployment Options

Azure App Service — Deploy directly from Visual Studio or GitHub Actions
IIS (Windows Server) — Standard ASP.NET Core publish to IIS
Docker — Containerize and deploy anywhere Docker runs
Windows / Linux / macOS — .NET 10 runs everywhere
Single Project — No distributed complexity. One publish, one deploy
Setup Time: Clone repo → set connection string → F5 → running in under 60 seconds

+ + +

Application Screenshots

Explore the Blazor SCM interface — dashboards, data management, workflow management, and more.

+ + +

Try the Live Demo

Test every feature before you buy. No registration required.

URL: https://blazor-scm.csharpasp.net/

Email: admin@root.com

Password: 123456

+ + +

Get Blazor SCM Source Code

Complete, unrestricted C# source code. Single .NET 10 project. Clone, F5, run.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy +

Secure checkout via Lemon Squeezy. Lifetime access. No subscription.

+ + +

FAQ

Frequently Asked Questions

+ +

You get the complete, unrestricted C# source code of the entire Blazor SCM application. A single .NET 10 project with all features, Vertical Slice Architecture implementation, EF Core migrations, seed data, and full configuration. Clone, set your connection string, press F5, and it runs immediately. Includes Blazor Server UI, REST API, authentication, authorization, audit trail, and all CRM features.

+ +

Blazor SCM uses Vertical Slice Architecture (VSA) with CQRS via MediatR. Each feature (Create Contact, Get Deal, etc.) lives in its own folder with endpoint, MediatR handler, FluentValidation validator, and EF Core queries. This pattern is AI-friendly, beginner-friendly, and production-proven. Read our VSA Introduction.

+ +

Due to the digital nature of source code, we have a strict no-refund policy. That's why we provide a fully functional live demo — test every feature before you buy. Full policy here.

+ + + + + + \ No newline at end of file diff --git a/products/blazor-swm.html b/products/blazor-swm.html new file mode 100644 index 0000000..f475aa1 --- /dev/null +++ b/products/blazor-swm.html @@ -0,0 +1,543 @@ + + + + + + + +Blazor SWM — Spa & Wellness Management .NET 10 Source Code | Indotalent + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ .NET 10 · Blazor Server · VSA · MudBlazor +

Blazor CRM

Spa & Wellness Management — Complete Source Code

A production-ready spa & wellness management application to manage clients, appointments, services, and billing. Built with .NET 10, ASP.NET Core, Blazor Server, MudBlazor, and Vertical Slice Architecture.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy + Live Demo +

Blazor SWM Dashboard — Spa & Wellness Management .NET 10 Blazor Server

+ + +

+ + +

The Problem

Business Problems Solved

Spa, fitness, and wellness businesses struggle with fragmented appointment booking, manual client management, disconnected billing, and no business analytics — limiting growth and profitability.

Fragmented Client & Appointment Management

Client bookings are managed through phone calls, paper logs, and sticky notes. Double bookings and no-shows hurt revenue. Blazor SWM provides a complete booking system with resource scheduling, availability management, and client tracking.

Manual Sales & Billing

Service sales, packages, and invoices are handled manually leading to billing errors and delayed payments. Blazor SWM integrates the full sales cycle — from order to invoice to payment — with commission tracking for therapists.

Disconnected Employee & Commission Tracking

Therapist schedules, service assignments, and commissions are tracked in spreadsheets. Blazor SWM centralizes employee management with group categorization, service assignments, and automated commission reports.

No Business Analytics

Without dashboards, spa owners cannot see which services sell best, which therapists perform, or track revenue trends. Blazor SWM includes KPI dashboards with sales reports, commission reports, and inventory summaries.

+ + +

Business Features

What's Included in Blazor SWM

Complete end-to-end business features — every module is a complete vertical slice with endpoint, handler, validator, and EF Core queries.

Profile

Personal Info, Password, Avatar, Session

Third Party

Customer Group, Customer Category, Customer, Customer Contact, Vendor Group, Vendor Category, Vendor, Vendor Contact

Organization

Employee, Employee Group, Employee Category

Sales

Sales Order, Invoice, Payment, Sales Report, Commission Report, Invoice Report, Payment Report

Purchase

Purchase Order, Bill, Payment, Purchase Report, Bill Report, Payment Report

Inventory

Unit Measure, Product Group, Product, Warehouse

Utilities

Booking Group, Booking Resource, Booking Manager, Scheduler, To-Do List

System Logs

Database log, File log

App Settings

Users, Currencies, Auto Number

System Settings

full inspection mode for appsettings.json

+ + +

Technology

Technologies Used

Blazor SWM is built on the modern .NET ecosystem with production-grade libraries and tools.

+ .NET 10 + ASP.NET Core 10 + Blazor Server + MudBlazor + ASP.NET Core Minimal APIs + Entity Framework Core 10 + MediatR + CQRS + FluentValidation + Swagger / OpenAPI + SignalR +

+ + + + + + + + + + + + + + + + +

Layer	Technology
Framework	.NET 10
Web Framework	ASP.NET Core 10
UI Rendering	Blazor Server (SignalR-based real-time UI)
UI Component Library	MudBlazor (Material Design components for Blazor)
Architecture Pattern	Vertical Slice Architecture (VSA) + CQRS via MediatR
API Style	ASP.NET Core Minimal APIs with Swagger/OpenAPI
Data Access	Entity Framework Core 10 (Code-First, Migrations, Compiled Queries)
Database	SQL Server (fully tested) / PostgreSQL (scaffolded)
Validation	FluentValidation
Authentication	ASP.NET Core Identity + JWT Bearer Token
Authorization	Role-Based (RBAC) + Policy-Based Authorization
Real-Time	SignalR (built into Blazor Server)

+ + +

Architecture

Application Architecture

Blazor SWM uses Vertical Slice Architecture (VSA) with CQRS via MediatR — the modern, maintainable approach to building .NET applications.

Vertical Slice Architecture

Folder structure: Features/Products/CreateContact/ contains endpoint, handler, validator, DTO, and mapping — everything for that single operation.

CQRS via MediatR

Example: GetContactByIdQuery uses .AsNoTracking(). CreateContactCommand uses full change tracking with validation pipeline behavior.

Single-Project Monolith

Project Structure Overview

BlazorSWM/
+├── Features/                    # Vertical Slices (one folder per feature)
+│   ├── Products/
+│   │   ├── CreateContact/       # Endpoint + Handler + Validator + DTO
+│   │   ├── GetContactById/
+│   │   ├── GetContactList/
+│   │   ├── UpdateContact/
+│   │   └── DeleteContact/
+│   ├── Warehouses/
+│   ├── StockMovements/
+│   ├── Inventory/
+│   ├── Transfers/
+│   └── Dashboard/
+├── Infrastructure/              # Cross-cutting: Auth, Audit, EF Core
+├── Migrations/                  # EF Core migrations
+├── SeedData/                    # Initial seed data (demo users, sample data)
+├── Components/                  # Shared Blazor components
+├── wwwroot/                     # Static assets
+└── Program.cs                   # Single entry point with full configuration

+ + +

Security

Security & Authorization

Security is baked into the architecture from the ground up — not bolted on as an afterthought.

Blazor SWM ships with a fully configured authentication and authorization system. ASP.NET Core Identity manages users and roles with secure password hashing. JWT (JSON Web Token) authentication protects all REST API endpoints, while cookie-based authentication handles Blazor Server UI access. Both schemes run simultaneously.

Security Features

ASP.NET Core Identity — User registration, login, password hashing, password reset
JWT + Cookie Dual Auth — Cookies for Blazor UI, JWT for REST API
Role-Based Access Control — Admin, Manager, User roles with granular permissions
Policy-Based Authorization — Declarative policies for fine-grained feature access
Audit Trail — Every create/update/delete logged with user ID and timestamp
SignalR Protection — Blazor Server connections secured with [Authorize]
Server-Side Code — Source code and DB credentials never leave the server

+ + +

Integration

REST API & Integration

Blazor SWM exposes a complete REST Web API for all entities — ready for mobile apps, third-party integrations, and external systems.

API Endpoints

Every feature exposes REST endpoints via ASP.NET Core Minimal APIs. All endpoints are JWT-protected and return proper HTTP status codes.

GET/api/contacts— List contacts with pagination, search, sort

GET/api/contacts/{id}— Get contact by ID

POST/api/contacts— Create new contact

PUT/api/contacts/{id}— Update contact

DELETE/api/contacts/{id}— Delete contact

Same pattern applies to all entities: Companies, Deals, Leads, Activities, and Dashboard aggregations.

API Features

Swagger/OpenAPI Docs — Interactive API documentation at /swagger
JWT Authentication — All endpoints require Bearer token
Request/Response DTOs — Clean separation from domain models
FluentValidation — Input validation on all endpoints
Pagination & Filtering — Built-in query parameters for list endpoints
Mobile-Ready — Use the API to build mobile apps or integrate with external systems

+ + +

Database & Deployment

EF Core migrations, seed data, and flexible deployment options — ready to run in under 60 seconds.

Database

SQL Server — Fully tested with EF Core migrations and seed data included
PostgreSQL — Scaffolded in codebase (provider + connection string config ready, not fully tested)
EF Core Migrations — Code-first approach with full migration history
Seed Data — Demo users (admin, manager, user), sample business records
Compiled Queries — Performance-optimized EF Core queries

Deployment Options

Azure App Service — Deploy directly from Visual Studio or GitHub Actions
IIS (Windows Server) — Standard ASP.NET Core publish to IIS
Docker — Containerize and deploy anywhere Docker runs
Windows / Linux / macOS — .NET 10 runs everywhere
Single Project — No distributed complexity. One publish, one deploy
Setup Time: Clone repo → set connection string → F5 → running in under 60 seconds

+ + +

Application Screenshots

Explore the Blazor SWM interface — dashboards, data management, workflow management, and more.

+ + +

Try the Live Demo

Test every feature before you buy. No registration required.

URL: https://blazor-swm.csharpasp.net/

Email: admin@root.com

Password: 123456

+ + +

Get Blazor SWM Source Code

Complete, unrestricted C# source code. Single .NET 10 project. Clone, F5, run.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy +

Secure checkout via Lemon Squeezy. Lifetime access. No subscription.

+ + +

FAQ

Frequently Asked Questions

+ +

You get the complete, unrestricted C# source code of the entire Blazor SWM application. A single .NET 10 project with all features, Vertical Slice Architecture implementation, EF Core migrations, seed data, and full configuration. Clone, set your connection string, press F5, and it runs immediately. Includes Blazor Server UI, REST API, authentication, authorization, audit trail, and all CRM features.

+ +

Blazor SWM uses Vertical Slice Architecture (VSA) with CQRS via MediatR. Each feature (Create Contact, Get Deal, etc.) lives in its own folder with endpoint, MediatR handler, FluentValidation validator, and EF Core queries. This pattern is AI-friendly, beginner-friendly, and production-proven. Read our VSA Introduction.

+ +

Due to the digital nature of source code, we have a strict no-refund policy. That's why we provide a fully functional live demo — test every feature before you buy. Full policy here.

+ + + + + + \ No newline at end of file diff --git a/products/blazor-wms.html b/products/blazor-wms.html new file mode 100644 index 0000000..97c242a --- /dev/null +++ b/products/blazor-wms.html @@ -0,0 +1,542 @@ + + + + + + + +Blazor WMS — Warehouse Management System .NET 10 Source Code | Indotalent + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ .NET 10 · Blazor Server · VSA · MudBlazor +

Blazor CRM

Warehouse Management System — Complete Source Code

A production-ready warehouse management application to manage inventory, stock movements, sales, and procurement. Built with .NET 10, ASP.NET Core, Blazor Server, MudBlazor, and Vertical Slice Architecture.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy + Live Demo +

Blazor WMS Dashboard — Warehouse Management System .NET 10 Blazor Server

+ + +

+ + +

The Problem

Business Problems Solved

Warehouse operations suffer from manual inventory tracking, disconnected stock movements, fragmented sales-purchase cycles, and no real-time visibility — leading to errors, delays, and lost revenue.

Manual Inventory & Stock Management

Inventory is tracked on paper or spreadsheets, leading to stockouts, overstocking, write-offs, and inaccurate counts. Blazor WMS provides complete warehouse inventory management with real-time tracking, stock counts, adjustments, and movement reports.

Disconnected Sales & Delivery Operations

Sales orders, delivery orders, returns, and invoices are managed in separate systems causing fulfillment delays and errors. Blazor WMS integrates the full order-to-cash cycle with complete traceability from quotation to payment.

Fragmented Procurement & Receiving

Purchase requisitions, goods receipts, returns, and vendor bills are processed manually. Blazor WMS unifies the procure-to-pay cycle with automated receiving, debit notes, and payment tracking.

No Warehouse Analytics

Without dashboards, warehouse managers cannot track inventory levels, movement trends, stock turnover, or operational KPIs. Blazor WMS includes KPI dashboards with transaction reports, stock reports, inventory reports, and payment summaries.

+ + +

Business Features

What's Included in Blazor WMS

Complete end-to-end business features — every module is a complete vertical slice with endpoint, handler, validator, and EF Core queries.

Profile

Personal Info, Password, Avatar, Session

Third Party

Customer Group, Customer Category, Customer, Customer Contact, Vendor Group, Vendor Category, Vendor, Vendor Contact

Sales

Quotation, Sales Order, Delivery Order, Sales Return, Invoice, Credit Note, Payment, Sales Report, Delivery Report, Return Report, Invoice Report, Payment Report

Purchase

Requisition, Purchase Order, Goods Receive, Purchase Return, Bill, Debit Note, Payment, Purchase Report, Receive Report, Return Report, Bill Report, Payment Report

Inventory

Unit Measure, Product Group, Product, Warehouse, Transfer Out, Transfer In, Positive/Negative Adjustment, Scrapping, Stock Count, Transaction Report, Stock Report, Movement Report

Utilities

Booking Group, Booking Resource, Booking Manager, Scheduler, Program Resource, Program Manager, To-Do List

System Logs

Database log, File log

App Settings

Users, Currencies, Auto Number

System Settings

full inspection mode for appsettings.json

+ + +

Technology

Technologies Used

Blazor WMS is built on the modern .NET ecosystem with production-grade libraries and tools.

+ .NET 10 + ASP.NET Core 10 + Blazor Server + MudBlazor + ASP.NET Core Minimal APIs + Entity Framework Core 10 + MediatR + CQRS + FluentValidation + Swagger / OpenAPI + SignalR +

+ + + + + + + + + + + + + + + + +

Layer	Technology
Framework	.NET 10
Web Framework	ASP.NET Core 10
UI Rendering	Blazor Server (SignalR-based real-time UI)
UI Component Library	MudBlazor (Material Design components for Blazor)
Architecture Pattern	Vertical Slice Architecture (VSA) + CQRS via MediatR
API Style	ASP.NET Core Minimal APIs with Swagger/OpenAPI
Data Access	Entity Framework Core 10 (Code-First, Migrations, Compiled Queries)
Database	SQL Server (fully tested) / PostgreSQL (scaffolded)
Validation	FluentValidation
Authentication	ASP.NET Core Identity + JWT Bearer Token
Authorization	Role-Based (RBAC) + Policy-Based Authorization
Real-Time	SignalR (built into Blazor Server)

+ + +

Architecture

Application Architecture

Blazor WMS uses Vertical Slice Architecture (VSA) with CQRS via MediatR — the modern, maintainable approach to building .NET applications.

Vertical Slice Architecture

Folder structure: Features/Products/CreateContact/ contains endpoint, handler, validator, DTO, and mapping — everything for that single operation.

CQRS via MediatR

Example: GetContactByIdQuery uses .AsNoTracking(). CreateContactCommand uses full change tracking with validation pipeline behavior.

Single-Project Monolith

Project Structure Overview

BlazorWMS/
+├── Features/                    # Vertical Slices (one folder per feature)
+│   ├── Products/
+│   │   ├── CreateContact/       # Endpoint + Handler + Validator + DTO
+│   │   ├── GetContactById/
+│   │   ├── GetContactList/
+│   │   ├── UpdateContact/
+│   │   └── DeleteContact/
+│   ├── Warehouses/
+│   ├── StockMovements/
+│   ├── Inventory/
+│   ├── Transfers/
+│   └── Dashboard/
+├── Infrastructure/              # Cross-cutting: Auth, Audit, EF Core
+├── Migrations/                  # EF Core migrations
+├── SeedData/                    # Initial seed data (demo users, sample data)
+├── Components/                  # Shared Blazor components
+├── wwwroot/                     # Static assets
+└── Program.cs                   # Single entry point with full configuration

+ + +

Security

Security & Authorization

Security is baked into the architecture from the ground up — not bolted on as an afterthought.

Blazor WMS ships with a fully configured authentication and authorization system. ASP.NET Core Identity manages users and roles with secure password hashing. JWT (JSON Web Token) authentication protects all REST API endpoints, while cookie-based authentication handles Blazor Server UI access. Both schemes run simultaneously.

Security Features

ASP.NET Core Identity — User registration, login, password hashing, password reset
JWT + Cookie Dual Auth — Cookies for Blazor UI, JWT for REST API
Role-Based Access Control — Admin, Manager, User roles with granular permissions
Policy-Based Authorization — Declarative policies for fine-grained feature access
Audit Trail — Every create/update/delete logged with user ID and timestamp
SignalR Protection — Blazor Server connections secured with [Authorize]
Server-Side Code — Source code and DB credentials never leave the server

+ + +

Integration

REST API & Integration

Blazor WMS exposes a complete REST Web API for all entities — ready for mobile apps, third-party integrations, and external systems.

API Endpoints

Every feature exposes REST endpoints via ASP.NET Core Minimal APIs. All endpoints are JWT-protected and return proper HTTP status codes.

GET/api/contacts— List contacts with pagination, search, sort

GET/api/contacts/{id}— Get contact by ID

POST/api/contacts— Create new contact

PUT/api/contacts/{id}— Update contact

DELETE/api/contacts/{id}— Delete contact

Same pattern applies to all entities: Companies, Deals, Leads, Activities, and Dashboard aggregations.

API Features

Swagger/OpenAPI Docs — Interactive API documentation at /swagger
JWT Authentication — All endpoints require Bearer token
Request/Response DTOs — Clean separation from domain models
FluentValidation — Input validation on all endpoints
Pagination & Filtering — Built-in query parameters for list endpoints
Mobile-Ready — Use the API to build mobile apps or integrate with external systems

+ + +

Database & Deployment

EF Core migrations, seed data, and flexible deployment options — ready to run in under 60 seconds.

Database

SQL Server — Fully tested with EF Core migrations and seed data included
PostgreSQL — Scaffolded in codebase (provider + connection string config ready, not fully tested)
EF Core Migrations — Code-first approach with full migration history
Seed Data — Demo users (admin, manager, user), sample business records
Compiled Queries — Performance-optimized EF Core queries

Deployment Options

Azure App Service — Deploy directly from Visual Studio or GitHub Actions
IIS (Windows Server) — Standard ASP.NET Core publish to IIS
Docker — Containerize and deploy anywhere Docker runs
Windows / Linux / macOS — .NET 10 runs everywhere
Single Project — No distributed complexity. One publish, one deploy
Setup Time: Clone repo → set connection string → F5 → running in under 60 seconds

+ + +

Application Screenshots

Explore the Blazor WMS interface — dashboards, data management, workflow management, and more.

+ + +

Try the Live Demo

Test every feature before you buy. No registration required.

URL: https://blazor-wms.csharpasp.net/

Email: admin@root.com

Password: 123456

+ + +

Get Blazor WMS Source Code

Complete, unrestricted C# source code. Single .NET 10 project. Clone, F5, run.

$21 $49

+ Instant Download +

+ Buy Now — $21 via Lemon Squeezy +

Secure checkout via Lemon Squeezy. Lifetime access. No subscription.

+ + +

FAQ

Frequently Asked Questions

+ +

You get the complete, unrestricted C# source code of the entire Blazor WMS application. A single .NET 10 project with all features, Vertical Slice Architecture implementation, EF Core migrations, seed data, and full configuration. Clone, set your connection string, press F5, and it runs immediately. Includes Blazor Server UI, REST API, authentication, authorization, audit trail, and all CRM features.

+ +

Blazor WMS uses Vertical Slice Architecture (VSA) with CQRS via MediatR. Each feature (Create Contact, Get Deal, etc.) lives in its own folder with endpoint, MediatR handler, FluentValidation validator, and EF Core queries. This pattern is AI-friendly, beginner-friendly, and production-proven. Read our VSA Introduction.

+ +

Due to the digital nature of source code, we have a strict no-refund policy. That's why we provide a fully functional live demo — test every feature before you buy. Full policy here.

+ + + + + + \ No newline at end of file diff --git a/robots.txt b/robots.txt new file mode 100644 index 0000000..d45e960 --- /dev/null +++ b/robots.txt @@ -0,0 +1,3 @@ +User-agent: * +Allow: / +Sitemap: https://www.indotalent.com/sitemap.xml \ No newline at end of file diff --git a/sitemap.xml b/sitemap.xml new file mode 100644 index 0000000..948d2b8 --- /dev/null +++ b/sitemap.xml @@ -0,0 +1,31 @@ + + + https://www.indotalent.com/weekly1.0 + https://www.indotalent.com/products/blazor-crm.htmlmonthly0.9 + https://www.indotalent.com/products/blazor-crm-multitenant.htmlmonthly0.9 + https://www.indotalent.com/products/blazor-cms.htmlmonthly0.9 + https://www.indotalent.com/products/blazor-hrm.htmlmonthly0.9 + https://www.indotalent.com/products/blazor-hrm-multitenant.htmlmonthly0.9 + https://www.indotalent.com/products/blazor-oms.htmlmonthly0.9 + https://www.indotalent.com/products/blazor-scm.htmlmonthly0.9 + https://www.indotalent.com/products/blazor-swm.htmlmonthly0.9 + https://www.indotalent.com/products/blazor-wms.htmlmonthly0.9 + https://www.indotalent.com/for-beginners.htmlmonthly0.8 + https://www.indotalent.com/for-freelancers.htmlmonthly0.8 + https://www.indotalent.com/blog.htmlweekly0.8 + https://www.indotalent.com/blog/vsa-ai-assisted-development.htmlmonthly0.7`r`n + https://www.indotalent.com/blog/vsa-introduction.htmlmonthly0.7 + https://www.indotalent.com/blog/blazor-hosting-model.htmlmonthly0.7 + https://www.indotalent.com/blog/vsa-eliminates-project-hell.htmlmonthly0.7 + https://www.indotalent.com/blog/vsa-mediatr.htmlmonthly0.7 + https://www.indotalent.com/blog/mudblazor-component-library.htmlmonthly0.7 + https://www.indotalent.com/blog/blazor-performance-optimization.htmlmonthly0.7 + https://www.indotalent.com/blog/clean-architecture-to-vsa-migration.htmlmonthly0.7 + https://www.indotalent.com/blog/blazor-server-security-jwt.htmlmonthly0.7 + https://www.indotalent.com/blog/vsa-vs-layered-architecture.htmlmonthly0.7 + https://www.indotalent.com/blog/real-world-vsa-net10.htmlmonthly0.7 + https://www.indotalent.com/support.htmlmonthly0.6 + https://www.indotalent.com/privacy-policy.htmlyearly0.3 + https://www.indotalent.com/no-refund-policy.htmlyearly0.3 + https://www.indotalent.com/license.htmlyearly0.4 + diff --git a/sitemap_new.xml b/sitemap_new.xml new file mode 100644 index 0000000..e69de29 diff --git a/support.html b/support.html new file mode 100644 index 0000000..3ef2e38 --- /dev/null +++ b/support.html @@ -0,0 +1,19 @@ + + + + + + + + Support | Indotalent + + + + + + + + + + +

Support

Get In Touch

Have a question, need help, or want to discuss a project? We're here for you.

Email Us Directly

Send us an email and we'll respond within 48 hours.

hi@indotalent.com

Live Demo

Try our products before you buy. Explore the live demo.

Try Demo

Send Us a Message

Your Name

Your Email

Subject

Message

This form opens your default email client

Since this is a static HTML page, clicking submit will open your email app. You can also reach us directly at hi@indotalent.com.

Send via Email

\ No newline at end of file