Project Lifecycle

Every ioLoop application begins as a Project and evolves through a continuous process of creation, development, testing, publishing, and improvement.

ioLoop brings these stages together within a unified development environment. You can start by describing your idea to AI Wiz, build and customize your application through the Project Editor, test its functionality, and publish it when you're ready.

The Project lifecycle encompasses six key stages:

1. Create — Start a new Project and establish the foundation of your application.
2. Build — Develop the frontend, backend, database, integrations, and AI-powered functionality.
3. Refine — Improve your application using AI Wiz, visual editing, visual programming, and direct code customization.
4. Test — Validate application behavior, data operations, workflows, and user experiences before publishing.
5. Publish & Launch — Make your application available to users through its configured URL.
6. Maintain & Evolve — Continue developing features, improving functionality, and publishing updates as requirements change.

These stages are not a rigid sequence. You can move between development, refinement, and testing as often as needed. Once published, your application continues running while you work on future improvements.

The Project lifecycle is continuous—build, test, publish, improve, and repeat.

Create a Project

Every application in ioLoop starts with a Project. A Project provides the dedicated workspace where your application's frontend, backend, database, integrations, AI Agents, and configuration are developed and managed.

You can create a new Project from the Account Dashboard and open it in the Project Editor, where all aspects of application development come together.

Start with AI Wiz

One of the easiest ways to begin is with AI Wiz, ioLoop's built-in AI development assistant.

Describe the application you want to build in natural language, including its purpose, intended users, key features, and functionality.

AI Wiz can help translate your requirements into a working application, creating and configuring the necessary Project components, such as pages, forms, database tables, application logic, and other supporting functionality.

You don't need to define every detail upfront. Start with your core requirements and progressively expand your application as your ideas develop.

Build Directly in the Project Editor

You can also develop your application directly through the Project Editor, without relying on AI-assisted creation.

Create pages and forms, configure database tables, implement Page Flow and Cloud Flow logic, manage assets, and introduce integrations and AI Agents as needed.

This approach gives you direct control over your application's structure and functionality from the beginning.

You can also bring AI Wiz into the development process at any point to help create new components, implement features, or refine existing functionality.

Establish Your Application's Foundation

As your Project takes shape, you can configure its essential settings, organize application components, and establish the functionality needed for its initial version.

There is no requirement to build everything at once. You might begin with a simple interface and gradually introduce data storage, backend processing, user authentication, integrations, and AI-powered features.

Your Project is the foundation. How you begin—and how you continue building—is entirely up to you.

Build Your Application

Once your Project is created, you can begin developing the features and functionality that bring your application to life.

The Project Editor provides a structured environment where you can build user interfaces, manage data, implement business logic, configure integrations, and introduce AI-powered functionality.

You can develop these components individually or work across multiple areas as your application takes shape.

Develop the Frontend

Start building the experiences your application's users will interact with.

Create pages and forms, design layouts, organize content, and configure navigation and page behavior through the visual editor.

For interactive functionality, Page Flow lets you implement client-side logic using visual programming blocks, JavaScript code blocks, or a combination of both within the same flow.

You can also create JavaScript and CSS assets to introduce custom functionality, reusable code, and advanced styling.

Build the Backend

The backend provides the data storage and server-side functionality that powers your application.

Create database tables to store and manage application information, define fields and queries, and configure access rules.

Use Cloud Flow to implement server-side business logic, process data, expose webhooks, and create background tasks.

Like Page Flow, Cloud Flow supports both visual programming blocks and JavaScript code blocks, allowing you to build backend workflows visually while introducing custom code wherever needed.

Connect External Services

As your application develops, you may need to communicate with external systems.

Through Integrations, you can configure connections to third-party services and APIs for capabilities such as payment processing, notifications, data synchronization, and other external operations.

These connections can be incorporated into your application's frontend, Cloud Flow workflows, and AI Agents where supported.

Introduce AI-Powered Functionality

You can extend your application with AI Agents that provide intelligent, context-aware experiences.

Configure agents with instructions, knowledge sources, functions, and connections to let them interact with application data and perform permitted operations.

AI Agents can also be invoked from Cloud Flow webhooks and background tasks, allowing you to incorporate AI processing into automated backend workflows and build agentic loops.

Configure Users and Access

For applications requiring authentication or different levels of access, configure Project Users, User Groups, and resource permissions.

