Questions every CTO asks.

Every CleenUI license is sized to your team — developer count, environments, white-label / OEM needs, and engagement scope. A flat list price would either undercharge a 20-person team or scare off a 3-person startup. The price is set on the architecture review call, after the architect understands what you actually need. It's typically a one-time fee; there's no ongoing subscription required to keep running or modifying the codebase.

One-time license. Once you have the source code, it's yours — no renewal required to keep your application running, no per-seat tax as the team grows, no subscription cliff that holds your deployment hostage. The license covers perpetual use of the code as delivered. Updates and ongoing architectural advice are available under separate engagement terms.

Full source code across all four tiers: React 18 frontend (61 accessible components), ASP.NET Core 8 Web API (524 documented endpoints), Azure SQL schema (300+ tables, 700+ stored procedures), and the 12-project background services solution (Azure Functions + WebJobs). All 14 production modules (M01–M14) are included. Also included: CLAUDE.md + AI agent skills (Setup, Builder, Theme), OpenAPI 3 spec for all endpoints, Storybook component documentation, and initial architect onboarding.

Yes. CleenUI is a licensed codebase — you modify it, build on it, and ship it as your own product to your own customers. You own the product you build. The license does not require you to disclose CleenUI as the foundation. Per-customer white-label / OEM usage is covered in the engagement scoping; that's one of the variables that affects pricing.

No. CleenUI is source code, not a hosted SaaS. Your application runs on your infrastructure. There is no license key, no license server, no expiry check in the code. If the engagement ends, your application keeps running as-is. What expires is access to updates and priority architectural support — the codebase you have continues to work.

The codebase is delivered as a unit — frontend, API, database, services, and all 14 modules together. The modules share infrastructure (auth, RBAC, observability, translation registry, notification engine) that would be incomplete if modules were stripped individually. In practice, most teams use 6–10 of the 14 modules immediately and grow into the others; unused modules don't add runtime cost or complexity.

Two reasons: predictability and auditability. Stored procedures give data teams explicit query control — a DBA can read every query, inspect the execution plan, and tune it without touching application code. Entity Framework\'s LINQ-to-SQL translation is opaque: the generated SQL is often correct, occasionally disastrous, and always one abstraction layer away from what the database actually sees. CleenUI is used by teams in regulated industries where every query path needs to be auditable. Dapper + ADO.NET + named stored procedures is the pattern Fortune 500 data teams require. There is no EF in CleenUI and none will be added. If EF is a hard requirement, Jason Taylor\'s Clean Architecture Template or ASP.NET Zero are better fits.

The background services layer (Azure Functions + WebJobs) is Azure-native by design. The database is Azure SQL. The API can deploy to Azure App Service, Azure Container Apps, or any .NET-compatible host. Teams on AWS or GCP typically run the API and database on their preferred cloud and use Azure Functions specifically for the background services tier, or re-host those workers on their own async infrastructure. The architect covers deployment topology on the call.

Things you provide: Auth0 tenant (M01 uses Auth0 for identity), Azure subscription (for SQL + Functions), Stripe account (M14), third-party API keys (OpenAI, Anthropic, Google AI for M09). Things not in the box: a pre-built mobile app (the React frontend is web-only; mobile is a separate engagement), end-to-end test suite (Playwright configuration is present but test cases are yours to write), and any domain-specific business logic specific to your product category. CleenUI ships the generic SaaS foundation; the differentiated product logic is yours to add on top.

CleenUI's data layer is Azure SQL with 700+ named stored procedures. The schema is tightly coupled to the stored procedures and the API endpoints — they form a single coherent unit. Connecting it to an existing database is not a config change; it requires mapping your schema to the CleenUI model or running a migration. The architecture review is the right place to evaluate whether a hybrid approach or a clean-slate deployment fits your situation.

The architect listens to your stack, your team shape (size, experience level, existing infrastructure), your timeline, and your top three modernization or build problems. From that, he tells you (a) whether CleenUI fits or doesn't, and (b) if it does, which modules you'll use day one, how the engagement would be scoped, and what the rough timeline looks like. If CleenUI isn't the right fit, you still get 30 minutes of senior architectural guidance on your problem. No SDR, no sales engineering hand-off.

For serious evaluations, the architect provides a sandbox repository under NDA so engineering leadership can inspect the code directly before committing. This isn't a self-serve download; it's a scoped evaluation step after the architecture review, when both sides are confident the fit is real. The 30-minute call is the evaluation entry point — it's no-cost and no-commitment.

The architect-led onboarding covers environment provisioning, CI/CD configuration, Auth0 tenant setup, initial branding pass, and a walkthrough of the module architecture. Most teams are running the application locally within the first day and have a staging environment deployed within the first week. The timeline for the first meaningful feature — built on top of the existing modules — is typically days, not months.

AI coding tools are excellent at writing code inside an existing architecture. They\'re slow at designing it. 300+ normalized database tables, 524 endpoint contracts, auth guards, RBAC row filters, SignalR hub plumbing, background job infrastructure — an AI agent can help extend those once they exist, but won\'t arrive at the same design without months of iteration and significant rework. CleenUI ships the architecture that AI tools extend well; they don\'t replace it. The vibe-coding paradox →

You own the source code. If the architect stops adding new features tomorrow, your application still runs, your team can still modify any file, and the codebase continues to be yours. There is no runtime dependency on CleenUI infrastructure, no hosted service to go down, no license key to expire. The risk profile is identical to any in-house codebase your team owns outright.

Ongoing support is scoped per engagement. The architecture review call sets the engagement shape — some teams want a single delivery handoff; others want recurring architectural office hours. There is no single default support tier; it's sized to your team's needs. What's always available: the architect is reachable for critical blockers during onboarding, and the codebase ships with enough documentation (CLAUDE.md, ADRs, Storybook, OpenAPI spec, postman collection) that a competent team can self-serve on most questions.

Updates ship as source code — either a new delivery of the codebase or a diff/patch against your version, depending on how far your fork has diverged. Unlike a framework package (where you pull the new version from npm), CleenUI updates are deliberate: the architect reviews your codebase state, applies the relevant additions, and hands them off in a way that doesn't conflict with your product changes. Update cadence and delivery are part of the engagement scope.

Not yet — CleenUI is architect-led by design, not community-moderated. The support relationship is direct with the architect rather than a forum. If you're evaluating based on community size, tools like Supastarter or Makerkit have active Discord communities and are the right comparison. CleenUI trades community breadth for architectural depth and direct access to the person who built it.