Skip to content

Generated SaaS Product Platform Overview

Target Architecture — Final-State Design

This page describes the final-state target architecture of a Generated SaaS Product — the platform the factory produces. The templates and reusable libraries that compose every generated product exist in the codebase today and are marked separately; the specific runtime services, workers, APIs, and portals described here are the designed end state that the factory assembles per product. A concrete generated product will contain a superset of this common platform-level baseline plus its own domain.

The Generated SaaS Product Platform is the output of the ConnectSoft AI Software Factory. Where the eleven factory platforms (Factory Studio, Control Plane, Agent Mesh, Knowledge, Template Library, Marketplace, DevOps & GitOps, Runtime & Cloud, Observability & Feedback, Governance & Security & Compliance, and Integration) design, build, validate, ship, and operate software, this platform is the software they ship: a complete, independently running, multi-tenant SaaS product.

A generated product is not a demo or a scaffold. It is a production-grade system — API gateway, identity and authorization servers, tenant management, backend microservices, workers, integration and notification services, admin and customer portals, audit, reporting, migrations, CI/CD pipelines, infrastructure-as-code, and an observability surface — every piece of which is generated from a real ConnectSoft template by a specific generating agent. The factory's value proposition is realized here: the same patterns, libraries, envelope, and naming conventions that make the factory traceable, reusable, governed, and observable are stamped into every product the factory emits.

This is the AI-native software factory platform's deliverable. It is described as a common platform-level baseline: every generated SaaS contains the cross-cutting SaaS spine (tenancy, identity, subscriptions, billing, audit, reporting, configuration) plus the bounded contexts of its own domain. The pages in this section document that common baseline as the canonical reference architecture for any generated product.

Purpose

The Generated SaaS Product Platform exists to be the proof and the payload of the factory:

  • Deliver complete running SaaS. Produce a deployable, operable, multi-tenant product — not code fragments — with every architectural concern (auth, persistence, messaging, UI, observability, IaC) already wired.
  • Inherit the factory's quality bar by construction. Because each component is generated from a hardened template, the product inherits Clean Architecture layering, the canonical event envelope, naming conventions, tenant isolation, and observability without bespoke effort.
  • Stay traceable to its origin. Every generated module carries lineage back to the blueprint, agent task, template version, and commit that produced it, so a running SaaS can be traced to the intent that created it.
  • Be reusable and regenerable. A product is a composition of versioned templates; upgrading a template and re-running the generating agent evolves the product without hand-porting.
  • Operate autonomously after generation. Once shipped, the product runs on its own runtime, emits its own events and telemetry, and feeds signals back to the factory's Observability & Feedback platform to close the loop.

Role in the AI Software Factory

flowchart LR
    Intent["Business Intent / Blueprint"] --> CP["Control Plane"]
    CP --> AM["Agent Mesh"]
    AM -->|"selects + binds"| TL["Template Library"]
    AM -->|"generates modules"| Product["Generated SaaS Product"]
    TL -->|"versioned templates"| Product
    DG["DevOps & GitOps"] -->|"CI/CD"| Product
    IaC["Runtime & Cloud"] -->|"provisioned infra"| Product
    Product -->|"runtime signals + events"| OBS["Observability & Feedback"]
    Product -->|"audited actions"| GOV["Governance, Security & Compliance"]
    OBS -->|"feedback"| CP
Hold "Alt" / "Option" to enable pan & zoom

The generated product is the terminal node of the factory's value chain and the source node of its feedback loop. The Agent Mesh, drawing context from the Knowledge Platform and templates from the Template Library, generates each module; DevOps & GitOps builds and ships it; Runtime & Cloud provisions its infrastructure via Pulumi; and once live, the product streams its own events and telemetry back into Observability & Feedback, which informs the next iteration through the Control Plane.

Core Responsibilities

Responsibility Description
Serve the product Run the SaaS: handle API traffic at the gateway, execute domain logic in microservices, render the admin and customer portals.
Enforce tenancy Isolate every tenant's data and traffic across all services, stores, and UI surfaces via a tenantId discriminator.
Manage identity & access Authenticate users (OpenIddict) and enforce RBAC/ABAC across the product.
Run the SaaS commercial spine Manage tenants, subscriptions, editions, entitlements, feature flags, metering, and billing.
Process asynchronously Execute workers for notifications, reporting, integration sync, audit export, and the transactional outbox.
Integrate externally Connect to third-party systems through generated integration services and webhook subscriptions.
Record audit & produce reports Capture an immutable audit trail and generate tenant-scoped reports and analytics.
Emit events & telemetry Publish domain/integration events in the canonical envelope and export logs, metrics, and traces.
Be operable Ship with health checks, CI/CD pipelines, Pulumi IaC, and observability dashboards.

