How It Works

From a natural-language brief to a Project Analysis plan, per-module DBML, generated microservices, GitHub repositories, and Cloud Run deployments — step by step.

Get started

Describe your business requirements to AI

Start on the homepage with Try generating with AI, or open QuickCode Studio and choose Project with AI. Describe your product in natural language (optionally attach a PDF). Pick Google Gemini, OpenAI, or Anthropic Claude. QuickCode runs a Project Analysis first — a module plan you can review — then generates DBML per module.

Google Gemini

OpenAI

Anthropic Claude

Do not generate Identity/User modules

QuickCode injects IdentityModule automatically. Do not add separate user, role, or auth modules in AI output or DBML, they conflict with the built-in module.

Platform modules from the catalog

When email, SMS, or similar capabilities fit, analysis can select ready-made PLATFORM modules from the QuickCode catalog instead of inventing duplicate services.

Plan with AI

Project analysis module plan review — Module plan

Answering an open question — Open question

Review the Project Analysis plan

Analysis returns a structured module plan: custom GENERATED modules, ready-made PLATFORM modules, and system Identity. Open questions highlight decisions that would change the schema. Answer only what you need — answering switches the flow to update the plan before DBML generation.

Open questions (optional)

Tap a question, pick a suggested answer or write your own, then update the plan. Questions are capped to the highest-priority gaps so you are not blocked by a long questionnaire.

Add a note

Optional context (providers, v1 scope, constraints) is kept with your answers and applied when you update the plan — PDFs are not resent on refine.

Generate only when the plan is ready

With unanswered questions, Generate DBML from this plan stays available. Once you keep an answer, the primary action becomes Update plan with answers until the analysis is refreshed.

DBML generation in progress from analysis — Writing DBML

Analysis DBML generation complete — Schemas ready

Generate DBML schemas from the plan

When the plan looks right, generate per-module DBML in the background. Each GENERATED module gets tables, relations, and QuickCode DSL notes; PLATFORM modules are copied from the catalog. Review the result in Studio, then iterate or deploy.

Per-module generation

Schemas are written and validated module by module. Failures stay isolated so successful modules are not regenerated.

Single-module AI still available

Use Module with AI or Update Module when you only need one bounded context, without running a full project analysis.

Get started

Why QuickCode is Different

Copilot and ChatGPT help you write code. QuickCode helps you run engineering at scale, with repeatable architecture, safe regeneration, and working APIs from day one.

Regen-Safe Generation

Generated code lives in .g.cs files; your logic stays in partial classes. Regenerate after schema changes without manual merges.

Consistent Architecture

Every service follows the same patterns for logging, validation, auth, and CI/CD.

Early Schema Validation

Invalid DBML is caught before generation with per-module errors.

Design your schema

DBML & QuickCode DSL

Edit tables, enums, and Ref relationships in the Studio DBML editor or diagram view. Default CRUD is generated for every table; add QuickCode DSL in table Note blocks for custom queries, updates, and deletes.

Modules & templates

Add modules from templates (e-commerce, HR, email, and more) or generate with AI. Each module has its own DBML file and deployable API service.

Per-module settings

Set database type (PostgreSQL, MySQL, SQL Server) and architecture (CQRS + Mediator or Service) in the Project {} block or module settings.

Built for Iteration

Update DBML and regenerate. The generated layer refreshes; custom code in partial classes is preserved. Schema diff drives migration scripts and API updates consistently.

Generated layer

Controllers, DTOs, repositories, and scaffolding in .g.cs files; regenerated on each run.

Custom layer

Business logic, extra endpoints, and validation in partial classes QuickCode never overwrites.

What gets generated

Gateway Swagger and module APIs — Gateway APIs

APIs with Dapper & .NET 10

QuickCode generates .NET 10 API services with Dapper repositories, parameterized SQL for PostgreSQL, MySQL, or SQL Server. Choose CQRS + Mediator or Service pattern per module.

.NET 10

Docker

QuickCode DSL

Custom operations in DBML Notes compile to REST endpoints, handlers, and Dapper queries.

