Work lives across disconnected tools
Forms collect one part of the request, spreadsheets hold another, and decisions remain buried in messages. People re-enter the same information because no shared application owns the full state.
App Builder for real business workflows
Turn the way your business works into a real application
Describe the people who use it, the information they handle, and the rules that move work forward. E-Code turns that context into connected screens and routes inside editable source code. Inspect every file, run the app in Preview, continue through the Agent, and export the project for the hosting path it needs.
Start with the process you already know. Project files, the running Preview, build output, and export controls stay visible as the application evolves.
This page-specific browser demonstration presents services, available times, customer details, and confirmation in one interactive booking flow.
From scattered process to working app
Your workflow outgrows spreadsheets long before custom software arrives
A process begins in a spreadsheet, a form, or an inbox because those tools are close at hand. As more people, records, approvals, and exceptions appear, the team repeats data entry, loses context between systems, and waits for software that matches the work.
Off-the-shelf software reshapes the process
Fixed fields, roles, and flows force the business into someone else’s operating model. No-code tools reach their limit when the workflow needs precise rules, connected data, or an exception the template never anticipated.
Traditional delivery separates intent from implementation
Requirements cross multiple handoffs before they reach working software, while developer time raises the cost of every clarification. The person who understands the process waits on a backlog and remains dependent on someone else to change the code.
E-Code starts from the workflow in everyday language. You describe what people do, inspect a running application and its real code, then request the next change without translating every decision into a technical specification.
One prompt starts the build
Describe the service, not the software architecture
The request below reads like a message from a salon owner. The four items map its implementation scope; the browser captures show a scripted functional demonstration authored for this page with fictional salon data, not a record of an E-Code generation.
Example prompt
Create a booking app for my hair salon, with a calendar, customer accounts, and email reminders.
- 01
Booking screens
The requested journey covers service selection, an available time, account creation, appointment confirmation, and upcoming visits across responsive screens.
- 02
Booking database
The requested data model covers clients, services, staff members, availability, appointments, and reminder state, with explicit relationships between each record.
- 03
Working booking rules
The implementation scope includes availability checks, account access, appointment creation, rescheduling, cancellation, confirmation, and reminder triggers.
- 04
Preview and deployment
E-Code runs the generated project in Preview for inspection across screen sizes. Supported static builds continue through guided publishing to a live URL; other projects remain exportable for their own hosting workflow.
The client selects a service, sees available times, and confirms the visit without calling the salon.
The team sees appointments, open capacity, and booking status in a schedule shaped around the working day.
Prompt → agent → Preview
Watch the app take shape inside E-Code
This is a real E-Code workspace captured after the agent ran the salon booking prompt. The E-Code UI, generated project files, and running Preview are real. The salon identity and records are fictional, and this captured project uses a local in-memory adapter; it has no external database, authentication provider, or email delivery service connected.
- 01
Describe the result
The salon owner writes the workflow in everyday language: booking calendar, customer accounts, and email reminders. There is no component list or software architecture to prepare first.
- 02
Follow the agent’s work
The Agent panel keeps the original request and its implementation plan visible while the Library shows the generated routes, pages, components, styles, and project configuration.
- 03
Test the app in Preview
The Webview tab runs the same project beside the conversation. You inspect the dashboard, calendar, booking journey, and account screens without leaving the E-Code workspace.
This capture shows the real E-Code UI, generated project tree, and booking dashboard running in Preview. It does not demonstrate server logic or a connected external database, authentication provider, or email delivery service.
Open full-size IDE capture
This correction follow-up asks the agent to inspect a router runtime error, preserve every route, and verify the booking dashboard again. The exported project later passed typecheck and a production build independently; the red Problems badge records local Preview startup diagnostics, not a claim that every generation is error-free on the first pass.
Open full-size IDE captureWhat you receive
A working application you own and keep evolving
The project remains inspectable from the first generated file through Preview and export. For supported static builds, guided publishing adds a live release without hiding the code or build output.
Real source code
Whatever the agent generates—frontend components, routes, validation, configuration, and any server modules—lives in readable project files that you review, edit, version, and export.
A visible data layer
Inspect the types, state, adapters, schemas, and queries the generated project actually contains. Supported database connections live in protected project secrets and expose schema inspection and read-query tools.
Running preview
The application runs beside the project so you click through its flows and review the experience across phone, tablet, and desktop layouts while the code changes.
Guided static publishing
For supported static builds, move the reviewed output through the E-Code deployment wizard, where configuration, publication, status, and logs remain visible.
A live URL for static builds
A supported static release receives a shareable E-Code address. Server-backed projects remain exportable so you can deploy them with the runtime and hosting workflow they require.
Conversation-led iteration
Ask for a shorter form, a new field, a changed approval rule, or a different route. The agent works from the existing files and keeps every change inside the same project.
An inspectable application project
Every working part stays visible
E-Code keeps screens, code, data connections, Preview, and build output in one project so you can inspect what exists before release.
The demonstration places contact details, appointment history, and the next scheduled reminder state in one customer view.
Connected screens and routes
Turn each step into the right view: lists, forms, records, account areas, administration screens, and the routes that move every user through the application.
Data models you inspect
Review the types, state, adapters, schemas, and queries the generated project actually contains. Add supported database connections through protected project secrets, then inspect their schema before wiring production flows.
Protected project secrets
Store database credentials and runtime values outside prompts and source files. E-Code encrypts saved project secrets and injects them into the workspace when the application runs.
Import, version, and export
Open an E-Code project or import ZIP or GitHub files, keep changes in the project history, and export the current source as an archive when you need another workflow.
Multi-screen preview
Run the application while it is built, inspect complete journeys, and verify layouts at phone, tablet, laptop, and wide desktop sizes before release.
Iteration on the existing codebase
Continue the conversation to change a screen, field, rule, or route. The agent reads the current project and edits the implementation already in place.
Applications shaped around the work
Build the exact tool your users need to complete a job
Each application starts with different records, roles, and actions. The prompt defines that operating model instead of forcing every business into the same template.
Salon booking application
Bring service selection, staff availability, customer records, and appointment changes into one booking journey. Treat account authentication and real email delivery as explicit integrations to implement and test before launch.
Customer portal for a service business
Model request intake, document uploads, progress, deliverables, and team contact in one portal. Define and test authentication and document-access rules in the application code before production.
Inventory and order tracker
Track products, stock movements, suppliers, purchase orders, fulfilment state, and low-stock actions from operational screens built around the real process.
Member area
Organise registration, plans, resources, event access, account settings, and administration for a community, with authentication and authorization kept explicit in the code review.
Practical answers
What happens after you describe the app
You stay in control of the code, data connections, and release decisions throughout the build.
Do I need to know how to code?+
No coding knowledge is required to describe the workflow or request changes. E-Code writes and updates the project files. You still see the code, preview, and build output, and a developer may review or extend the same project whenever you want deeper technical control.
Can I export the source code?+
Yes. The application lives as real project files rather than a locked visual configuration. You review, edit, version, and export those files for your own repository or handoff process.
Where is the application hosted?+
The project runs first in E-Code Preview. The current deployment wizard publishes supported static builds and returns a live E-Code URL. For a server-backed application, export the source and use the runtime and hosting workflow it requires.
Can I connect my existing database?+
Yes. Add a supported connection URL through protected project secrets, never inside the prompt. E-Code detects PostgreSQL, MySQL, MongoDB, and Redis connections and exposes schema inspection and read-query tools. Review and test the application mapping and every write operation before production.
Can I continue from an existing application?+
Yes. Open an existing E-Code project or import the project files, then explain the screen, workflow, or integration you want to add or change. The agent works from the current structure instead of replacing the application with an unrelated starter.
How do I protect users and application data?+
Connection credentials live in encrypted project secrets. Authentication and role enforcement for the generated application remain part of its source code: state the requirements, then inspect and test every generated route and data check before production. A prompt is not a security review.
App Builder for real business workflows
Describe the application your business is missing
Explain the workflow, users, data, and rules in your own words. E-Code turns that context into connected screens, working code, and a project you inspect, run, export, and continue improving.