Key Capabilities

  • Generated from real templates — every component is a stamped, versioned instance of a ConnectSoft template, so products are consistent and regenerable.
  • Multi-tenant by construction — tenantId is an isolation boundary on every request, query, message, cache key, and UI surface, backed by ConnectSoft.Extensions.Saas.* libraries.
  • Event-driven core — services communicate through MassTransit on Azure Service Bus using the canonical envelope, with a transactional outbox for reliable publication.
  • Complete commercial spine — tenants, subscriptions, editions, entitlements, metering, and billing are first-class, generated from ConnectSoft.Saas.*Template.
  • Composable Blazor experiences — admin and customer portals are microfrontend compositions over the shell template, plus an optional MAUI mobile client.
  • Operable on day one — health aggregation, dashboards, Pulumi IaC, and GitOps pipelines are generated alongside the product.
  • Fully traceable — lineage from blueprint → template version → generated module → commit → deployment → runtime signal is preserved end to end.

High-Level Component Diagram — The Generated Runtime Architecture

flowchart TB
    subgraph Clients["Client Tier"]
        Admin["Admin Portal<br/>Blazor MFE"]
        Customer["Customer Portal<br/>Blazor MFE"]
        Mobile["Mobile App<br/>MAUI"]
        ExternalApi["External API Consumers"]
    end

    subgraph Edge["Edge"]
        Gateway["API Gateway"]
    end

    subgraph Identity["Identity Plane"]
        AuthServer["Authorization Server<br/>OpenIddict"]
        IdentitySvc["Identity Service"]
    end

    subgraph SaasSpine["SaaS Spine"]
        TenantSvc["Tenant Management"]
        SubSvc["Subscription & Billing"]
        FeatureSvc["Feature Flags & Config"]
    end

    subgraph Domain["Domain Services"]
        DomainA["Domain Microservice A"]
        DomainB["Domain Microservice B"]
    end

    subgraph Supporting["Supporting Services"]
        NotificationSvc["Notification Service"]
        IntegrationSvc["Integration Service"]
        ReportingSvc["Reporting & Analytics"]
        AuditSvc["Audit Trail"]
    end

    subgraph Async["Async Processing"]
        Workers["Workers / Event Consumers"]
        Bus["Azure Service Bus<br/>MassTransit"]
    end

    subgraph Data["Data Tier"]
        SQL[("Azure SQL / PostgreSQL")]
        Blob[("Blob Storage")]
        Redis[("Redis Cache")]
        Vault[("Key Vault")]
    end

    Admin --> Gateway
    Customer --> Gateway
    Mobile --> Gateway
    ExternalApi --> Gateway

    Gateway --> AuthServer
    Gateway --> IdentitySvc
    Gateway --> TenantSvc
    Gateway --> SubSvc
    Gateway --> FeatureSvc
    Gateway --> DomainA
    Gateway --> DomainB
    Gateway --> ReportingSvc

    IdentitySvc --> SQL
    TenantSvc --> SQL
    SubSvc --> SQL
    DomainA --> SQL
    DomainB --> SQL
    AuditSvc --> SQL
    ReportingSvc --> SQL
    NotificationSvc --> Blob

    DomainA -->|"events"| Bus
    DomainB -->|"events"| Bus
    SubSvc -->|"events"| Bus
    TenantSvc -->|"events"| Bus
    Bus --> Workers
    Bus --> NotificationSvc
    Bus --> IntegrationSvc
    Bus --> AuditSvc
    Bus --> ReportingSvc

    Gateway --> Redis
    AuthServer --> Vault
    IntegrationSvc --> Vault
Hold "Alt" / "Option" to enable pan & zoom

Generated Component → Template + Agent Map

Each of the sixteen generated components maps to a real ConnectSoft template and the generating agent responsible for producing it.

