From Zero to Production: Building Cross-Platform .NET Apps in Minutes

Introduction

How long does it take to set up a new .NET project? If you're being honest, probably 2-3 days:

• Day 1: Create solution, add projects, configure dependencies
• Day 2: Set up authentication, database, API structure
• Day 3: Configure build pipeline, add UI framework, write first feature

What if I told you that you could have a production-ready, cross-platform application running in under 5 minutes? Not a "Hello World" demo, but a real application with:

• ✅ Blazor Web (Server + WebAssembly)
• ✅ MAUI Hybrid Mobile App
• ✅ RESTful API with OpenAPI docs
• ✅ Entity Framework with migrations
• ✅ Authentication & Authorization
• ✅ Modern UI framework
• ✅ Complete CRUD features
• ✅ Offline support

This isn't science fiction. This is VanillaStudio.

The Problem: Project Setup is a Time Sink

Let's be real. Starting a new .NET project is tedious:

Manual Approach (2-3 days):

# Day 1 Morning: Create solution structure
dotnet new sln -n MyApp
dotnet new webapi -n MyApp.API
dotnet new blazor -n MyApp.Web
dotnet new maui -n MyApp.Mobile
dotnet new classlib -n MyApp.Core
dotnet new classlib -n MyApp.Data

# Day 1 Afternoon: Configure references
dotnet add MyApp.API reference MyApp.Core
dotnet add MyApp.API reference MyApp.Data
dotnet add MyApp.Web reference MyApp.Core
# ... 20 more reference commands

# Day 2 Morning: Add NuGet packages
dotnet add MyApp.API package Microsoft.EntityFrameworkCore.SqlServer
dotnet add MyApp.API package Microsoft.AspNetCore.Identity.EntityFrameworkCore
dotnet add MyApp.API package Swashbuckle.AspNetCore
# ... 30 more package installations

# Day 2 Afternoon: Configure Identity
# ... Copy-paste code from documentation
# ... Fix compilation errors
# ... Configure JWT tokens

# Day 3: Configure UI framework
# ... Add Bootstrap/Fluent/MudBlazor
# ... Set up layouts
# ... Create first components
# ... Wire up routing

Then you realize: "Wait, I haven't written a single line of business logic yet."

The Solution: VanillaStudio

VanillaStudio is a project generator that creates enterprise-ready .NET applications in seconds. But it's not just another template—it's a complete development platform.

The 5-Minute Workflow:

Minute 1: Configure Your Project

Visit VanillaStudio and configure:

Project Name: AwesomeApp
Root Namespace: AwesomeApp
Platform: ✅ Web + MAUI Hybrid
UI Framework: Bootstrap 5 / Fluent UI / Tailwind
Database: SQL Server / PostgreSQL / SQLite
Authentication: ✅ Yes (Identity + JWT)
Sample Features: ✅ Product Management
Aspire Support: ✅ Yes

Minute 2: Generate & Download

Click "Generate Project" → Download ZIP (8-12 MB)

Minute 3-4: Extract & Restore

unzip AwesomeApp.zip
cd AwesomeApp
dotnet restore

Minute 5: Run

# Update database
dotnet ef database update -p src/AwesomeApp.Server.Data

# Run web app
dotnet run --project src/AwesomeApp.WebPortal

Result: Open https://localhost:5001 and see:

• ✅ Working web application
• ✅ Login/Register pages
• ✅ Product listing with pagination
• ✅ Product form with validation
• ✅ API documentation at /swagger
• ✅ Database created and seeded

What's Generated: A Deep Dive

Project Structure

AwesomeApp/
├── src/
│   ├── AwesomeApp.WebPortal/              # Blazor Server/WASM hybrid
│   ├── AwesomeApp.WebPortal.Client/       # Blazor WebAssembly project
│   ├── AwesomeApp.HybridApp/              # MAUI Hybrid (iOS, Android, Windows, macOS)
│   ├── AwesomeApp.WebAPI/                 # RESTful API services
│   ├── AwesomeApp.Server.Data/            # Entity Framework Core context
│   ├── AwesomeApp.Server.DataServices/    # Business logic & controllers
│   ├── AwesomeApp.ServiceContracts/       # Shared interfaces & models
│   ├── AwesomeApp.ClientShared/           # Client-side services
│   ├── AwesomeApp.Framework/              # Core framework & base classes
│   └── AwesomeApp.SliceFactory/           # Feature generator tool
├── AwesomeApp.AppHost/                    # .NET Aspire orchestration
├── AwesomeApp.ServiceDefaults/            # Shared configurations
└── AwesomeApp.sln                         # Solution file

Authentication & Authorization

Pre-configured Identity with JWT—already set up in Program.cs:

Includes:

• Login/Register pages (Razor components)
• JWT token management
• Refresh token support
• Role-based authorization
• Claims-based access control

Database & Entity Framework

Pre-configured DbContext with migrations and seed data.

Database Support:

• SQL Server (production-ready)
• PostgreSQL (coming soon)
• SQLite (development & testing)

Includes:

• Initial migration created
• Seed data configured
• Direct LINQ queries in services (no repository abstraction)
• Clean separation between data access and business logic

The Secret Weapon: SliceFactory

