Appearance
Core Concepts
This guide defines the principal concepts used throughout ioLoop and shows how they relate. Follow the links for complete configuration, development, testing, security, and publishing guidance.
Accounts, Projects, and Applications
Account
An ioLoop account owns Projects and provides the administrative context for profile information, billing, subscriptions, and Creators. The Account Dashboard is the central place for managing these account-level concerns.
An Account is not the same as a Project, and an account administrator is not automatically an application user.
Project
A Project is the structured workspace for an application. It brings together the application's frontend, data, server-side logic, AI capabilities, integrations, users, settings, and publishing configuration.
My Projects contains Projects owned by the current account. Shared with Me contains Projects owned by other accounts that have granted the current Creator access.
Published Application
The published application is the released version of a Project used by its visitors and Project Users. Development changes do not automatically alter this version. A Creator releases applicable saved changes through Publish Project and opens the result through Launch Project.
People and Permissions
Creator
A Creator is a collaborator who works on Projects through the Project Editor. Project-specific Creator permissions include:
| Permission | Meaning |
|---|---|
| Viewer | Can inspect the Project but cannot modify or publish it. |
| Contributor | Can inspect and modify the Project but cannot publish it. |
| Publisher | Can inspect, modify, and publish the Project. |
An account-wide Publisher receives read, write, and publish access across the account's Projects. Creator access is separate from account administration and from access inside the published application.
Project User
A Project User is a person or system identity that can authenticate to the application produced by a Project. A Project User can have credentials, status, contact information, User Group membership, role levels, and a Web Hook Key.
Creating a Project User does not grant Project Editor access. Adding a Creator does not create a Project User account.
User Group
A User Group is a reusable application identity used by Access (Security) settings. Project Users can belong to custom groups at assigned role levels, and resources can require a particular group and minimum level.
The built-in access identities are:
| Identity | Meaning |
|---|---|
| Public (No Password) | An unauthenticated visitor. |
| All Users | Every authenticated Project User. |
| Custom Groups | Project-defined audiences or responsibilities such as Customers, Support, or Finance. |
| Admin | Project Users granted broad application-administrator access. |
Application Admin is not the same as an account administrator or a Creator with Publisher access.
Role Level
A role level is an ordered level within a User Group. When a resource requires a group at a particular level, users with that level or a higher level in the same group satisfy the rule. A role level in one group does not carry into another group.
Web Hook Key
A Web Hook Key is a credential associated with a Project User. Supported external requests can send it in the HTTP Authorization header using the Bearer scheme. The request receives the associated user's group and role context; the key does not bypass the Web Hook's own access rules.
The Project Editor and AI Wiz
Project Editor
The Project Editor is the main development environment for a Project. It organizes work into Frontend, Backend, AI Agents, Integrations, Scale, Settings, and Publish.
These areas are different views of one application. A Page can collect input, Page Flow can coordinate the browser experience, Cloud Flow can enforce trusted rules, the Database can store records, and Connections or AI Agents can extend the workflow.
AI Wiz
AI Wiz is ioLoop's AI development assistant for Creators. It can explain a Project and create or modify supported Project components from natural-language requests.
AI Wiz works with the same structured resources available in the Project Editor. Its changes remain editable through the corresponding visual or code-based tools. AI Wiz does not become part of the published application, does not publish the Project, and does not expand the current Creator's permissions.
AI Wiz is different from an AI Agent:
| Capability | Role |
|---|---|
| AI Wiz | Helps a Creator build and maintain the Project. |
| AI Agent | Provides AI-powered behavior inside the application or an automated workflow. |
Frontend Concepts
Frontend
The Frontend is the user-facing portion of a Project. It includes Pages and Forms, visual content, browser-side behavior, Media, and reusable JavaScript or CSS Code assets.
ioLoop frontends use standard HTML, CSS, and JavaScript. See Standards-Based Frontend for how visual tools, Page Flow, Code assets, and the Client API work together.
Pages and Forms
Pages & Forms contains the primary user-interface resources:
| Resource | Meaning |
|---|---|
| Page | A user-facing application screen managed as one content structure. |
| Form | A specialized Page for collecting and validating input, commonly opened as a modal workflow. |
| Structured Page | A Page assembled from independently managed Page Slices. |
| Page Slice | A reusable section that can participate in Structured Pages, such as a shared header or footer. |
Page Settings controls an individual Page or Form's active state, URL, access, metadata, fonts, Code inclusion, and advanced presentation settings.
Page Editor
The Page Editor is the visual environment for arranging and configuring the content of Pages, Forms, and Page Slices.
The editor manages content and layout. Browser-side behavior is added through Page Flow, while reusable JavaScript and CSS can be maintained under Code.
Page Element
A Page Element is a visual building block placed in the Page Editor. Elements include layout containers, text, media, navigation, buttons, tables, cards, form controls, and Widgets.
The Element Library provides available elements. Element Settings controls the properties of the selected element.
Widget
A Widget is a specialized Page Element with configured application functionality. Important Widget types include:
- Data Table Widget for interactive Database records.
- AI Agent Widget for conversations with a configured AI Agent.
- Payment Widgets for supported payment experiences.
- Display and Utility Widgets for focused application and account-related functions.
A Widget can depend on other Project resources. Adding a Widget does not automatically create or authorize its Database table, AI Agent, Connection, or user access.
Data Design and Placeholders
A Data Design is a reusable visual layout for one dynamic item. The same design can be rendered repeatedly with different values.
Placeholders identify the text, image, link, or other values supplied when the Data Design is rendered. Data Design controls presentation; it does not independently retrieve or authorize the data being displayed.
Page Flow
Page Flow defines browser-side behavior for a Page or Form. It responds to startup and user events, works with elements and Widgets, opens Forms, performs supported Database operations, calls Web Hooks or Connections, and updates the interface.
Page Flow supports visual blocks and JavaScript:
| Construct | Purpose |
|---|---|
| Visual block | Represents a supported event, value, action, or operation. |
| Custom Code block | Executes focused JavaScript statements within the flow. |
| Code Expression block | Evaluates JavaScript and supplies a value to another block. |
Page Flow runs in the user's browser. It must not be the only enforcement point for secrets, record ownership, or other trusted authorization.
Frontend Code
Code contains reusable JavaScript and CSS assets for Pages and Forms. A Code asset must be included at the Project or Page level before it is loaded.
Frontend JavaScript is delivered to the browser and should be treated as inspectable. Keep credentials and trusted business rules in appropriate Backend functionality.
Media
Media is the Project library for public frontend files such as images, videos, PDFs, logos, and social-sharing assets.
Media URLs are publicly accessible. Restricting the Page that displays a file does not make the Media URL private. Use Database-backed file workflows and Backend controls when files require authorization.
Preview
Preview runs the saved development version of a Page or Form inside the Project Editor. It helps test layout, navigation, Page Flow, Forms, Widgets, access contexts, and connected operations before publishing.
Preview does not publish. Built-in Database operations during Preview use development data, while external services can still have real effects depending on their configuration.
Backend and Database Concepts
Backend
The Backend contains the Project's structured data and trusted server-side behavior. It has two principal areas: Database and Cloud Flow.
Database
The Database stores structured Project data and defines how it can be retrieved or changed.
| Concept | Meaning |
|---|---|
| Table | A collection of records representing one application concept, such as customers or orders. |
| Field | A named value stored in every record according to a configured type and settings. |
| Record | One stored item in a table. |
| Named Query | A reusable definition for selecting, joining, sorting, and shaping records. |
| File Field | A field that associates uploaded or generated files with a Database record. |
Table Access
Table Access controls which Project Users and User Groups may view, add, modify, or delete records through supported runtime interfaces.
Table Access is independent of Page Access. A user being allowed to open a Page does not automatically grant permission to the data used by that Page.
Development and Production Data
ioLoop separates development and production data:
| Environment | Purpose |
|---|---|
| Development data | Records used while building and testing the Project. Built-in Database operations during Preview use this environment. |
| Production data | Records used by the published application. |
Publishing applies table definitions and related configuration to production. When a corresponding production table is empty, its development records are copied into it. Development records are not merged into or used to overwrite a production table that already contains records.
Cloud Flow
Cloud Flow is ioLoop's server-side workflow and programming environment. Use it for protected credentials, trusted authorization, business rules, Database operations, files, Connections, AI Agents, and processing that should not depend on an open browser.
The Cloud Flow Editor supports visual blocks, Custom Code, and Code Expression blocks for server-side logic.
Web Hook
A Web Hook is a Cloud Flow module that receives an HTTP request, runs server-side logic, and returns an HTTP response. Pages, custom frontends, external applications, and external services can call Web Hooks.
A Web Hook has its own Access (Security) configuration. Allowing a request to enter the Web Hook does not automatically authorize every record or action requested by the caller.
Background Task
A Background Task is a Cloud Flow module for server-side functionality that is not exposed as an HTTP endpoint. Its execution and scheduling behavior are defined by the logic implemented inside the module.
Background Tasks can also initialize shared helpers used by other Backend modules.
Flow Share
Flow Share provides named runtime values, objects, and functions that supported flows can share. It is useful for reusable Backend helpers and module coordination.
Flow Share is runtime state, not durable application storage. Persistent business data belongs in the Database or another appropriate storage system.
Test Runtime and Logs
The Cloud Flow development test runtime runs saved development Cloud Flow for testing. It is separate from the published runtime.
Test and Live Logs help distinguish development activity from published application activity and diagnose Backend behavior through the actual invocation path.
Integration Concepts
Integration and Connection Service
An Integration connects a Project with an external provider, API, credential set, or supported tool.
A Connection Service defines the provider-specific authentication, settings, operations, and supported Project interfaces. Services include general API connections, credential storage, communications providers, payment providers, business platforms, AI providers, and MCP servers.
Profile
A Profile stores the authentication or authorization information used with a Connection Service. Depending on the service, it can contain API credentials, OAuth authorization, account identifiers, or other provider-specific settings.
Profiles can be reused by multiple Connections. A Profile is shared by development and published Connections that reference it, so changing its credentials can affect both environments without waiting for another Project publish.
Connection
A Connection is a named Project resource that combines a Connection Service, a Profile, Connection-specific settings, and Access (Security) rules.
Connections can be used by supported Page Flow, Cloud Flow, Widgets, custom code, and AI Agent Knowledge Sources. Creating or changing a Connection affects development first and must be published when the change needs to reach the published application.
MCP Server Connection
An MCP Server Connection connects a Project to a remote Model Context Protocol server. Its tools can be made available to supported AI Agent functionality and trusted Backend workflows according to the Project's configuration.
AI Agent Concepts
AI Agent
An AI Agent is an application capability that combines a provider Connection, instructions, model configuration, Knowledge Sources, optional Prompt Library entries, and Cloud Flow functionality.
An Agent can be used interactively through an AI Agent Widget or invoked headlessly from trusted Cloud Flow. Client access and trusted Backend invocation have different security boundaries.
Knowledge Source
A Knowledge Source defines information, data, or a tool an AI Agent can use. Major types include:
| Type | Purpose |
|---|---|
| File | Supplies uploaded reference material to the Agent. |
| Database Table | Gives the Agent configured operations on a selected Project table. |
| Custom Function | Describes a Project-defined tool whose implementation is provided in the Agent's Cloud Flow. |
| Connection | Makes supported operations from a configured Connection available to the Agent. |
| MCP Server | Makes supported tools from an MCP Server Connection available to the Agent. |
Adding a Knowledge Source expands what the Agent can retrieve or do. It does not remove the need for access controls, input validation, operation authorization, and side-effect review.
AI Agent Cloud Flow
Every Agent has an AI Agent Cloud Flow module. It implements Custom Function Knowledge Sources and supported callbacks that customize Agent behavior.
Prompt Library
The Prompt Library provides reusable prompts that help users begin common Agent tasks. Prompt Library entries are user-interface conveniences; they do not replace Agent instructions or grant additional permissions.
Interactive and Headless Invocation
Interactive invocation uses an AI Agent Widget to provide a conversation within a Page.
Headless invocation calls an Agent from Cloud Flow without an interactive Widget. A Background Task, Web Hook, or another Agent module can initiate the work. The calling workflow must enforce the authorization appropriate to its own entry point and requested operation.
Run Logs and Generated Files
Run Logs record supported Agent execution activity for review and troubleshooting. Generated files are outputs retained by supported Agent capabilities and managed separately from ordinary Project Media.
Access and Security Concepts
Authentication and Authorization
Authentication establishes who a caller is. Authorization decides whether that authenticated caller may perform the requested action.
A valid sign-in or Web Hook Key proves an accepted identity; it does not grant permission to every Page, table, Connection, Web Hook, Agent, record, or business operation.
Access (Security)
Access (Security) is the resource-level configuration that selects the Project User identities or User Groups permitted to use a resource or operation.
Access is layered across the Project:
| Boundary | Authoritative Guide |
|---|---|
| Page or Form | Page Settings |
| Database table operation | Table Access |
| Connection operation | Connection Access |
| Web Hook invocation | Cloud Flow Access Security |
| AI Agent client access | Managing and Testing AI Agents |
These rules do not automatically propagate. A protected Page can still call an inadequately protected Backend operation, and an allowed Web Hook caller can still be prohibited from modifying a particular record.
Public Access
Public access permits use without Project User authentication. Use it only when the resource and every exposed operation are intentionally available to unauthenticated visitors.
Public access to one operation does not require other operations on the same resource to be public. For example, a table can permit public creation for a registration Form without permitting public reads or updates.
Record-Specific Authorization
Record-specific authorization determines whether the current caller may act on a particular record, such as allowing a customer to update only their own order.
Resource-level access does not automatically enforce ownership or other record-specific business rules. Use trusted Backend logic when the decision depends on the caller, target record, current status, or other server-side information.
Least Privilege
Least privilege means granting only the access, operations, fields, tools, and role level required for the intended workflow. Apply it to Project Users, Creator permissions, tables, Connections, Web Hooks, AI Agents, provider scopes, and returned data.
Project Configuration and Operations
Project Settings
Project Settings controls Project-wide publishing, identity, appearance, authentication, included Code, and advanced application behavior.
Starting Page
The Starting Page is the active Page opened at the root published address. A Starting Page is required for publishing and must be included in the successful release.
Project URL and Custom Domain
The Project URL is the ioLoop-hosted address configured for the published application. A Custom Domain is a supported non-apex domain such as app.example.com.
Saving either setting does not activate the address. The Project must be published, and a custom domain also requires its DNS record and HTTPS provisioning to complete.
Checkpoint
A Checkpoint preserves a meaningful point in supported development configuration. It can be inspected and used to roll back that configuration.
Checkpoints are not backups of Database records or Media. A rollback changes development configuration; publishing that restored configuration can subsequently affect production structures and records.
Scale
Scale controls the runtime capacity assigned to a Project. Scaling changes available application resources; it does not modify Page design, business logic, or data permissions.
Saving, Testing, and Releasing
The development lifecycle uses separate actions:
| Action | Meaning |
|---|---|
| Save | Record a change in the Project's development state. |
| Preview | Run a saved Page or Form in the development context. |
| Start Test | Make the Cloud Flow development test runtime available for independent Backend testing. |
| Publish Project | Release applicable saved development changes and update the published application. |
| Launch Project | Open the published application for verification. |
Publishing is an application release, not merely a Page upload. It can affect active Pages and Forms, Code, Project Settings, Database structure, Cloud Flow, Connections, AI Agents, access rules, URLs, and domains. The application is temporarily inaccessible while publishing is underway.
For the complete workflow, see Project Lifecycle, Previewing, and Publish.
Programming Concepts
Frontend Programming
Frontend Programming covers browser-side implementation through Page Flow and the Client API.
The Page Flow Blocks reference documents ioLoop-specific visual blocks. The Client API provides supported $io interfaces for custom frontend JavaScript.
Backend Programming
Backend Programming covers trusted server-side implementation through Cloud Flow and the Server API.
The Cloud Flow Blocks reference documents ioLoop-specific Backend blocks. The Server API provides supported $io interfaces for Cloud Flow Custom Code.
Result Object
A Result Object is the standard success-or-failure value returned by many ioLoop blocks and APIs. It commonly contains a status, returned data, and error information. Page Flow and Cloud Flow should inspect the result rather than assuming an asynchronous operation succeeded.
See the Page Flow Result Objects and Cloud Flow Result Objects references for their respective environments.