Form API
Buildocs UI Engine is not just a form builder.
It is a backend-driven frontend framework that allows you to build complete applications using forms, tables, dialogs, workflows, and runtime UI control — all driven by your backend.
Instead of treating forms as isolated pages, you build connected application flows where interfaces react dynamically to business logic.
Your backend becomes the brain.
The frontend becomes the runtime engine.
Build Complete Applications, Not Just Forms
Stop thinking about single forms.
With Buildocs UI Engine, you can build entire applications where multiple forms work together as one connected system.
This includes:
- CRM platforms
- ERP systems
- approval workflows
- document management systems
- internal admin tools
- client portals
- multi-tenant SaaS applications
Forms open other forms.
Tables refresh automatically.
Dialogs appear when needed.
Files are generated, previewed, and downloaded.
The entire frontend behaves like a real product — without manually coding every screen.
Example: Customer Management Application
Imagine building a customer management system.
Master Form
The main screen displays a customer table and action buttons.
User actions
Click Add New
→ Opens a customer creation form inside a modal
Save the form
→ The customer table refreshes automatically
Click a table row
→ Opens a customer detail form with existing data
This feels like a normal SaaS product — but the entire behavior is controlled by backend responses.
Detail Form
The customer detail form can contain:
- customer information
- action buttons
- embedded tables
- related workflows
Example actions
Edit button
→ Opens the customer edit form
View Orders
→ Opens an orders table form
Add Payment
→ Opens a payment entry form
View Documents
→ Opens file previews or document upload forms
Each form can open additional forms.
This creates full multi-form application flows.
Multi-Form Workflows
You can link forms together to build complex business processes.
Approval flows
Submit request → Open approval form → Trigger notifications → Lock approved data
Wizards
Step-by-step forms that pass data between screens automatically
Master-detail systems
Parent record with multiple child forms and related data tables
Document workflows
Generate → Upload → Review → Approve → Download → Archive
This is where Buildocs UI Engine becomes much more than a form builder.
With Buildocs UI Engine, the frontend behavior is handled automatically.
Forms open other forms.
Tables refresh dynamically.
Modals appear when needed.
Documents preview inline.
Validation states update automatically.
You write backend logic.
Your API receives events, applies business rules, and responds with actions that control the UI.
Your Backend Controls Everything
The real power of Buildocs UI Engine is that all form behavior is controlled by your backend.
When users interact with the UI, your API receives events and sends back instructions.
This enables true server-driven UI.
You change behavior by changing backend responses — not by deploying frontend code.
Backend-Driven Actions
Your API can instruct forms to:
- open other forms
- set field values
- show or hide widgets
- pre-populate dropdowns
- refresh tables
- set read-only states
- preview documents
- trigger file downloads
- display messages
- highlight fields
- execute validation
- close forms
Your business logic stays on the server.
The UI reacts automatically.
This architecture enables powerful scenarios:
Approve a request → the form locks itself
Select a premium plan → advanced options appear
Save a record → the parent table refreshes automatically
Generate a contract → the PDF opens instantly
Your backend orchestrates the full user experience.
Core API Capabilities
Dynamic Widget Control
Show and Hide Widgets
Control visibility based on any condition.
Examples:
- reveal billing fields for premium users
- hide admin sections for limited roles
- show advanced options only when needed
Read-Only and Editable States
Lock or unlock fields dynamically.
Examples:
- make approved forms read-only
- allow editing only for managers
- protect finalized data while allowing comments
Prefill Form Data
Load data directly from your systems.
Examples:
- existing customer information
- default project settings
- data from previous workflow steps
User Notifications
Display messages to guide users during interactions.
Success
Customer saved successfully
Warning
This action cannot be undone
Error
Email address already exists
Info
Premium features are available for this account
Notifications are controlled by backend responses.
Validation and Error Handling
Backend-Driven Validation
Business validation should live where your business logic lives — on the server.
Examples:
- duplicate record checks
- external API validation
- role-based permissions
- approval state validation
- financial rule enforcement
This avoids duplicated frontend validation logic.
Field Highlighting
Draw attention to specific fields visually.
Examples:
- highlight validation errors
- mark missing required fields
- show warnings for risky values
- indicate successful validation states
The backend decides what needs attention.
File Management
File Upload and Processing
Upload handling stays fully under your control.
Examples:
- validate file type and size
- process uploaded documents
- trigger OCR workflows
- store files in your own infrastructure
- connect uploads to business processes
File Download and Generation
Your backend can trigger downloads programmatically.
Examples:
- PDF reports
- Excel exports
- contracts
- certificates
- signed documents
- generated invoices
The frontend handles delivery automatically.
PDF Preview
Preview documents directly inside forms.
Examples:
- review contracts before approval
- preview uploaded files
- display generated reports
- compare document versions
No external viewer required.
Form Navigation and Modals
Open Forms from Anywhere
Your backend can open any form based on user actions.
From buttons
Click Add Customer
→ open customer form
From tables
Click row
→ open detail form
From forms
Save form
→ open next workflow step
After save
Complete action
→ open confirmation or approval form
This creates seamless application flows.
Modal and Full-Screen Forms
Forms can appear in different contexts.
Modal overlays
Quick edits without losing page context
Full-screen forms
Large workflows needing full focus
Nested modals
Open forms from inside forms
Sequential modals
Step-by-step guided workflows
This creates rich frontend experiences without frontend complexity.
Table Integration
Tables and forms work together automatically.
Examples:
- Add button opens a blank form
- Row click opens a prefilled form
- Save refreshes the parent table
- Actions trigger related forms instantly
This makes CRUD systems extremely fast to build.
Real-Time Backend Communication
Field Change Handlers
Every widget can trigger backend calls when values change.
Examples:
Cascading dropdowns
Select country → load states
Dynamic pricing
Choose options → calculate totals
Availability checks
Enter username → verify uniqueness
Auto-complete
Type value → fetch suggestions
Dependent fields
One value changes another field’s options
This creates live, reactive interfaces.
Event-Driven Architecture
Forms communicate with your backend throughout the full lifecycle.
onLoad
Form opens → fetch initial data
onChange
Field changes → run logic
onSave
User clicks save → validate and process
onButtonClick
Execute custom backend action
onTableAction
Respond to table interactions
The frontend becomes fully reactive to backend instructions.
Bi-Directional Data Flow
Traditional forms only submit data.
Buildocs UI Engine supports much more.
Forms request data
When needed, from your backend
Backend pushes updates
Based on business logic
Real-time UI updates
Without page refreshes
Multi-form orchestration
Across complex workflows
This is application behavior, not just form submission.
Internationalization and Localization
Multi-Language Support
Render interfaces in any language without code changes.
Includes:
- labels
- placeholders
- validation messages
- button text
- workflow messages
Translations are managed centrally inside Buildocs UI Engine.
Automatic fallback is supported.
Regional Formatting
Formatting adapts automatically to user locale.
Dates
DD/MM/YYYY, MM/DD/YYYY, YYYY-MM-DD
Time
12-hour or 24-hour format
Numbers
Decimal and thousand separators
Currency
Localized currency symbols and formatting
This improves global usability immediately.
Think Applications, Not Forms
Traditional form builders give you static data collection.
Buildocs UI Engine gives you a complete frontend framework.
| Traditional Approach | Buildocs UI Engine |
|---|---|
| Single-page forms | Multi-form applications |
| Static layouts | Dynamic widget control |
| Fixed validation | Backend-driven validation |
| Simple data collection | Real-time data manipulation |
| One-way form submission | Bi-directional communication |
| Frontend-heavy development | Backend-first development |
| UI changes require deployment | Behavior changes via API |
The Development Experience
You focus on business logic
Write backend code that:
- handles data
- enforces rules
- manages workflows
- orchestrates UI behavior
We handle the frontend
Forms open automatically.
Tables refresh.
Dialogs appear.
Files preview.
Validation updates.
UI reacts to your backend.
No frontend deployments
Change behavior by updating backend logic.
The frontend responds automatically.
This dramatically speeds up product development.
Build Like a SaaS Product
With Buildocs UI Engine, you can build applications that feel like modern SaaS platforms:
- CRM systems
- project management tools
- inventory platforms
- document management systems
- approval workflows
- construction management systems
- internal business tools
- multi-tenant enterprise software
The difference?
You write backend logic.
Buildocs UI Engine handles the frontend runtime.
That is the real power of the platform.