# Generated Component Generating Template Generating Agent
1 API Gateway ConnectSoft.ApiGatewayTemplate API Gateway Generator Agent
2 Identity / Auth Server ConnectSoft.IdentityTemplate + ConnectSoft.AuthorizationServerTemplate Identity Generator Agent
3 Tenant Management ConnectSoft.Saas.TenantsTemplate Microservice Generator Agent
4 Admin Portal ConnectSoft.Blazor.ShellTemplate + Blazor.Mfe.* Frontend Developer Agent
5 Customer Portal ConnectSoft.Blazor.ShellTemplate + Blazor.Mfe.* Frontend Developer Agent
6 Backend Microservices ConnectSoft.MicroserviceTemplate Microservice Generator + Backend Developer Agent
7 Workers / Event Consumers ConnectSoft.WorkerTemplate Worker Generator Agent
8 Database Migrations ConnectSoft.MicroserviceTemplate (DatabaseModel.Migrations) Backend Developer Agent
9 Integration Services ConnectSoft.MicroserviceTemplate + ConnectSoft.Integration.* Integration Developer Agent
10 Notification Services ConnectSoft.WorkerTemplate + ConnectSoft.Notifications.* Worker Generator Agent
11 Audit Trail ConnectSoft.Saas.AuditTemplate Microservice Generator Agent
12 Reporting / Analytics ConnectSoft.MicroserviceTemplate + reporting libraries Backend Developer Agent
13 DevOps Pipelines ConnectSoft.DevOpsPipelineTemplate DevOps Agent
14 Infrastructure-as-Code Pulumi IaC templates (ConnectSoft.Infrastructure.*) DevOps / Platform Agent
15 Observability Dashboards Observability dashboard templates DevOps / SRE Agent
16 Documentation Site ConnectSoft.DocumentationTemplate Documentation Agent
— Tenants / Billing / Metering / Entitlements ConnectSoft.Saas.*Template Microservice Generator Agent
— Health Aggregation ConnectSoft.HealthChecksAggregatorTemplate Backend Developer Agent

Implemented

The templates and reusable libraries that compose every generated product are real assets in the codebase today:

  • Service generation — ConnectSoft.MicroserviceTemplate, ConnectSoft.WorkerTemplate.
  • Edge & identity — ConnectSoft.ApiGatewayTemplate, ConnectSoft.IdentityTemplate, ConnectSoft.AuthorizationServerTemplate (OpenIddict).
  • SaaS spine — ConnectSoft.Saas.*Template (tenants, billing, metering, entitlements) and ConnectSoft.Extensions.Saas.* libraries.
  • Experience — ConnectSoft.Blazor.ShellTemplate, ConnectSoft.Blazor.MicrofrontendLibraryTemplate, ConnectSoft.Blazor.UIKit, Blazor.Mfe.*, ConnectSoft.MauiBaseTemplate.
  • Operations — ConnectSoft.HealthChecksAggregatorTemplate, ConnectSoft.DocumentationTemplate, Pulumi IaC templates.

A generated product is the assembly of these proven templates into a single, running, multi-tenant SaaS.

Integration with Other Platforms

flowchart LR
    Product["Generated SaaS Product"] -->|"runtime signals, metrics, traces"| OBS["Observability & Feedback"]
    Product -->|"audited actions, policy checks"| GOV["Governance, Security & Compliance"]
    Product -->|"lineage + artifact references"| KP["Knowledge Platform"]
    DG["DevOps & GitOps"] -->|"build + deploy"| Product
    RC["Runtime & Cloud"] -->|"AKS / Container Apps + Pulumi"| Product
    AM["Agent Mesh"] -->|"generates + regenerates"| Product
    TL["Template Library"] -->|"versioned templates"| Product
    INT["Integration Platform"] -->|"connector patterns"| Product
Hold "Alt" / "Option" to enable pan & zoom
Platform Generated product receives Generated product provides
Agent Mesh Generation and regeneration of every module Generation telemetry and module lineage
Template Library Versioned, validated templates to compose from Usage signals informing template evolution
DevOps & GitOps CI/CD pipelines, GitOps deployment Build and deployment status events
Runtime & Cloud Provisioned AKS/Container Apps infra via Pulumi Resource utilization and scaling signals
Observability & Feedback Dashboard and alert definitions Logs, metrics, traces, runtime feedback
Governance, Security & Compliance Policies, classification, audit sink Audited actions and compliance evidence
Knowledge Platform Grounded context at generation time Lineage from running SaaS back to intent

Final-State Summary

The Generated SaaS Product Platform is the output of the ConnectSoft AI Software Factory — a complete, multi-tenant, production-grade SaaS product assembled from real, versioned templates by specific generating agents. Its common platform-level baseline comprises sixteen generated components (gateway, identity, tenancy, portals, domain microservices, workers, integration, notification, audit, reporting, migrations, pipelines, IaC, dashboards, docs) over a thirteen-aggregate SaaS spine, built on .NET 10, NHibernate on Azure SQL/PostgreSQL, MassTransit on Azure Service Bus, OpenIddict, Blazor MFE, Serilog/OpenTelemetry/Application Insights, and Pulumi IaC, deployed to AKS or Container Apps. Because every part is generated from a hardened template, each product inherits traceability, reusability, autonomy, governance, observability, and multi-tenant scale by construction — and feeds its runtime signals back into the factory to drive the next iteration.