Introduction
Buildocs lets you build CRMs, ERPs, and workflow applications without frontend deployments.
Design forms with tables, inputs, file uploads, and custom widgets in the visual designer. Connect your backend through the SDK. Ship UI changes instantly — no rebuilds, no downtime.
It is not a form builder that stops at submission — it is a full UI engine for forms, tables, document workflows, and approval flows, where your backend controls everything at runtime.
Rapid Application Development
Buildocs is built for speed. The features that normally take weeks to implement are included and production-ready — you focus on business logic, not infrastructure.
| Feature | What it means |
|---|---|
| File upload & download | Upload, store, and download files without writing file-handling UI code |
| Document previewer | Preview PDFs, images, and Excel files inline — no third-party viewer needed |
| i18n support | Multi-language interfaces with automatic locale resolution |
| Form validation | Built-in required-field validation, custom backend rules, field highlighting |
| Modal workflows | Open nested forms, detail views, and approval flows from buttons or table rows |
| Table widget | Sortable, paginated data tables with inline actions |
Teams use Buildocs to digitalize operations quickly — turning paper processes, Excel sheets, and documented workflows into working digital applications in a fraction of the time.
What you can build
Buildocs is designed for teams building configurable business systems, not just collecting form submissions.
- CRM and ERP platforms
- Document management and approval workflows
- Internal tools and admin panels
- Client portals and multi-tenant SaaS products
- Enterprise process automation
Your backend controls the UI at runtime — opening modals, showing or hiding fields, triggering downloads, running validation, and driving full user journeys — without frontend deployments.
Architecture Overview
Buildocs UI Engine follows a design-once, render-anywhere architecture.
How It Works
1. Design
Create and configure forms, workflows, and interfaces inside the Buildocs UI Engine platform using the visual designer.
2. Integrate
Install the SDK inside your frontend application or use iframe integration for faster adoption.
3. Render
Interfaces are rendered natively inside your application (for example React), not hosted externally.
4. Control
Your backend controls behavior, validation, workflows, and business logic at runtime.
5. Process
All submission data and workflows remain fully inside your own infrastructure.
Buildocs UI Engine integrates naturally into existing systems without requiring vendor-controlled hosting, external backends, or forced iframe usage.
Unlike many form builder platforms, you keep full ownership of:
- frontend behavior
- backend logic
- workflows
- security
- compliance
- data
Core Capabilities
These features are available when using the Buildocs UI Engine SDK.
✅ Visual UI Designer — Build forms and interfaces using a visual schema-driven designer
✅ Runtime UI API — Full programmatic control over application behavior
✅ Backend Communication — Trigger backend logic from UI events
✅ Dynamic Interfaces — Show, hide, validate, and prefill components dynamically
✅ Document Workflows — Generate, preview, upload, and download files
✅ Modal Interfaces — Open nested forms and dialogs from actions or workflows
✅ Advanced Theming — Centralized project-level UI customization
✅ Full Data Ownership — Your infrastructure controls all workflows and persistence
Runtime API
What makes Buildocs UI Engine a true platform instead of a simple form builder is the Runtime API.
While interfaces are designed visually, your application controls them completely at runtime.
| Capability | Description |
|---|---|
| Widget Control | Show, hide, enable, disable any UI element |
| Data Manipulation | Prefill values, update fields, read application state |
| Validation | Custom validation, highlighting, errors, warnings |
| File Operations | Upload files, trigger downloads, preview PDFs |
| Modal Interfaces | Open forms in dialogs from buttons or table actions |
| Backend Commands | Backend responses can modify UI automatically |
Your backend can send commands that the interface executes automatically:
- update values
- open dialogs
- show or hide sections
- trigger downloads
- change validation states
This enables server-driven UI behavior without frontend deployments.
Data Flow and Ownership
Buildocs UI Engine does not impose a predefined submission pipeline like many traditional form builders.
When using the SDK, your application is responsible for all data handling.
Your Application Handles
- receiving submission data
- validation and transformation
- database persistence
- external service integrations
- business workflows
- permissions and access control
This makes Buildocs UI Engine suitable for applications with strict requirements around:
- security
- compliance
- auditability
- data sovereignty
- enterprise workflows
Typical Use Cases
Buildocs UI Engine is designed for teams building configurable business systems — not just collecting form submissions.
| Use Case | Description |
|---|---|
| 🏢 SaaS Platforms | Embedded interfaces for customer-facing applications |
| 👥 Multi-tenant Systems | Shared UI definitions across multiple tenants |
| 📄 Document Workflows | Generation, signing, approval, and automation |
| ⚙️ Internal Tools | Admin panels, process flows, operational systems |
| 🎯 Centralized Management | Design centrally, execute locally |
| 🔒 Data Sovereignty | Full ownership of infrastructure and workflows |
Why Teams Choose Buildocs UI Engine
Because most businesses do not need another simple form builder.
They need:
- flexible application infrastructure
- dynamic UI without constant frontend deployments
- backend-controlled workflows
- document automation
- enterprise-grade customization
They need forms that are part of the product — not isolated submission pages.
Buildocs UI Engine provides exactly that.
It helps teams ship CRMs, ERPs, and internal tools faster — without maintaining a separate frontend codebase for every UI change.
Next Steps
📚 Explore Documentation
Learn platform concepts and implementation patterns
💻 View Code Examples
See real-world integration examples
🔧 API Reference
Detailed SDK and runtime API documentation
Need help with architecture, integration, or implementation?
Contact support or reach out to our team for guidance.