Frequently Asked Questions

QuickCode is a diagram-driven microservices generator. You describe your system in plain language or DBML, and QuickCode produces production-ready .NET services with API endpoints, Dapper data access, and optional QuickCode DSL for custom Query, Update, and Delete operations, plus a YARP gateway, IdentityModule, admin portal, GitHub repositories, and CI/CD pipelines aimed at Google Cloud Run.

Start on the homepage with Try generating with AI or open an existing project in QuickCode Studio. QuickCode runs Project Analysis first — a reviewable module plan with optional open questions you can refine before generating per-module DBML. You choose database type and architecture (CQRS + Mediator or Service), then generate. Code is pushed to GitHub; QuickCode Studio can track the Cloud Run deploy pipeline for gateway, portal, and module APIs. Step-by-step: How it works.

Yes. Describe your product in natural language on the homepage (Try generating with AI) or in QuickCode Studio (Project with AI). Pick Google Gemini, OpenAI, or Anthropic Claude. QuickCode runs Project Analysis first — a module plan with open questions you can answer or skip, then refine iteratively before per-module DBML is generated. In Studio you can optionally attach a PDF with the brief. Many teams use AI for a first draft, then refine tables and DSL by hand. Details below under AI analysis & generation.

QuickCode is currently offered free of charge, as is. We may introduce paid plans or premium features later; any change will be announced in advance. Third-party costs (your own cloud accounts, object storage, or LLM usage outside the product) are separate if you choose those paths.

There is no separate sign-up flow and no SSO yet. When you set up a project you provide a project name and work email. A one-time secret code is emailed to you; you need it to open the project in QuickCode Studio and run generation. That combination identifies and protects your workspace. For enterprise pilots that need org accounts or SSO, contact us.

Each project is a full workspace, not API stubs only:

• Per-module .NET APIs with Dapper repositories, default CRUD, and custom Query/Update/Delete from QuickCode DSL
• YARP gateway, single HTTPS entry to module APIs
• Admin portal with CRUD, Live Reports, media upload fields, and access grants
• IdentityModule for users, roles, and API/portal auth (injected automatically)
• Event listener for async/Kafka workflows where configured
• Migrations, Postman collections, docker-compose, and GitHub Actions toward Google Cloud Run

More detail: What QuickCode generates.

Where configured, you can choose Google Gemini, OpenAI, or Anthropic Claude for Project Analysis, module generation, and refine flows in QuickCode Studio. You review the plan and DBML before generation; AI drafts schemas, it does not silently overwrite your custom code.

You describe the product in plain language and choose an AI provider. QuickCode does not jump straight to code. It first returns a structured module plan you can review:

• GENERATED modules — custom bounded contexts the AI proposed for your domain
• PLATFORM modules — ready-made catalog services (email, SMS, and similar) when they fit
• Identity — injected automatically; do not add User/Auth modules yourself

Optional open questions flag decisions that would change the schema. When the plan looks right, you generate per-module DBML in the background, then refine tables, relations, and DSL in QuickCode Studio before Generate Microservices. Walkthrough: How it works.

PDF attach is in QuickCode Studio, on Project with AI (not on the homepage prompt). A written prompt is still required; the PDF is extra context.

1. Open the project in QuickCode Studio (project name, email, secret code).
2. Choose Project with AI, write the brief, and pick Gemini, OpenAI, or Claude.
3. Click Upload PDF (paperclip). Only .pdf files, max 5 MB.
4. Use a text-based PDF (selectable text). Scanned image-only PDFs fail because QuickCode cannot extract enough text.

When you later update the plan with answers or a note, the original PDF is not resent — the note and answers are applied on top of the current plan. Replace the file with Replace PDF before a new analysis if the document changed.

No. Open questions highlight the highest-priority gaps that would change modules or schema (providers, v1 scope, and similar). You are not blocked by a long questionnaire.

• Tap a question, pick a suggested answer or write your own, then Update plan with answers.
• Add an optional note (constraints, providers, out-of-scope items). It is kept with your answers on refine.
• If you leave questions unanswered, Generate DBML from this plan stays available.
• Once you keep an answer, the primary action becomes Update plan with answers until analysis is refreshed.

When the module list looks right — custom modules, catalog PLATFORM picks, and no Identity duplicates. Generation writes tables, relations, and QuickCode DSL notes per module in the background. PLATFORM modules are copied from the catalog. Failures stay isolated so successful modules are not rewritten.

After DBML is ready, review it in Studio (editor or diagram), then generate microservices when you are ready to ship. You can still edit DBML by hand before that step.

Yes. Use Module with AI to add one bounded context, or Update Module to refine an existing module’s schema and DSL. That path does not rerun a full Project Analysis. Use full analysis when you are shaping the whole product; use single-module AI when you already have a project and only need one service changed.

Every generated project includes AI-readable guide files such as AGENTS.md and assistant instruction files (Cursor, Copilot, Claude). They tell tools where generated code ends and your code begins. Regeneration preserves these files, so later AI edits keep following the same project rules. More: How it works.

Update tables, DSL, or modules in QuickCode Studio (or via CLI update-dbmls), then regenerate. Generated .g.cs files are rewritten; your logic in partial classes stays. New APIs and migrations land, and the GitHub Actions / Cloud Run pipeline can run again. Put durable custom code only in non-generated partials, not in .g.cs files.

DBML (Database Markup Language) is a readable way to define tables, columns, enums, and relationships. QuickCode includes a DBML editor in QuickCode Studio. For syntax, column types, relationships, and DSL rules, see the Documentation.