These controls help you create public experiences, authenticated interfaces, administrative areas, and applications with different functionality for different categories of users.

You can also implement additional authorization checks through application logic and Cloud Flow.

Build Incrementally

You don't need to complete every part of your application before moving forward.

You might begin with a few pages, introduce database tables when persistent data becomes necessary, add Cloud Flow to implement business rules, and incorporate integrations or AI Agents as new requirements emerge.

Throughout development, AI Wiz can help you create components, implement functionality, and extend what you've already built.

Build one feature at a time, or develop across the full stack. Every component remains part of the same Project.

Refine Your Application

Application development is an iterative process. As your Project takes shape, you'll discover opportunities to improve the design, enhance functionality, optimize workflows, and adapt to changing requirements.

ioLoop makes it easy to refine your application without starting over. Whether you're making a small visual adjustment or restructuring complex application logic, you can continue working within the same Project using the development approach that best suits the task.

Evolve Your Application with AI Wiz

AI Wiz remains available throughout the development process, not just when creating your initial application.

You can describe changes in natural language and ask AI Wiz to help implement them across your Project.

For example, you might ask AI Wiz to improve the layout of an existing page, add validation to a form, introduce new database functionality, modify a Cloud Flow workflow, or extend an AI Agent's capabilities.

You can continue refining your requirements through conversation, building upon existing functionality rather than generating an entirely new application.

Refine Visually

The Project Editor lets you make direct changes to your application's pages, forms, and other components.

You can adjust layouts, modify content, update configurations, and fine-tune user interactions through visual editing tools.

For application behavior, Page Flow and Cloud Flow provide visual programming environments where you can inspect and modify existing workflows.

You can rearrange visual programming blocks, change their configuration, introduce additional logic, or incorporate JavaScript code blocks within the same flow.

This gives you the flexibility to make targeted changes without unnecessarily rebuilding functionality that already works.

Customize and Extend with Code

Some requirements call for specialized functionality or more precise control.

You can work directly with JavaScript and CSS assets, modify JavaScript code blocks within Page Flow and Cloud Flow, and implement custom behavior where visual tools alone may not be sufficient.

Because these components remain organized within your Project, you can locate and update the relevant functionality as your application evolves.

You can also use AI Wiz to assist with code modifications, improvements, and new implementations.

Combine Development Approaches

One of ioLoop's key strengths is that AI-assisted development, visual editing, visual programming, and direct coding complement each other.

You might use AI Wiz to introduce a feature, modify its interface visually, fine-tune its behavior through Page Flow, and implement specialized backend processing with Cloud Flow.

These approaches are not mutually exclusive. You can move between them as needed, using the most effective method for each task.

Improve Through Iteration

Refinement often involves repeated cycles of making changes, evaluating results, and adjusting functionality.

As your application becomes more sophisticated, you can revisit existing components to improve usability, strengthen business rules, enhance integrations, and introduce new capabilities.

ioLoop also provides Checkpoints to help manage Project progress during development.

Because development changes are separate from the published application, you can continue refining and testing new functionality before making it available to your users.

Create with AI Wiz. Refine visually. Customize with code. Keep improving without starting over.

Test Your Application

Testing is an essential part of building reliable applications. As you develop and refine your Project, ioLoop lets you evaluate functionality, verify expected behavior, and identify issues before making changes available to your users.

Testing doesn't have to wait until your application is complete. You can validate individual components as you build them, then test how everything works together as your application grows.

Test Pages and User Interactions

Start by exploring your application's pages and forms as an end user would.

Verify that layouts display correctly, navigation works as expected, forms accept and validate input, and interactive elements respond appropriately.

For functionality implemented through Page Flow, test the execution of visual programming blocks and JavaScript code blocks to ensure that interactions, conditional logic, data processing, and other client-side operations behave as intended.

Consider different user scenarios, including valid inputs, invalid inputs, missing information, and unexpected actions.

Validate Database and Backend Operations

Test how your application stores, retrieves, updates, and processes information.

Verify that database operations produce the expected results and that configured access rules are enforced.

For Cloud Flow, exercise your server-side workflows to confirm that visual programming blocks, JavaScript code blocks, and database operations execute correctly.

Pay particular attention to:

• Business rules and data validation.
• Database queries and record updates.
• Webhook request handling and responses.
• Background task execution.
• File processing and data transformations.
• Error handling and unexpected conditions.

