Coming Soon — Early Access 2026

Describe Your System.
No AI Writes The Code.

The metadata framework where solution architects and business consultants declare complete systems — data models, workflows, permissions, and interfaces — in a single specification. A deterministic generator turns it into software, and a compiler compiles it. If it does not compile, you do not get it.

Great systems shouldn't require
armies of developers.

Today, turning a business vision into software demands months of handwritten code across dozens of layers. Models, APIs, databases, interfaces, permissions, tests — every change propagated manually. What if you could describe the system you need — once, in a specification a machine can validate — and let a deterministic pipeline handle the engineering?

// SalesOrder.dotDocType.json { "header": { "name": "SalesOrder", "metatype": "Document" }, "fields": [ ... ], "rules": [ ... ], "permissions": { ... }, "layout": { "diagram": "Draft → Submitted → Cancelled" }, "x-server-scope": "business_unit" } // → Deterministic. No language model in the path. // → Workflows & state machines included // → If it does not compile, you do not get it.

Declare The Structure. Not The Plumbing.

A dotDocType is a single JSON file that completely describes a business entity — fields, validation rules, user permissions, state flows, and visual layout. Change the specification, and the platform re-applies it additively: tables and columns are created, never dropped.

Design your business processes as flow diagrams and state machines directly inside the specification. Define transitions like Draft → Submitted → Cancelled, and the framework generates the complete workflow engine automatically.

If you can describe a business process, you can build a system. dotDocType was designed for solution architects and business consultants who understand what needs to exist — not how to code it.

Your specification enters.
A complete system exits.

Inside dotDocType your declaration runs a fixed sequence: it is parsed and checked against a formal schema, a deterministic generator emits the code, and a compiler compiles it. No language model takes part. A malformed specification never reaches the compiler.

.dotDocType.json
Entity.g.cs
EfConfiguration.g.cs
Compile.ok
Specification
Your JSON declaration enters the pipeline
Validate
Checked against a formal schema. Malformed input is refused with a numbered diagnostic.
Generate
A deterministic generator — not a language model — emits the code.
Compile
If it does not compile, nothing is delivered. Failure tears the environment down.
Activate
dotDocType activates the module. You declare; we activate.
No language model takes part in generating the code that runs your system.
A fixed sequence — parse, generate, compile — with no way around it.
Permissions are declared in the specification and enforced at runtime, down to the field.
You describe the structure of your business. We operate the platform that runs it.

No language model
writes your system.

A deterministic generator — not a model — turns your specification into code, and a compiler compiles it. There is an AI assistant while you author: it suggests fields, permissions or layout inside a draft you already opened, read-only, and a human accepts or rejects each suggestion. It never writes code, and it never publishes.

C# .NET 10 Vue.js PostgreSQL REST API

No language model in the compile path

The code that runs your system is emitted by a deterministic generator and compiled. Not written by a model.

Malformed specifications are refused

The specification is parsed and checked against a formal schema. A malformed declaration never reaches the compiler.

Fail-closed by construction

If the code does not compile, the environment is torn down and nothing is delivered. Nothing half-applied survives.

No tenant code on our infrastructure

No tenant executes imperative code on our infrastructure. It is our strongest security property — and it is also our ceiling. We say both.

Metadata. Determinism. Governance.

Three architectural pillars working together to eliminate the gap between business vision and working software.

Metadata-Driven Design

Describe entities, workflows, and permissions in structured JSON — including state machines, transition flows, and layout definitions. Your business logic becomes the blueprint, not handwritten code.

Deterministic Generation

Your specification is parsed, generated and compiled in a fixed sequence. No language model takes part in producing the code that runs your system. If it does not compile, you do not receive it.

Declared Governance

Who can read, create, update and delete — and which fields each role can see — is declared in the specification and enforced by the server, denying by default.

From business vision to running system.

Describe what your business needs. A deterministic pipeline handles the engineering.

1

Describe

Define your business entities, rules, workflows, and permissions in a structured .dotDocType.json file. Design state flows and transition diagrams inline.

2

Validate

The specification is checked against a formal schema. A malformed declaration is refused with a numbered diagnostic and never reaches the compiler.

3

Compile

A deterministic generator emits the code and a compiler compiles it. If it fails, the environment is torn down — nothing half-applied survives.

4

Activate

dotDocType activates the module and operates the platform that runs it. You declare; we activate.

Built for the people who
understand the business.

dotDocType bridges the gap between business knowledge and working software. You describe the structure the system must have; we build and operate it.

Solution Architects

Design complete system architectures — entities, relationships, workflows, and access rules — and see them materialize into working software.

Business Consultants

Translate business processes into structured specifications. Define approval flows, access controls, and data models in a language that reads like business requirements — and works like software.

Development Teams

Eliminate repetitive boilerplate. Focus on complex business logic while the framework handles scaffolding, migrations, tests, and infrastructure. Extend with custom code when you need to.

Be among the first.

Join the waitlist to get early access when we launch. We'll keep you updated on our progress.

No spam. We'll only reach out with meaningful updates.

You're on the list!

We'll reach out when early access is ready. Thank you for your interest in dotDocType.