QuickCode DSL is a one-line, intent-based notation inside DBML Note sections. It describes custom queries, updates, and deletes (filters, joins, pagination, and similar) not general programming logic. Standard CRUD endpoints are generated automatically; add DSL only for operations beyond that. Full reference: DBML & DSL guide.

Yes. Generated scaffolding lives in .g.cs files that QuickCode rewrites on each run. Your business logic, extra endpoints, and validation stay in partial classes that QuickCode never overwrites. Update DBML or DSL, regenerate, and the fresh generated layer continues to compile with your additions. Put durable custom code only in the non-generated partials, not in .g.cs files.

No. QuickCode injects IdentityModule automatically for users, roles, permissions, and API/portal access. Do not ask AI to invent User/Auth/Role modules, and do not add them in DBML, they conflict with the built-in module and fail validation. For email, SMS, or similar shared capabilities, analysis may select ready-made PLATFORM catalog modules instead of duplicating them.

When you create or configure a project you can target PostgreSQL, MySQL, or SQL Server per module. Generated SQL, connection strings, and migrations are tailored to the type you select. You can also set database_type and architectural_pattern (Service or CqrsAndMediator) in the DBML Project {} block.

Choose per module. Service is a straightforward layered API for most CRUD-heavy modules. CQRS + Mediator separates commands and queries when you want that pattern consistently across handlers. Both keep the same regen-safe layout, gateway routing, and portal integration. You can mix patterns across modules in one project.

The QuickCode CLI runs from your terminal: check or create projects, sync DBML, trigger generation, and pull repositories. Use it for automation, local workflows, or when you prefer not to use the browser. Install via Homebrew (macOS), Scoop (Windows), or a GitHub release, see the CLI Tool page.

Each project gets a GitHub repository under the QuickCodeStudio organization, typically at https://github.com/QuickCodeStudio/your-project-name. Clone, fork, or download as ZIP from GitHub. Pipelines in the repo build and deploy services (for example to Google Cloud Run). You own the generated code (see ownership below); the org hosts the default remote while you use QuickCode generation.

After you confirm Generate Microservices, QuickCode Studio tracks the cloud pipeline: GitHub repo, code push, solution generation, migrations, then build and deploy for portal, gateway, listener, and each module API. Hosted URLs follow patterns like {project}-gateway.quickcode.net and {project}-portal.quickcode.net. Generated repos also include GitHub Actions workflows you can adapt for your own cloud credentials and environments. For day-two ops, see Documentation.

Yes. Generated repositories include docker-compose to run the full stack locally (gateway, portal, module APIs, and databases) for development and demos before or instead of Cloud Run. Clone the repo from GitHub and follow the README in that project.

1. Describe your system on the homepage (Try generating with AI) or prepare DBML in QuickCode Studio.
2. Complete Set Up Your Project: project name and work email.
3. Confirm access with the secret code sent to your email.
4. Review the Project Analysis plan (and optional open questions), then refine modules, DBML, database type, and architecture (CQRS or Service).
5. Run generation and use the GitHub repository (and optional Cloud Run pipeline in Studio).

Step-by-step detail: Quick start · How it works.

Open QuickCode Studio with your project name, email, and secret code. Update DBML or DSL, then regenerate; changes are pushed to your GitHub repository. You can also use the CLI to pull DBML, edit locally, and upload with update-dbmls. Studio share links (?token=) give time-limited access without re-entering the secret code.

The secret code is a 20-character key emailed to your work address. It proves you control the inbox tied to the project. You need it to continue after setup and to return to the project later. Do not share it. If you lose it, use Forgot secret code? in the setup flow or QuickCode Studio to request a new code.

You do. Per our Terms, all code generated by QuickCode for your projects belongs to you, including the right to modify, distribute, and use it for any purpose. You also retain ownership of your DBML and project data; QuickCode only uses that data to provide the service.

Yes. Clone or fork the GitHub repository, or download it as a ZIP, and continue development in your own org or privately. Regeneration and Studio AI features require an active QuickCode project (name, email, secret code). Hosted *.quickcode.net Cloud Run URLs are tied to the platform pipeline; for your own cloud, use the generated Actions workflows and your credentials. For repo transfer help, contact us.

Access to a project requires the correct project name, email, and secret code. DBML and project metadata are stored on QuickCode infrastructure; treat DBML as design data, not a place for live secrets, API keys, or PII you would not put in source control. Review generated repos and cloud credentials in your own environment. Formal compliance certifications (for example SOC 2) are not claimed on this site; enterprise security reviews can start via Contact. See our Privacy Policy for more.

Parse errors usually mean invalid DBML syntax. Common causes:

• Missing or mismatched quotes on table/column names
• Incorrect Ref: relationship syntax
• Invalid or unsupported column types
• Malformed DSL inside Note blocks (see docs for Query/Update/Delete rules)
• Duplicate Identity/User/Auth modules conflicting with built-in IdentityModule

Use the QuickCode Studio editor and compare with examples in Documentation.

• Invalid DBML or DSL syntax
• Project name already taken or invalid format
• Wrong or expired secret code, or email that does not match the project
• GitHub repository name conflict
• Temporary service or network issues

Fix validation messages, verify your secret code, and try again. Persistent failures: Contact us.

• Update to the latest CLI release
• Confirm network access to QuickCode APIs
• Verify project name, email, and secret_code in config
• Reinstall via Homebrew, Scoop, or the GitHub release binary

Command reference: CLI Tool · Contact support