Testing these operations helps ensure that your application's backend behaves reliably across different scenarios.

Verify Integrations and AI Agents

Applications that communicate with external services should be tested to ensure that requests, authentication, responses, and error handling work as expected.

For Integrations, verify that configured connections can communicate with their intended services and that your application processes the returned information correctly.

For AI Agents, evaluate their responses, knowledge source usage, function invocations, and interactions with application data.

If your application invokes AI Agents through Cloud Flow webhooks or background tasks, test the complete workflow, including how agent responses are processed and how subsequent operations are executed.

For agentic loops, verify that execution progresses according to your intended logic, handles unexpected outcomes, and terminates appropriately.

When testing integrations or automated workflows, be mindful of operations that may affect external systems, modify data, or trigger real-world actions.

Check Users and Access Permissions

For applications supporting multiple user roles, verify that users can access the resources and functionality intended for them.

Test scenarios involving public visitors, authenticated users, and different User Groups.

Confirm that restricted pages, database operations, Cloud Flow functionality, and AI Agent capabilities respect the configured permissions and authorization rules.

Where necessary, test with different user accounts to ensure that one user's access does not unintentionally expose another user's information or privileged functionality.

Test Complete Application Workflows

Individual components may work correctly on their own but behave differently when combined.

Test complete user journeys that involve multiple parts of your application.

For example, in an event registration application, you might verify that:

1. A visitor can open the event registration page.
2. The form validates the information entered.
3. Cloud Flow processes the registration and checks availability.
4. The registration is stored correctly in the database.
5. An external service sends a confirmation message.
6. The registration appears in the administrator's interface.

By testing the complete process, you can identify issues involving interactions between the frontend, backend, database, and external services.

Refine, Retest, and Prepare to Publish

Testing and refinement go hand in hand.

When you identify an issue, return to the Project Editor to make the necessary changes. You can use AI Wiz, visual editing, Page Flow, Cloud Flow, or direct code modifications to resolve problems and improve functionality.

After making changes, test the affected components again and verify that existing functionality continues to work as expected.

Because development changes do not automatically update the published application, you can continue refining and validating your Project before releasing those changes.

Test as you build. Validate how everything works together. Publish when you're confident your application is ready.

Publish & Launch Your Application

Once you've developed, refined, and tested your application, you're ready to make it available to users.

ioLoop provides an integrated publishing process that lets you move your Project from development to a running application, without having to separately assemble and deploy its frontend, backend, database, and supporting services.

Publishing is a deliberate action, giving you control over when your application—or subsequent changes to it—becomes available to users.

Prepare for Publishing

Before publishing, review your application's configuration and verify that its essential functionality is ready for use.

Depending on your application's requirements, this may include:

• Starting Page: Configure the page that users will see when they open your application's main URL.
• Application URL: Configure the subdomain or supported custom domain through which users will access your application.
• Project Settings: Review application-level settings, branding, and other relevant configurations.
• Users and Permissions: Verify that public visitors, authenticated users, and User Groups have the appropriate access.
• Backend Functionality: Test database operations, Cloud Flow webhooks, background tasks, and business logic.
• Integrations and AI Agents: Confirm that external connections and AI-powered functionality behave as intended.

These checks help ensure that the published application delivers the experience you expect.

Publish Your Project

The Publish area of the Project Editor provides the controls for making your application available to users.

When you publish, ioLoop makes your application accessible through its configured URL, allowing users to interact with its pages, forms, data, and backend functionality according to the permissions and configuration you've established.

Your published application can provide much more than a static website. It can execute server-side logic, interact with its database, communicate with external services, and deliver AI-powered experiences.

Cloud Flow webhooks and background tasks can also support automated operations, including workflows that invoke AI Agents and orchestrate agentic loops.

Development and Published Applications

ioLoop separates ongoing Project development from the published application.

Changes you make in the Project Editor do not automatically update the published version. This means you can continue designing pages, modifying Page Flow and Cloud Flow logic, updating assets, and introducing new functionality without immediately changing the experience delivered to your users.

When your changes are ready, you can publish again to make the updated functionality available.

This separation enables you to continue working on new features while maintaining control over when those changes are released.

Launch and Verify Your Application

After publishing, you can Launch your Project to open the published application through its configured URL.

