Most modern AI app builders output disposable client-side JavaScript (Vite/React) with mocked SQLite in-memory databases and ephemeral runtimes. They look flashy in 30-second demos, but crumble when you need real relational persistence, transactional email, tenant data isolation, or custom business rules.

Core Architectural Capabilities

How Development Works in 3 Steps

1. Prompt the Assistant: Express your software concept in plain English (e.g. "Build an asset tracker with Barcodes, Locations, Maintenance Schedules, and low-inventory email alerts").
2. Review the Code Diff: The AI proposes changes as declarative schema updates. You review new entities, relations, business rules, and permissions in real-time.
3. Deploy Instantly: Click Publish to compile the C# solution, run database migrations, and deploy to a dedicated Docker container behind automated reverse proxy routing.

/// <summary>
/// Tracks capital equipment, hardware assets, and warranty expirations.
/// </summary>
public class AssetItem
{
    public Guid Id { get; set; }

    /// <summary>
    /// Equipment identifier or internal asset serial number.
    /// </summary>
    public string AssetTag { get; set; } = string.Empty;

    /// <summary>
    /// Asset purchase acquisition date in universal UTC.
    /// </summary>
    public DateTime PurchaseDate { get; set; }

    public decimal ReplacementCost { get; set; }

    // Multi-tenant isolation filter
    public string TenantId { get; set; } = string.Empty;
}

Step 1: Create a Project Workspace

From your ProjectHelm dashboard, click New Project. Choose your starting App Type:

• Website: Public content pages, catalogues, blogs (no user authentication required).
• Business App: Single-company portal where staff log in to manage workflows, records, and approvals.
• SaaS: Multi-tenant subscription platform where customer companies sign up, invite team members, and have completely isolated databases.

Step 2: Describe Your Data & Rules

In the prompt input, describe your application domain. For example:

"I need a Fleet & Vehicle Maintenance Tracker.
- Vehicle: LicensePlate, Make, Model, Year, Mileage, Status (Active, InShop, Retired).
- MaintenanceRecord: ServiceDate, ServiceType, Cost, TechnicianNotes, BelongsTo Vehicle.
- When Status becomes 'InShop', send a notification email to the Fleet Manager.
- Auto-generate an invoice PDF for completed service work."

Step 3: Inspect Diff & Interactive Preview

The AI generates the declarative schema and displays the proposal as a diff. Click Preview to test-drive the interactive prototype: search tables, fill out sample forms with real validation, and inspect layout without waiting for a cloud build.

Step 4: One-Click Deploy

When satisfied with the architecture, click Publish. ProjectHelm compiles the C# codebase, applies EF Core database migrations, creates an optimized Docker container, and launches it behind an automated SSL reverse proxy at https://your-app.projecthelm.in.

Think in Entities & Relations

ProjectHelm is not an unstructured LLM script writer; it is a declarative schema compiler. You get the best results when you describe your problem in terms of real-world concepts:

Specifying Business Rules & Locks

You can specify data integrity rules directly in your request:

• Validation Rules: "Ensure EndDate is always after StartDate" or "DiscountPercent cannot exceed 25%".
• Role-Based Locks: "Only users with the 'Manager' role can edit the UnitPrice field".
• State Locks: "Once an Invoice stage becomes 'Paid', lock the entire record against edits".

Every application built by ProjectHelm is a self-contained, enterprise ASP.NET Core solution. There is no central orchestrator or hidden proxy; the emitted container runs directly on Kestrel behind your reverse proxy.

The ASP.NET Core Request Pipeline

Background Workers & Automations

Applications with scheduled or interval automations run background hosted services (IHostedService). A cron worker checks every minute for scheduled tasks (daily morning sweeps, interval jobs every N minutes, and email retry queues) without requiring external Lambda functions or cron daemons.

ProjectHelm outputs standard ASP.NET Core MVC solution structures. Once you download the codebase or push to Git, there is zero dependency on ProjectHelm.

Solution Structure (.slnx)

YourApp.slnx
├── src/
│   ├── YourApp.Core.Models/       # POCO entities, DTOs, Enums, Custom Permissions
│   │   ├── Entities/
│   │   ├── Dto/
│   │   └── Enums/
│   ├── YourApp.Core.Data/         # EF Core AppDbContext, Database Migrations
│   │   ├── AppDbContext.cs
│   │   └── Migrations/
│   └── YourApp.UI.Web/            # ASP.NET Core MVC Controllers, Razor Views, Auth
│       ├── Controllers/
│       ├── Views/
│       ├── Services/
│       └── Program.cs
└── docker/
    └── Dockerfile                 # Multi-stage optimized Alpine container

Engineering Guarantees

• No Runtime Lock-In: Open in Visual Studio 2026, Rider, or VS Code with dotnet build.
• Strict Entity Separation: Clear separation between domain models and DTOs to prevent over-posting vulnerabilities.
• Enterprise Security: Anti-forgery tokens (CSRF) on all POST actions, encrypted cookies, role policy attributes, and SQL injection prevention via EF Core parameterization.

