How Three Sigma Works

From idea to running application in four steps.

Three Sigma isn't a tool that helps you build software—it's an engine that builds software for you. Here's what happens behind the scenes when you create a process.

The Four-Step Flow

Step 1: Describe

You tell Three Sigma what you need. Use plain language. Be specific about what happens, who's involved, and what decisions need to be made.

Example prompt:

"Create a non-conformance report process for our manufacturing floor. When a defect is found, the operator should log the part number, defect type, and attach a photo. Then quality reviews it and decides whether to scrap, rework, or accept with deviation. If rework is chosen, track the rework completion and re-inspection."

That's it. No wireframes. No database design. No form builders. Just describe what you need.

Step 2: Generate

Our AI Process Generator takes your description and produces a complete process definition—a structured schema that specifies:

• Every step in the workflow

• Every field needed to capture data

• Every action users can take

• Every transition between steps

• Every validation rule and conditional requirement

This isn't a rough draft or a suggestion. It's a fully-formed, machine-readable definition that's ready to run.

What the AI figures out for you:

• Which field types match your data (text, numbers, dates, selections +many more)

• How steps should flow based on decisions

• What validations prevent incomplete submissions

• Which automations should trigger on actions

Step 3: Validate

Before anything goes live, the Validation Engine checks the entire process definition for consistency and safety.

What gets validated:

• Every field reference points to a real field

• Every step transition leads to a real step

• Conditional expressions use valid operators

• Required fields are defined before they're needed

• Automations reference existing processes and fields

• Permissions and access controls are properly configured

If something doesn't add up—a typo in a field name, a transition to a step that doesn't exist, a circular dependency—the validator catches it. Your process won't deploy with errors lurking inside.

This matters because:

• Non-technical users can iterate without breaking things

• AI-generated schemas are guaranteed to be runnable

• Production systems stay stable even as you experiment

Step 4: Deploy

Once validated, deployment is instant. The runtime automatically:

• Creates database tables to store your process data

• Generates API endpoints for every operation

• Builds the user interface for each step

• Provisions tenant isolation so your data stays yours

• Activates automations so notifications and triggers work immediately

There's no build step. No deployment pipeline. No DevOps ticket. The process is live and ready for users.

What Makes This Possible

Schema-Driven Architecture

Everything in Three Sigma flows from a single JSON schema. That schema is the source of truth for:

• What data gets stored (database)

• What operations are available (API)

• What users see and interact with (UI)

• How work flows between steps (runtime)

Change the schema, and the entire system updates. Add a field, and it appears everywhere it should. Remove a step, and all the routing adjusts automatically.

AI That Outputs Runnable Code

Most AI tools generate suggestions, summaries, or drafts that humans still need to implement. Three Sigma's AI generates deployable process definitions—complete schemas that the runtime can execute immediately.

The AI doesn't just help you think about your process. It builds the process.

Validation as a Safety Net

The Validation Engine means you can iterate fearlessly. Try things. Experiment. If something won't work, you'll know before it's deployed. If it passes validation, it will run correctly.

Real-World Timeline

Traditional development:

• Requirements gathering: 2–4 weeks

• Design and specification: 2–4 weeks

• Development: 4–12 weeks

• Testing: 2–4 weeks

• Deployment and fixes: 1–2 weeks

• Total: 3–6 months

Low-code platforms:

• Configuration and setup: 1–2 weeks

• Building workflows: 2–4 weeks

• Testing and refinement: 1–2 weeks

• Total: 4–8 weeks

Three Sigma:

• Describe and generate: 5–10 minutes

• Review and refine: 5–15 minutes

• Validate and deploy: instant

• Total: 8–20 minutes

After Deployment

Your process is live, but that's just the beginning.

Iterate instantly: Changes take the same path—describe what you want to adjust, regenerate, validate, deploy. Updates go live in minutes.

Learn from usage (Process Mining): See how people actually use your process. Which paths do they take? Where do they get stuck? What fields are always empty? Use real data to improve.

Scale effortlessly: The same process that works for 10 users works for 10,000. The runtime handles scaling automatically.

Connect to other systems: Every process exposes APIs. Integrate with your existing tools, or trigger other Three Sigma processes automatically.

Next Steps

→ Processes — Understand steps, fields, and actions
→ Templates — See ready-to-deploy examples