Skip to main content

Architecture

Learn how Buildocs UI Engine works behind the scenes and how its components work together to deliver backend-driven, runtime-controlled interfaces.

Unlike traditional form builders, Buildocs UI Engine separates interface design from interface execution — giving your application full ownership of logic, workflows, and data.

It follows a design-once, render-anywhere architecture built for modern SaaS platforms, enterprise systems, and dynamic business applications.

Overview​

Buildocs UI Engine uses a schema-driven architecture where interfaces are designed visually and rendered dynamically inside your own frontend application.

This allows teams to build forms, workflows, dialogs, tables, and document-driven processes without hardcoding every UI change.

Instead of deploying frontend changes for every workflow update, your backend and runtime API control the experience dynamically.

This is what makes Buildocs UI Engine more than a form builder — it becomes a runtime UI platform.

System Components​

The architecture consists of three main parts:

  1. Buildocs UI Engine Platform
  2. Client SDK
  3. Your Application

Each part has a clear responsibility.

Buildocs UI Engine Platform​

The cloud platform where interfaces are created, configured, and managed.

This is where teams design forms, workflows, and reusable UI schemas using the visual designer.

Includes​

  • Visual UI designer
  • Dynamic form builder
  • Project and API key management
  • Theme configuration
  • Translations and localization
  • Form branching and conditional logic
  • Workflow definitions
  • Centralized UI configuration

The platform stores the interface definitions — not your business data.

It acts as the design layer, not the execution layer.

Client SDK​

The client-side SDK installed inside your application.

This SDK renders interfaces natively inside your frontend (for example React) and exposes the Runtime API for full programmatic control.

Includes​

  • Form rendering engine
  • Dynamic UI renderer
  • Provider components
  • Runtime API
  • Theme system
  • Event handling
  • Modal and dialog support
  • File preview and document actions

This is where Buildocs UI Engine becomes a true embedded platform instead of a hosted form builder.

The SDK allows your application to control interfaces at runtime.

Your Application​

Your application remains the source of truth for everything important.

Buildocs UI Engine does not take ownership of your workflows, users, or data.

You stay fully in control.

Your application handles​

  • Data submission and storage
  • Business logic and workflows
  • User authentication
  • Permissions and access control
  • API integrations
  • Validation rules
  • External system communication
  • Compliance and audit requirements

This architecture is especially important for enterprise systems where security and ownership matter.

Data Flow​

Buildocs UI Engine Data Flow

How Data Flows​

1. Design​

Interfaces are created and configured inside the Buildocs UI Engine platform using the visual designer.

This includes forms, dialogs, approval flows, nested modals, and document workflows.

2. Fetch​

The Client SDK fetches interface definitions securely at runtime using your project configuration and API keys.

No hardcoded frontend structure is required.

3. Render​

Interfaces render natively inside your React application using the SDK.

Users interact with UI that feels fully native to your product.

4. Control​

Your backend controls runtime behavior through responses and commands.

It can:

  • open modal forms
  • update fields
  • trigger validation
  • show or hide widgets
  • preview PDFs
  • trigger file downloads

5. Process​

Your application handles all submissions, persistence, and workflow execution.

Nothing is forced into vendor-managed storage.

You own the entire business process.

Why This Architecture Matters​

Most form builders stop after rendering a form.

Buildocs UI Engine continues through the full application lifecycle.

This architecture enables:

  • backend-driven UI behavior
  • zero frontend redeployments for workflow changes
  • enterprise-grade flexibility
  • full data sovereignty
  • document automation
  • embedded SaaS experiences
  • multi-tenant runtime control

Instead of building isolated forms, teams build full runtime-controlled applications.

Design Once, Render Anywhere​

One of the core principles of Buildocs UI Engine is:

Design once. Render anywhere.

The same interface definitions can be rendered:

  • inside your React application
  • inside customer portals
  • inside internal admin systems
  • inside embedded iframe integrations
  • across multi-tenant SaaS environments

This creates consistency while preserving flexibility.

Your backend stays in control everywhere.

Summary​

Buildocs UI Engine architecture is designed for teams that need more than a form builder.

It provides:

  • visual design for speed
  • runtime APIs for flexibility
  • backend control for ownership
  • native frontend rendering for better UX
  • enterprise-grade infrastructure for long-term scalability

The result is a UI platform built for real business systems — not just form submissions.