ProjectHelm is database-agnostic. You can build your prototype on SQLite in the hosted cloud container, and export your production code targeting PostgreSQL, SQL Server, MySQL, or Oracle.

Universal UTC Normalization

A notorious issue in relational databases is timezone drift when saving DateTime values. ProjectHelm generates universal UtcDateTimeValueConverter configurations in EF Core, guaranteeing that all moments are stored in UTC and converted dynamically to the application's configured timezone at presentation.

ProjectHelm incorporates a unified Description property across 10 schema components: Domain Groups, Entities, Properties, Relations, Business Rules, Workflow Stages, Transitions, Enums, Enum Values, and Custom Permissions.

Triple-Duty Documentation Architecture

Exporting Full Source (.slnx)

ProjectHelm adheres strictly to the philosophy that the developer owns the source code. From the project header:

• Click Export > Download Solution to get a complete ZIP with the solution file (.slnx), project files, POCO models, EF Core database context, migrations, MVC controllers, and Razor views.
• Double click the .slnx file to immediately open in Visual Studio 2026 or JetBrains Rider. Run dotnet run to launch the web server.

Direct Git Synchronization

Configure your remote Git repository URL (e.g. https://github.com/your-org/your-app.git). Each time you approve a diff, ProjectHelm can commit and push the updated C# source directly to your repository with clear, descriptive commit messages.

Standard Scalar & Semantic Types

ProjectHelm supports rich declarative property formats that automatically enforce database data types, client-side HTML validation, and table formatting:

• Text: Single-line strings or multi-line textareas (isMultiline: true) with regex validation and custom error messages.
• Numbers: Integer, Long, Decimal, and Double with configurable decimalPlaces and display prefix (e.g. currency signs).
• Semantic Types: Date (date picker, zero timezone drift), Email, Phone, Url, Money (2 decimals with thousands separators), and Percent.
• Color Swatches: Stored as standard #RRGGBB hex tokens and rendered with interactive HTML5 color picker dialogs.
• Secret Credentials: Stored encrypted with zero readback in UI, ideal for API keys and webhooks.
• Files & Images: Single or multiple attachments with configurable size limits (maxFileSizeKb) and aspect ratio cropping.

BelongsTo Relationships

A record points to another record (e.g. Order belongs to Customer). Supported dropdown modes:

• ServerSearch: High-performance async typeahead for tables with thousands or millions of rows.
• Static: Standard HTML select dropdown for small sets (e.g. Departments, Statuses).
• StaticSearchable: Searchable in-memory dropdown with instant text filtering.

HasMany Child Tables & Tabs

Parent entities display their child records either as dedicated tabs, inline overview tables, or interactive dual-pane list views. With allowInlineCreate: true, users can add child line items directly from the parent view.

Cascading Dropdowns

Easily link related dropdowns: selecting a Country automatically restricts the State dropdown to matching records via cascadeFromRelationName.

Three Types of Business Rules

Expression Language Guide

Expressions support arithmetic (+ - * /), comparisons (== != > < >= <=), boolean logic (&& ||), Today, Now, date math (DueDate + 14), and role tests (CurrentUser.HasRole("Manager")).

Stages & State Badges

Give any entity a state machine lifecycle (e.g. Draft → UnderReview → Approved → Archived). Each stage carries an optional badge color and display label.

Transition Action Buttons

Buttons appear conditionally on records when they reside in the matching fromStageName. Transitions support:

• Permission Guards: Restrict button visibility to users holding a specific role or permission (requiredPermission).
• Condition Expressions: Ensure mandatory fields are populated before advancing stages.
• Required Comments: Prompts the user for an approval or rejection reason.
• Automated Notifications: Dispatches emails to specific roles or triggers external webhooks.

Declarative Sequence Formatting

Configure custom auto-incrementing templates like {Tenant.Name}/{Facility.Code}/INV/{Auto:4digit}.

Dynamic Step Sequences

Attach repeatable onboarding checklists, maintenance steps, or study milestones to any entity. Each step specifies an offsetDays from an anchor date (e.g. -7 for one week before an event, 0 on the day, 1 for next-day review).

Interactive Month Calendar Plan

Enabling isCalendarEvent: true on an entity produces an interactive full-month calendar view with color-coded category labels, date filtering, and quick-add modals.

Real-Time Aggregates

Define metrics that compute live values directly from EF Core queries: Count, Sum, Average, Min, and Max. Filter by date window (Today, Last 7 Days, This Month, All Time) or stage (e.g. Stage == 'Completed').

Cross-Entity Formulas

Combine multiple metrics with arithmetic formulas:

// Net Cash Flow across Orders and Expenses
TotalRevenue - TotalOperatingExpenses

// Savings Rate Percentage
((TotalIncome - TotalExpenses) / TotalIncome) * 100

ProjectHelm connectors eliminate manual API glue code. When you enable a connector, required database entities and fields are generated and locked automatically to ensure stable, runtime-safe execution.

Static vs. Dynamic Binding Modes

Single Sign-On (OAuth 2.0)

Enabling the microsoft-auth connector configures OpenID Connect authentication against Microsoft Entra ID. Users can register and sign in using their corporate Microsoft 365 accounts.

Automated Microsoft Graph Writeback

Automations can execute automated tasks against Microsoft 365:

• CreateUser / UpdateUser: Automatically provision employee accounts in Entra ID when an HR record is created.
• AddGroupMember / RemoveGroupMember: Synchronize team memberships.
• AssignLicense / RemoveLicense: Automate Office 365 license assignment.

OAuth 2.0 Configuration

Turn on the google-signin connector in Settings > Connectors. Enter your Google Client ID and Client Secret from the Google Cloud Console. ProjectHelm handles redirect URLs, email extraction, and account linking automatically.

Unified Email Abstraction

Both Zoho Mail (custom SMTP) and SendGrid implement the same strongly-typed IEmailSender contract. You can switch between Zoho and SendGrid at any time; all existing static and dynamic email workflow bindings transfer losslessly.

Storefront Checkout

When the Storefront feature is enabled alongside Stripe or Razorpay, buyers are presented with secure payment popups (UPI, Cards, NetBanking, Wallets).

Automated Tax & Invoices

Supports automated GST tax splitting (CGST + SGST within store state, IGST interstate) and generates downloadable PDF customer invoices upon order payment.

Bot Integration

Connect your Telegram bot token. Use automations to send instant alerts whenever an urgent order is placed, a server alert fires, or a high-value lead registers.

Spam & Bot Defense

Enabling the google-recaptcha connector injects "I'm not a robot" checkbox verification into public forms, validating tokens server-side before processing requests.

The Three App Types

Custom Landing Page Upload & Dynamic Route Mapping

ProjectHelm allows uploading bespoke, custom-designed landing pages to replace the default generated homepage. Uploads are strictly validated to one HTML file (required), plus up to one CSS file and one JS file (optional).

In a SaaS application, multiple client businesses share the application infrastructure while keeping their data strictly quarantined.

Automated EF Core Query Filters

Entities marked with HasTenantFilter = true automatically receive EF Core global query filters in AppDbContext.cs:

builder.Entity<Customer>()
       .HasQueryFilter(e => !e.IsDeleted && e.TenantId == _currentTenantProvider.TenantId);

This guarantees that even if a developer writes _context.Customers.ToListAsync() without a where clause, the query can never leak records from another tenant.

Automatic CRUD Permissions

Every entity automatically gains 4 standard permissions: READ_ENTITY, CREATE_ENTITY, UPDATE_ENTITY, and DELETE_ENTITY.

Custom Permissions

Define high-level administrative permissions (e.g. EXPORT_REPORTS, APPROVE_PAYOUTS, MANAGE_BILLING). Admins can assign these permissions to specific roles using the built-in Dual List role manager.

TOTP Authenticator Apps

Users can link standard authenticator apps (Google Authenticator, Microsoft Authenticator, 1Password) by scanning a QR code. Backup emergency recovery codes are generated and hashed in the database.

Publishing in ProjectHelm is zero-configuration:

1. Source Packaging: The complete C# solution is compiled on the host Docker daemon.
2. Database Migration: Pending EF Core migrations are executed safely.
3. Blue/Green Swap: A candidate container spins up and performs HTTP health checks. Once healthy, traffic shifts with zero downtime.
4. Storage Caps: 50 MB baseline container storage included with proactive pre-write upload protection.

50 MB Baseline Included

Every hosted project includes 50 MB of dedicated container disk storage. To prevent containers from crashing due to disk exhaustion, ProjectHelm enforces proactive upload guards: incoming file uploads are checked against remaining capacity and rejected before bytes reach disk.

Expanding Storage

Expand storage seamlessly in 50 MB increments at standard daily credit rates directly from project settings.

Cloud File Storage Connectors (Quota Bypass)

When you attach an Azure Storage account, Amazon S3, Google Cloud Storage, or Cloudflare R2 connector to your project, all entity uploads, multi-file collections, calendar attachments, and storefront product images stream directly to your external cloud bucket.

Because files are persisted in your own cloud account rather than on the local container volume, file uploads completely bypass the 50 MB container disk quota, unlocking practically unlimited storage capacity with zero container disk consumption.

CNAME Configuration

Add a CNAME record in your DNS provider (Cloudflare, GoDaddy, Route53) pointing to cname.projecthelm.in. Enter your domain name in Project Settings > Custom Domain. ProjectHelm automatically obtains and renews SSL/TLS certificates.

How Metering Works

• AI Prompts & Edits: Metered on actual reasoning tokens consumed. Everyday changes cost a handful of credits.
• Container Hosting: Metered daily while your app is online (approx. ₹120/month with 50 MB container storage). Sleep or delete apps to stop the meter immediately.
• Source Code Export: Free forever. Export your solution or push to Git with zero credit charge.