This allows you to experience the application as its users would and verify that the published functionality operates as expected.

Depending on your application, you may want to verify:

• The starting page and application navigation.
• Public and authenticated user experiences.
• Form submissions and database interactions.
• Frontend and backend workflows.
• Connections to external services.
• AI Agent interactions and AI-powered functionality.
• Access permissions for different User Groups.

Testing the published application is especially important when functionality depends on external integrations, authentication, or server-side operations.

Continue Development After Publishing

Publishing is a milestone, not the end of development.

You can return to the Project Editor at any time to extend functionality, improve the user experience, introduce integrations, modify workflows, or enhance AI capabilities.

With AI Wiz, visual editing, Page Flow, Cloud Flow, and direct code customization, you can continue building upon your existing Project.

As new features are completed and tested, publish your changes to make them available to your users.

This creates a continuous development cycle in which your application remains available while you work on future improvements.

Build and test in development. Publish when ready. Launch with confidence. Keep evolving.

Maintain & Evolve Your Application

Launching your application is an important milestone, but its lifecycle doesn't end there.

As users interact with your application, new requirements emerge, business processes change, and opportunities for improvement arise. ioLoop provides a connected environment where you can continue developing, maintaining, and extending your application throughout its lifetime.

Your Project remains the central place for managing these changes, whether you're improving an existing feature, introducing new functionality, or adapting your application to growing demands.

Continue Improving Your Application

After publishing, you can return to the Project Editor to make changes and introduce enhancements.

You might want to:

• Improve page layouts and user experiences.
• Add new pages, forms, and interactive features.
• Extend database structures and application functionality.
• Refine Page Flow and Cloud Flow logic.
• Introduce additional integrations and external services.
• Enhance existing AI Agents or build new ones.
• Update application settings, permissions, and configurations.

You can make these improvements using AI Wiz, visual editing, visual programming, or direct code customization.

Because your application remains organized within the same structured Project, you can continue building upon existing components rather than starting over.

Maintain Application Functionality

As your application evolves, it's important to ensure that existing functionality continues operating as expected.

Regular maintenance may involve reviewing database operations, checking backend workflows, validating integrations, and verifying access permissions.

Applications that use Cloud Flow background tasks, webhooks, and AI Agents may also require periodic review to ensure their automated processes continue producing the expected results.

When external services change their APIs, authentication requirements, or behavior, you can update the corresponding connections and application logic.

You can also use AI Wiz to help investigate issues, implement improvements, and refine existing functionality.

Adapt to Growing Requirements

An application that starts with a small set of features may eventually need to support more users, larger datasets, additional workflows, or more sophisticated business processes.

ioLoop allows you to progressively expand your Project by introducing capabilities as they become necessary.

You might add user groups to support new roles, introduce Cloud Flow automation to streamline operations, connect additional business systems, or implement AI Agents to deliver intelligent functionality.

The Scale area provides controls for managing application resources and capacity according to your requirements and available plan options.

This flexibility allows your application to evolve alongside the needs of your users and organization.

Manage Changes and Updates

As you continue developing your application, maintaining control over changes becomes increasingly important.

ioLoop's separation between development and publishing allows you to work on improvements without automatically changing the live application.

You can develop new functionality, test modifications, validate complete workflows, and publish updates when they're ready.

Checkpoints provide an additional mechanism for managing development progress and tracking important stages of your Project.

This approach supports an ongoing cycle of improvement while giving you control over when changes become available to users.

A Continuous Development Lifecycle

The lifecycle of an ioLoop Project is not a one-time journey from an idea to a published application.

It is a continuous process of building, refining, testing, publishing, and improving.

As your application's requirements evolve, you can return to any stage, introduce new capabilities, and continue developing within the same Project.

Whether you're maintaining a simple internal tool or expanding a sophisticated business application, ioLoop provides the flexibility to keep moving forward.

Create. Build. Refine. Test. Publish. Evolve. Repeat.

Where to Go Next

Ready to put these concepts into practice? Explore the following documentation to begin building and managing your applications.

• Account Dashboard — Create, organize, and access your Projects.
• Project Editor — Learn how to develop applications using ioLoop's visual tools, programming environments, and AI Wiz.
• Platform Capabilities — Explore the full range of features available for building your applications.
• Core Concepts — Familiarize yourself with ioLoop's terminology and foundational concepts.