Here's where VanillaStudio becomes a force multiplier. Every generated project includes SliceFactory—a command-line tool that generates new features.

Usage:

cd AwesomeApp
dotnet run --project src/AwesomeApp.SliceFactory

VanillaSlice Feature Generator
==============================

Feature name: CustomerOrder
Feature type:
  1. Listing
  2. Form
  3. Both

Select option: 3

Namespace (e.g., Sales.Orders): Sales

Generating feature slice...

✅ Created: ServiceContracts/Features/Sales/ICustomerOrderListingDataService.cs
✅ Created: ServiceContracts/Features/Sales/ICustomerOrderFormDataService.cs
✅ Created: ServiceContracts/Features/Sales/CustomerOrderListingBusinessModel.cs
✅ Created: ServiceContracts/Features/Sales/CustomerOrderFormBusinessModel.cs
✅ Created: Server.DataServices/Features/Sales/CustomerOrderListingServerDataService.cs
✅ Created: Server.DataServices/Features/Sales/CustomerOrderFormServerDataService.cs
✅ Created: Server.DataServices/Controllers/Sales/CustomerOrderListingController.cs
✅ Created: Server.DataServices/Controllers/Sales/CustomerOrderFormController.cs
✅ Created: ClientShared/Features/Sales/CustomerOrderListingClientDataService.cs
✅ Created: ClientShared/Features/Sales/CustomerOrderFormClientDataService.cs
✅ Created: WebPortal.Client/Pages/Sales/CustomerOrderListing.razor
✅ Created: WebPortal.Client/Pages/Sales/CustomerOrderForm.razor
✅ Created: HybridApp/Pages/Sales/CustomerOrderListing.razor
✅ Created: HybridApp/Pages/Sales/CustomerOrderForm.razor
✅ Updated: DI registrations in Program.cs
✅ Updated: Navigation menu

Feature generated successfully!

What SliceFactory generates:

1. Service Contracts - Type-safe interfaces
2. Server Services - Stub implementations ready for business logic
3. Controllers - HTTP endpoints pre-wired
4. Client Services - HTTP clients with proper serialization
5. UI Components - Razor pages for both Web and MAUI
6. DI Registration - Automatically updates Program.cs
7. Navigation - Adds menu items

Time saved: 2-3 hours per feature reduced to 30 seconds.

Multi-Platform from Day One

The same UI components run everywhere:

Blazor Web:

// Program.cs - WebPortal
builder.Services.AddScoped<IProductListingDataService,
    ProductListingClientDataService>();

MAUI Hybrid:

// MauiProgram.cs
builder.Services.AddScoped<IProductListingDataService,
    ProductListingClientDataService>();

The Razor component is identical—shared between both platforms!

Result: Build once, deploy everywhere.

Real-World Use Cases

Use Case 1: SaaS Startup

Requirement: Build MVP with web dashboard and mobile app in 2 weeks.

Before VanillaStudio:

• Week 1: Project setup, authentication, database
• Week 2: First feature (barely)
• Result: Only web app, no mobile

After VanillaStudio:

• Day 1: Generate project, customize branding
• Days 2-10: Build business features using SliceFactory
• Days 11-14: Polish UI, deploy
• Result: Web + Mobile app delivered

"We delivered our MVP in 10 days instead of 6 weeks. Investors were impressed that we had both web and mobile from day one."

Use Case 2: Enterprise Internal Tool

Requirement: Field service management app for 500 technicians.

Challenge:

• Technicians need mobile app with offline support
• Managers need web dashboard
• 6-week deadline

Solution with VanillaStudio:

• Week 1: Generate project, integrate with existing SQL Server
• Week 2-4: Build features (work orders, time tracking, inventory)
• Week 5: Implement offline storage in MAUI app
• Week 6: Testing and deployment

Result: Delivered on time with both platforms.

Cost & ROI

Time Savings:

• Project setup: 2-3 days → 5 minutes (99% reduction)
• Per feature: 4-6 hours → 30 minutes (90% reduction)
• Authentication setup: 1 day → 0 minutes (included)
• Multi-platform setup: 1 week → 0 minutes (included)

For a typical project (20 features):

• Traditional: 3 days setup + 20 features × 5 hours = 103 hours
• VanillaStudio: 5 mins + 20 features × 30 mins = 10 hours

Savings: 93 hours per project

At $100/hour developer cost: $9,300 saved per project

Getting Started

Step 1: Generate Your Project

🌐 Visit VanillaStudio

Step 2: Extract & Run

unzip YourProject.zip
cd YourProject
dotnet restore
dotnet ef database update -p src/YourProject.Server.Data
dotnet run --project src/YourProject.WebPortal

Step 3: Start Building Features

dotnet run --project src/YourProject.SliceFactory

Step 4: Deploy

• Web: Azure App Service, AWS, or any ASP.NET Core host
• Mobile: App Store & Google Play (MAUI build)
• Database: Azure SQL, AWS RDS, on-premises

Conclusion

Modern software development shouldn't start with 3 days of project setup. With VanillaStudio:

• ✅ 5 minutes to production-ready app
• ✅ 30 seconds to add new features
• ✅ One codebase for web and mobile
• ✅ SOLID principles enforced by design
• ✅ Zero lock-in - standard .NET code

Stop wasting time on boilerplate. Start building features.