Postman collections

Auto-generated collections per module with auth environments for local, Docker, and Cloud Run.

Portal Live Report with parameters and Run Report — Live Report

Portal Live Report results grid — Report results

API method access grants — Access control

Brands list with image, PDF, and video preview actions — Media list

Image preview lightbox in admin portal — Image preview

PDF preview lightbox in admin portal — PDF preview

Video preview lightbox in admin portal — Video preview

Admin Portal & Identity

An admin portal is generated with CRUD for your tables, live reports from DSL Query operations, group-based authorization, table-level permissions, and configurable endpoint workflows. Declare BLOB_IMAGE, BLOB_PDF, BLOB_VIDEO, and BLOB_FILE columns in DBML to get upload fields, list actions, and in-app preview (image lightbox, PDF iframe, HTML5 video). Files are stored as HTTPS object URLs (Azure Blob, S3-compatible storage such as Cloudflare R2, or local files in development), not binary in the database. IdentityModule handles users, roles, and API/portal access; do not duplicate it in your modules.

Table management

Manage records through auto-generated portal screens tied to your DBML tables.

Access control

API method grants and portal page permissions from centralized management screens.

File and media columns

Use BLOB_IMAGE for photos and logos, BLOB_PDF for datasheets, BLOB_VIDEO for product or intro videos, and BLOB_FILE for other documents. The portal generates upload controls, size limits, and Preview actions without custom UI code.

Object storage backends

Configure Azure Blob Storage, any S3-compatible provider (including Cloudflare R2), or local file storage for development. The same pipeline applies to all BLOB_* column types.

Live Reports

DSL Query operations appear in the portal as Live Reports. Set parameters, click Run Report, and scan the result grid — the matching GET API path is shown on the page.

Microservices Architecture

Each domain module is a separate deployable API. YARP gateway routes client requests; an event listener service handles async processing where configured.

Gateway with YARP

Single HTTPS entry point to module APIs with routing and security.

Module APIs

Independent services per module, each with Swagger and Cloud Run deployment.

Deploy & integrate

GitHub Repository & Actions

All generated code is pushed to github.com/QuickCodeNet/{project-name}. GitHub Actions run tests, build Docker images, and trigger deployment workflows.

GitHub

QuickCode

Automated testing

Generated test suites for repositories and CRUD operations are included in the repo.

Studio generation pipeline complete — Pipeline complete

Deploy to Google Cloud Run

After you confirm Generate Microservices, Studio tracks the full cloud pipeline: GitHub repo, code push, Google Cloud project, solution generation, migrations, then build and deploy for portal, gateway, listener, and each module API. URLs follow patterns like {project}-gateway.quickcode.net and {project}-portal.quickcode.net.

Cloud Run

Live pipeline in Studio

Watch setup, generation, and Cloud Run deploy status in real time — mid-run progress and the completed view with service links.

Regenerate safely

Re-run Project with AI or Generate Microservices when the plan changes. Confirm before existing modules are replaced.

Run Locally with Docker

docker-compose in the generated repo runs the full stack locally (gateway, portal, module APIs, and databases) for development and demos before Cloud Run.

Try it

QuickCode Studio & Demo

Use QuickCode Studio for Project Analysis, DBML editing, ERD visualization, module AI, and the live Cloud Run generation pipeline. Explore the public demo (gateway, portal, GitHub) from the Demo menu, or start a new project from the homepage.

Studio

https://studio.quickcode.net — projects, Project with AI analysis, per-module DBML, AI refine, and cloud generation progress.

Demo project

Live demo gateway and portal; see /demo-project for a guided walkthrough with credentials.

AI Rule Pack (Persistent)

Every generated project includes AI-readable guide files so code generation follows consistent project rules from the first prompt to the latest regeneration.

What is added: rule and guide files such as AGENTS.md and AI instruction files.
How AI uses it: the generator and AI assistants read these files before creating or updating code.
Why it is safe: regeneration preserves these files, so your generation behavior stays stable over time.