This roadmap does not represent a guarantee that the features and products will be delivered on the specified dates as described in this document. The delivery dates may change, and features may be added or removed at any time. It is merely an outline of our thoughts for the future, and is subject to change at our discretion.

App Explorer (April 2025)

The App Studio’s user interface and features are finalized. This marks a significant milestone, ensuring that the tools and layout are fully developed and ready for consistent use. Developers can anticipate a stable and polished environment for building and customizing applications.

The finalized App Studio will provide a comprehensive suite of tools, including the App Explorer with optional “table” mode, Live Inspection, Global Search, Background Inspection, Peek Through, and Auto Complete. These features work together to streamline the development process, offering intuitive navigation, real-time feedback, and efficient search capabilities. The April 2025 release will solidify these functionalities, enhancing the user experience for both new and experienced developers.

Powerful features like Live Inspection, Global Search, and the innovative App Explorer revolutionize your development process. Dive into the details and learn more about App Studio 2025 now!

SQL & API Models + Model Builder (June 2025)

The upcoming release of App Studio will revolutionize the data modeling experience for Code On Time developers. We're unifying the "Model >> Controller >> Page" workflow, providing a more intuitive and efficient way to define application data structures. Developers will be able to create sophisticated data models, including those based on APIs and those independent of any database connection, directly within the App Studio. This streamlined approach eliminates the need to switch to the legacy Project Designer for many common tasks.

Every model created or modified will result in the application being re-generated and enhanced with a dedicated data controller and a page that links to it, providing a ready-to-use UI representation of the data. App Studio offers the “Models” hierarchy for viewing model fields and details. The "Legacy" model builder, the primary tool our customers currently use, is being ported to the new App Studio to provide a familiar experience. Accessed through the "Design" option of the model's node in the "Models" tab of the App Explorer, this tool's JavaScript and CSS code is being reused and will benefit from execution in modern JavaScript engines, resulting in higher performance. The "Legacy" Model Builder will be hosted in an <iframe> to isolate it from the App Studio UI and code. It will read and write data through the RESTful API of the App Studio app. For API-driven models, a specialized designer or a set of complex properties will further simplify the process of integrating external data sources. Models without a data source will be transformed into controllers, but these will not have a dedicated page in the application. Instead, developers can choose to use them as "confirmation" controllers for actions within other controllers, allowing for flexible workflow management.

These enhancements will significantly expand the capabilities of Code On Time developers. By enabling the creation of "no-connection" models, we're opening up new possibilities for building applications that operate on diverse data sources. The introduction of API-based models will streamline the integration of external services, empowering developers to create more connected and data-rich applications. The unification of the Model >> Controller >> Page workflow, along with the automated generation of data controllers and pages, will accelerate development cycles and improve overall application maintainability.

Apps + Edit Mode + Assistant (July 2025)

Our main goal over the last year has been to create an intuitive interface and workflow for customizing live applications. To achieve this, we've designed studio toolbars that surround the live application and provide developers with the necessary tools. The upcoming release 8.9.48.0 will focus on app creation and management by introducing the new "Edit" mode to the App Studio and the "Assistant" feature.

Apps

Functionality for the "Apps" button in the top corner will be included in release 8.9.48.0. When selected, the button will display the hierarchy of apps on the developer's workstation. The apps will be organized into groups. Clicking on the project name will take the user to the live instance of the app, with the option to start the application in "Edit" mode.

The app studio's homepage will feature a newsfeed and a list of apps.

“Edit” Mode

"Edit Mode" in the App Studio provides a dedicated environment for developers to modify and manage their applications. Unlike the "Live Mode" which overlays tools on a running instance of the app for direct inspection, "Edit Mode" presents the App Studio web application with the App Explorer permanently docked to the left side of the browser window. This persistent explorer allows developers to navigate the application's structure and access various visual design tools and code editors without needing to inspect elements in a live application.

Upon entering "Edit Mode" (either through a context menu option or when a live app is unresponsive), the App Studio interface overlays on its home page. A familiar top toolbar appears, providing access to common actions, though the "Inspect" button present in "Live Mode" is absent. The main content area of the browser window displays a permanent "Assistant" tab, which serves as a central hub for the newsfeed, change log, and developer tasks. Any previously opened code editors for business rules or the model builder are also visible as persistent, tabbed windows, occupying the remaining screen real estate in a fullscreen manner, contrasting with the modal editors in "Live Mode."

The focus of "Edit Mode" is on direct manipulation and troubleshooting. Developers can visually design UI elements, modify data models, and write or edit business rules within this environment. The persistent App Explorer ensures that the application's structure is always accessible, streamlining the development workflow. To view the application in a running state, developers can use the "Exit to App" button on the toolbar to navigate to the live app in the same browser tab or choose to "Launch" it in a separate tab, facilitating a clear separation between the editing and viewing processes.

Assistant

The Assistant feature in the App Studio is designed to streamline the development process by integrating contextual information and guidance directly into the user interface. Activated by a "magic" button, this panel serves as a dynamic hub, primarily focused on enhancing developer experience by consolidating relevant details, offering helpful tips, and highlighting recently modified elements. As a permanent tab within the "Edit Mode," the Assistant panel will provide a central location for developers to access key information.

A key component of the Assistant is the change log, which meticulously records modifications made within the project, presented in an easily digestible format similar to search results. Each entry in the log provides a snapshot of a specific change, complete with timestamps and property details, enabling developers to trace the evolution of their work. Crucially, selecting an item from the change log allows developers to directly open the corresponding configuration within the App Explorer. This seamless transition between reviewing past work and active modification preserves context and significantly enhances productivity.

Beyond tracking changes, the Assistant proactively guides developers, especially new users, through essential initial setup steps. For instance, upon initiating a new project, the Assistant can identify the absence of a database connection and present a task suggesting its creation. Selecting this task directly opens the relevant configuration within the App Explorer. Similarly, if a database connection exists but no data models are defined, the Assistant will offer a task to create the first model, again providing direct access to the necessary configuration area. This proactive guidance and contextual linking aim to reduce friction, accelerate development, and empower developers to build data-driven applications more efficiently. Furthermore, the Assistant panel will keep developers informed with the latest news and announcements through the integrated newsfeed, ensuring they are always up-to-date with the App Studio and Code On Time, with proactive suggestions, highlights, and newsfeed updates also being visible even when the panel is closed.

App Deployment (August 2025)

In the upcoming release 8.9.49.0 of the App Studio, managing your application's deployment will be a consistent experience across both "live" and "edit" modes. Upon launching a project, developers will find that clicking the "Deploy" button in the top studio toolbar will activate the dedicated "Deployment" hierarchy. In "live" mode, this hierarchy will appear in its own instance docked to the left, while in "edit" mode, it will be accessible as a tab within the left-docked App Explorer. This consistent access ensures that deployment configuration is always readily available alongside your application.

Within the "Deployment" hierarchy, developers will find nodes representing various deployment targets, such as the File System, FTP servers, Microsoft Azure App Service (including production and deployment slots), and future options like Amazon deployment. To initiate the deployment process for a specific target, developers will first select the corresponding node in the "Deployment" hierarchy. They can then trigger the deployment either by clicking a "Deploy" button located within the hierarchy's own toolbar or by choosing a "Deploy" option from the selected node's context menu.

This design centralizes the selection of deployment targets and the initiation of the deployment process within the dedicated "Deployment" hierarchy, accessible via the consistent "Deploy" button in the top toolbar across both "live" and "edit" modes. By providing a clear and focused interface for managing deployment configurations and actions, we aim to simplify and streamline the process of making your customized Code On Time application live and accessible on your chosen platform.

Code On Time v9 (September 2025)

The core features of the legacy Project Designer will be ported to and reimplemented in the App Studio by the end of Summer 2025.

Delivery Schedule

• App Explorer replaced Project Explorer and dedicated configuration pages (April 2025)
• Model Builder will be ported to the App Studio with additional new capabilities (June 2025)
• List of projects will be available on the homepage and within the live apps (July 2025)
• Changes logs will become available within the Assistant pane (July 2025)
• Dedicated deployment hierarchy will allow publishing apps to the file system, FTP, and Azure (August 2025)

This was made possible by our significant investment in the RESTful API. The new universal configuration tool, App Explorer, required over a year of dedicated work. It combines hierarchies and property grids in horizontal and vertical layouts with an optional "table" presentation mode.

App Studio is a Code On Time application. The innovative UI features of the App Studio will be coming to all custom Code On Time applications soon!

Fall 2025

The product version will switch to 9.0.0.0

The legacy Code On Time application will automatically shut down after launching the App Studio instance of Microsoft IIS Express web server at localhost and loading its homepage in the default web browser.

From this point forward, all app development with Code On Time will be done entirely in the web browser.

Community + Help Desk (November 2025)

We are revolutionizing our approach to community support and documentation by deeply integrating them within the App Studio ecosystem. Our new system leverages Google Drive as the central repository for all documentation and user interactions. This allows us to use Google Docs for content creation, benefiting from its powerful editing features, collaborative capabilities, and AI-assisted content generation with Gemini. An in-house "Content Hub" agent automates the process of converting these documents into HTML and publishing them to our documentation site, ensuring a streamlined and efficient workflow.

A key innovation is the way we handle user questions. When a question is posted about a specific property or feature within App Studio, the system automatically creates a corresponding folder and document in Google Drive. This document, initially populated with the property's metadata hint, serves as the foundation for expanded documentation. The user's question is also stored as an "invisible" document within a subfolder, providing crucial context for our team. This tight integration ensures that questions are directly linked to the relevant documentation, facilitating targeted and effective responses.

Our team will monitor the questions within Google Drive, using links provided directly within the public App Studio's chronological question feed. This allows us to see exactly what users are asking and quickly access the source Google Drive document for editing and response. By answering questions directly in Google Drive and optionally expanding the associated documentation, we create a dynamic and evolving knowledge base that directly addresses user needs.

This approach addresses the common problem of knowledge dispersal in traditional forums. By linking questions, extended documentation, and answers within a unified system, we provide a rich, contextualized learning experience. The automatic generation of documentation from metadata, combined with user-driven content, ensures that our resources are accurate, up-to-date, and directly relevant to the challenges developers face.

Ultimately, this integration will significantly reduce maintenance costs, improve the quality and consistency of our documentation, and foster a more engaged and self-sufficient community. The direct feedback loop between user questions and documentation updates will allow us to continuously refine our resources, ensuring they remain a valuable and indispensable asset for Code On Time developers.

.NET Core 9 in v10 (Winter 2026)

.NET Core 9 and .NET Framework 4.8: A Dual-Targeting Strategy for Optimal Deployment

Code On Time is evolving to support the generation of applications for both .NET Core 9 and the traditional .NET Framework 4.8. This dual-targeting strategy allows our users to leverage the benefits of the latest .NET Core technology, including cross-platform compatibility (enabling deployment on Windows, macOS, and Linux) and a modern, modular architecture, while maintaining compatibility with existing infrastructure. The Code On Time app builder will provide an option to select the desired target framework during the application creation process, resulting in optimized output for each environment. While .NET Core 9 generally offers performance advantages, particularly in areas like startup time and memory usage, the impact on overall application performance may vary depending on the specific application's design and database interaction patterns. Applications heavily reliant on database access may see less dramatic performance gains compared to CPU-bound applications, but .NET Core 9's improved scalability and resource utilization can still provide significant benefits.

1234var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => "Hello, Code On Time is coming to .NET Core in Winter 2026!");
app.Run();

Abstraction Layer for HttpContext Compatibility

A key challenge in the transition to .NET Core 9 is the absence of HttpContext.Current. To address this, Code On Time introduces an abstraction layer with AppHttpContextBase and platform-specific implementations (AppHttpContext). The .NET Framework 4.8 implementation wraps the existing System.Web.HttpContext, while the .NET Core 9 implementation utilizes Microsoft.AspNetCore.Http.HttpContext. To manage the context within the asynchronous .NET Core 9 environment, we leverage AsyncLocal<T> in a controlled manner.

Middleware-Driven Context Management in .NET Core 9

In .NET Core 9, the AppHttpContext.Current is populated and managed by a custom middleware component. This middleware, added to the ASP.NET Core pipeline, ensures that the HttpContext is available within the scope of each request. The middleware sets the AsyncLocal<T> at the beginning of the request and clears it at the end, mitigating potential context pollution issues and providing a reliable mechanism for accessing request-specific information.

Optimized Code Generation for Each Framework

Code On Time will dynamically generate code tailored to the selected target framework. This includes:

• .NET Framework 4.8: Code that utilizes the familiar System.Web APIs and the corresponding AppHttpContext implementation.
• .NET Core 9: Code that leverages ASP.NET Core's dependency injection, asynchronous patterns, and the Microsoft.AspNetCore.Http namespace, along with the AsyncLocal<T>-backed AppHttpContext for compatibility.

This ensures that generated applications are optimized for their respective runtime environments.

Long-Term Roadmap: Embracing .NET Core Principles

While initial .NET Core 9 support focuses on compatibility, our long-term roadmap emphasizes embracing .NET Core best practices. This includes promoting dependency injection, minimizing reliance on AsyncLocal<T>, and fully leveraging asynchronous programming patterns. Code On Time will provide tools and guidance to assist developers in gradually modernizing their application code, ultimately leading to more robust, scalable, and maintainable applications.

Code On Time v9 and v10: A New Era of Application Development and Deployment

Code On Time v9 marks a significant leap forward in developer productivity by introducing embedded development tools that enable the customization of live applications directly within the browser. This paradigm shift moves the development environment from traditional Windows-based tools to a more accessible and streamlined browser-based experience, empowering developers of all skill levels to modify and maintain applications with unprecedented ease. Building upon this foundation of enhanced developer flexibility, Code On Time v10 extends the platform's reach to the deployment landscape.

Let’s Go Crossplatform in v11 (Summer 2026)

The app generator will migrate from .NET Framework to .NET Core 9, enabling cross-platform development on Windows, Mac, and Linux. This pivotal transition, which will be reflected in the Code On Time version number as v11, marks the completion of our journey towards full-stack cross-platform capabilities.

Currently, Code On Time's browser-based App Studio provides a modern, web-based development environment, effectively replacing the traditional Windows Forms-based Project Wizard and Project Designer. While this represents a significant step forward, the server-side code of the App Studio still relies on invoking the codeontime.exe command-line executable, which is built on .NET Framework 4.8.

With the release of Code On Time v11, the app generator itself will be upgraded to .NET Core 9. This means that the core tool used to create and configure Code On Time applications will be able to run on any supported platform, including Windows, macOS, and Linux. This eliminates the last remaining dependency on Windows for Code On Time development.

This transition to a cross-platform app generator empowers developers to work on their preferred operating system, streamlining the development workflow and fostering a more unified experience. Combined with the cross-platform deployment of generated applications and the platform-agnostic nature of the client-side code, Code On Time v11 will deliver a truly end-to-end cross-platform solution.

Upcoming Features

The features listed below are standard components currently being developed and will be included in future product releases.

Toolbox

The “Toolbox" button, located in the bottom left corner, activates the Toolbox panel. This panel provides access to Components that facilitate both the creation and transformation of user interface elements within the live UI (displayed in the 'inspection frame') or through the App Explorer. Developers can also activate the Toolbox panel by holding the Ctrl key while performing live inspection.

These Components streamline the process of modifying the application's configuration. For example, when a form view is in focus, the Toolbox will offer Components to create elements such as a virtual field or a custom action button. If a lookup field is inspected, Components to transform the field's behavior or appearance will appear, such as a Component to change the lookup into a radio button list. Additionally, when a form view is active, components may be available to create layout elements, like placing a group of fields into a dedicated category or tab.

To use a Component, developers can either:

• Select it from the Toolbox and then, to indicate where the creation or transformation should occur, either draw or click on the target element in the live UI. This extra click or draw action is necessary when the live inspection frame is not visible. If a UI element is already selected, a single click on the Component will execute its associated action.
• Alternatively, developers can right-click on a node (or a selection of nodes) directly within the App Explorer and choose the 'Toolbox' option from the context menu. This provides the most specific context for selecting an appropriate Component. For example, if several data field nodes are selected in the App Explorer, the Toolbox will present 'Category/Panel,' 'Tab,' and 'Wizard Step' Components. Using these components will add the category to the view and configure properties like 'Tab' or 'Wizard' while also moving the selected data fields into the newly created category.

The selected Component will then create new configuration elements in the application's data controller or modify the properties of existing elements. After the Component's action is complete, the user is transitioned to the App Explorer, where they can further refine the changes and configure related properties. This approach provides a familiar visual development workflow, similar to using a component toolbox in visual IDEs, to accelerate UI customization and make Code On Time's powerful configuration options more accessible.

App View

Use the "App View" button to toggle between the App and API configurations.

The API View in App Studio provides developers with a comprehensive environment for working with RESTful APIs of Code On Time applications. By switching to the API view, developers view the app pages as documentation with the hypermedia and physical data. They can explore and test these APIs directly within the App Studio. The view intelligently determines the relevant API context based on the current page and presents the API documentation and data in a structured format. Live inspection of the API documentation or data will bring up the relevant configuration section in the App Explorer.

Developers can navigate through the API documentation using hypermedia links, and the browser's back button allows for easy navigation of API history. The API Explorer UI can be further enhanced with features like a consistent layout, clear sections, visual hierarchy, and interactive elements. These enhancements make the API View a powerful tool for understanding and working with RESTful APIs in Code On Time applications, streamlining the development process and promoting a deeper understanding of the API's structure and capabilities.

The API View will unlock the power of the RESTful API for developers willing to use Code On Time to build the powerful backend functionality for their custom state-of-the-art user facing applications.

Database Builder

The forthcoming Database tool, integrated into the App Studio, will provide essential functionality for manipulating the database schema directly within the application development environment. This tool will visually represent the application's database schema as an interactive diagram, enabling developers to create new database entities and modify existing ones. The visual presentation of the database schema and its entities within this tool will closely resemble the familiar interface found in the Model Builder, ensuring a consistent and intuitive user experience.

By offering this database schema editing functionality directly within the App Studio, developers will be able to streamline their workflow and make adjustments to the database structure without needing to switch between different tools or environments. This integration is expected to enhance productivity and facilitate a more cohesive development process.

A dedicated Database hierarchy will allow management of tables, views, and columns directly in the application. Changes to the schema will automatically update the models. The relationships between the database entities and data models will be reflected in the respective hierarchies.

The new tool will provide the much needed insight into the database schema directly in the live application.

ACL Editor

Access Control List (ACL), built into the application framework, manages application security by requiring explicit permission assignment for user access to data and features. This default "locked" state ensures that data and features remain inaccessible unless intentionally exposed, enhancing security compared to traditional restrictive methods that may inadvertently reveal information due to changes or updates.

The ACL Editor provides a visual security matrix where developers can assign permissions (rows) to user roles (columns). These default permission-role associations are stored in the acl.json file. During runtime, administrators can create new associations and permissions, which are then stored in the application's CMS. The framework merges the default and runtime ACLs to determine final access permissions. The implementation will take advantage of the App Explorer capabilities.

The App Identity feature will synchronize consumer app ACL with the master ACL defined in the identity provider, further streamlining security management across the application ecosystem.

App Explorer Integration

The App Explorer in the App Studio 2025 consists of the hierarchy of configuration nodes presented as a tree or list and attached Properties Grid. The studio itself is just another app created with Code On Time. The explorer is driven by the metadata and uses the studio’s RESTful API to manipulate data.

Any custom application created with Code On Time includes the client-side libraries of the Tree/ListView and Properties Grid that are part of Touch UI. They also have their own RESful API. The Data Aquarium application framework provides that basis for the server-side code of custom apps. The framework will be extended to dynamically create the metadata compatible with the App Explorer directly from the app’s data controllers. This will become another option for the developers to enhance their own custom apps.

Upcoming Products

The major features and new products that will become available in 2025-2026 are presented next. All of them are enhancements on top of the already existing functionality. Many were prompted by conversations with our customers and are easy to implement. Their aim is to empower developers to find new ways to utilize applications created with Code On Time platform.

Workflow Links

Introducing Workflow Links: The Future of Streamlined Application Interaction

Tired of complex application navigation slowing down your workflows? Code On Time is revolutionizing data interaction with our new Workflow Links feature. Imagine instantly guiding users to specific tasks with intuitive, RESTful-style URLs.

Workflow Links transform your Code On Time applications into a suite of focused, single-purpose tools. Whether it's updating customer data, approving requests, completing surveys, paying bills, or any other task, Workflow Links deliver users directly to the right form, eliminating unnecessary navigation and simplifying the user experience.

Here's how Workflow Links will change the way you work:

• Direct Access, Zero Friction: Workflow Links use clear, RESTful URLs (e.g., /tasks/update-account/AFLK) to take users directly to the task they need to complete. No more hunting through menus or complex interfaces.
• Simplified, Task-Focused UI: When a user clicks a Workflow Link, Code On Time presents a streamlined interface, optimized for the specific task. Distractions are minimized, and users can focus on what matters most.
• Seamless Integration, Maximum Power: Workflow Links aren't just about simplification. They also provide a powerful foundation for workflow automation. Upon form completion, the application executes the "Task" command, and custom business rules handle the post-processing, enabling integration with other systems and driving sophisticated business logic.
• Easy, Flexible Task Management: Define and manage your Workflow Links directly within the Code On Time App Explorer. Our intuitive UI lets you set up URL structures, configure UI customizations, and define post-completion actions with ease. Tasks can be created at runtime to adapt to evolving business needs, and the identifier of the target record can be dynamically calculated using SQL business rules. Workflow Links can be added or modified at any time, even after your application has been deployed, ensuring your app can adapt to changing requirements and user feedback.
• Proactive User Engagement: Enable your applications to guide users directly to specific actions, such as payment forms or information updates, based on reminders or notifications.

Workflow Links empower you to:

• Boost User Productivity: Get tasks done faster with a simplified, direct approach.
• Enhance Data Accuracy: Reduce errors with focused forms and clear workflows.
• Automate Complex Processes: Integrate Code On Time applications into your broader business ecosystems.
• Extend Application Reach: Reach users through email, messaging, and more, with links that work on any device.
• Adapt to Changing Needs: Dynamically create and manage tasks to reflect your evolving business requirements.

Unlock the full potential of your Code On Time applications with Workflow Links – the key to streamlined, efficient, and user-friendly workflows.

Data-Driven Surveys

This new product will make it possible to configure a powerful auditing and inspection system with just two tables. Users can take their surveys offline.

Consider the following database schema that may become a foundation of an auditing or inspection system. The catalog of survey forms is stored in the Surveys table. The definition of a survey is persisted in the JSON format to the Surveys.Definition column.

The results of an audit or inspection are stored in the Audits table row. The column Audits.SurveyID is referring to the survey form. The data collected in the survey form is persisted in the JSON format to the Audits.Response column. The application framework will rely on the input-survey-form and input-survey-data tags to activate the survey form and persist the collected data in JSON format to the database.

Application framework enhanced with the Surveys Add-on will display the progress button for the Audits.Response data field at runtime, when an audit record is shown in the Audit form. The button text will show the progress of the audit. The survey form will be displayed with the previously collected data when the button is pressed. The collected values are persisted as the value of the field marked as input-survey-data when the form is saved.

This is the definition of the survey in the ~/js/surveys/audits/questionnaire1.js file that will be displayed as the form shown above. The new survey definition format was introduced in the release 8.9.29.0 to allow visual customization in the App Studio, which will be possible at design-time and also in production apps with the help of the Surveys Add-on.

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596(function () {

    $app.survey.library['audits/questionnaire1.js'] = {
        text: "Important Questions",
        text2: "Information Request",
        submit: "questionnaire1_submit.app",
        submitText: "Submit",
        description: 'Please answer these important questions. Your prompt response is appreciated.',
        options: {
            materialIcon: "database",
            discardChangesPrompt: false,
            modal: {
                max: "xs"
            }
        },
        topics: [
            {
                questions: [
                    {
                        name: "Name",
                        text: "Full Name",
                        required: true
                    },
                    {
                        name: "Age",
                        text: "How old are you?",
                        type: "number",
                        required: true
                    },
                    {
                        name: "FavoriteColor",
                        text: "What is your favorite color?",
                        items: {
                            style: "RadioButtonList",
                            list: [
                                {
                                    value: "red",
                                    text: "Red"
                                },
                                {
                                    value: "green",
                                    text: "Green"
                                },
                                {
                                    value: "blue",
                                    text: "Blue"
                                }
                            ]
                        },
                        options: {
                            lookup: {
                                nullValue: false
                            }
                        }
                    },
                    {
                        name: "SupplierID",
                        text: "Favorite Supplier",
                        visibleWhen: "$row.FavoriteColor === 'green'",
                        items: {
                            controller: "Suppliers",
                            dataValueField: "SupplierID",
                            dataTextField: "CompanyName"
                        }
                    },
                    {
                        name: "ProductID",
                        text: "Product",
                        visibleWhen: "$row.SupplierID != null",
                        items: {
                            controller: "Products",
                            style: "ListBox",
                            filter: {
                                match: "SupplierID",
                                to: "SupplierID"
                            },
                            dataValueField: "ProductID",
                            dataTextField: "ProductName"
                        }
                    },
                    {
                        name: "Smoking",
                        type: "bool",
                        required: true
                    },
                    {
                        name: "Exercising",
                        type: "bool",
                        required: true
                    }
                ]
            }
        ]

    };
})();

The static surveys are visually designed in the App Studio tools. The dedicated hierarchy will present the surveys detected in the JavaScript files under the ~/js/surveys folder of an application.

The add-on registers custom inputs that will be rendered as values of the form fields tagged as input-survey-form or input-survey-data.

This is the same input extension mechanism used by the Barcode Reader.

If the editable field is tagged as the input-survey-form, then the field value will render as the inline Edit Form button. The survey form will be visually displayed when the button is pressed. The app will enter the development mode. The visual designed for the surveys is based on the Properties Grid used by App Explorer in the App Studio. The Explorer will be powered by the survey building metadata embedded in the Code On Time apps.The design of the survey will be saved as the field value. The read-only field tagged as input-survey-form is automatically hidden.

If the field is tagged as input-survey-data, then its value will be rendered as the survey progress button. The button text will show the progress of the survey form. The survey form is displayed when the button is pressed. The form definition will come from the field of the same data controller that has the input-survey-form tag specified. Typically the form field will be “borrowed” by the Audits data model from the “catalog” of surveys. Application users will be able to save an incomplete survey. The survey is completed when all required fields are entered.

Developers can write client-side and server-side business rules to process the survey questionnaires. The value of the survey response is the JSON object that combines the user answers and statistical information such as the progress and time spent.

Content Hub

Tired of wrestling with documentation, user feedback, and dynamic content in your custom apps?

Code On Time, amplified by our innovative Content Hub, is here to revolutionize your development process. We empower you to build powerful, data-driven applications with unparalleled ease, speed, and flexibility.

Imagine this:

• Seamlessly Integrated Documentation: Your application's help system isn't an afterthought, but a core component. Users get contextual, in-app assistance, reducing support requests and boosting satisfaction.
• Effortless Content Management: Say goodbye to disparate systems. Manage all your content - documentation, blog posts, news, and more - in Google Drive or Office 365, using the tools you already love.
• Dynamic, Engaging Applications: Easily incorporate user-generated content, create interactive helpdesks, and build vibrant community forums directly within your Code On Time apps.
• Future-Proof Flexibility: Our platform delivers your content in multiple formats (HTML, AMP, JSON), ensuring optimal viewing on any device and maximizing your SEO reach.
• Empowered Users, Evolving Applications: Turn your users into active collaborators. Foster a community where they contribute knowledge, provide feedback, and help shape your application's future.
• Rapid Issue Resolution, Increased Trust: Enable users to find answers and solutions quickly through community-driven support, building trust and demonstrating your responsiveness.
• Dynamic In-App Updates: Keep your users engaged and informed with the latest news and discussions, displayed directly within your application's homepage.

Why choose Code On Time with Content Hub?

• Rapid Development: Build sophisticated applications in record time with our low-code, data-driven approach.
• Unmatched Content Integration: Effortlessly weave dynamic content into your apps, creating truly engaging user experiences.
• Reduced Costs: Eliminate the need for separate CMS, forum, and helpdesk systems.
• Total Content Ownership: Store and control your valuable content in your own cloud environment.
• Enhanced User Experience: Provide users with seamless access to documentation, support, and community features directly within your application.
• Collaborative Development: Foster a dynamic ecosystem where users become co-creators, driving application improvement and adoption.

Code On Time with Content Hub isn't just a development tool - it's a complete platform for building and delivering dynamic, user-centric applications.

Serverless Apps

Code On Time will turn an app and its database into a collection of static files ready for deployment to any hosting platform. The App and its data are deployed as a static set of files. Data is serialized in the JSON format. Custom or integrated security with OAuth 2.0 protocol of a Code On Time app is optional.

Custom hook for Sync action will send the client-side objects to any destination specified by the developers. The default Sync handler will persist the changed data objects in XML, CSV or XLSX format to the client device.

Users do not require an online connection to work with the serverless app. The code and data are always offline after the initial download.

Offline Sync core technology will be included with the app frontend to allow the autonomous operation after the initial loading sequence. Developers create an app with a physical database on their workstation and use the app to populate the default dataset.

Applications published as serverless will have the data included. Serverless Apps are perfect for warranty registration, offline questionnaires, personal To-Do lists, etc.

History

See the previous iterations of the v9 roadmap:

• Roadmap 2023-2024
• App Studio (aka v9) Roadmap 2024

This roadmap does not represent a guarantee that the features and products will be delivered on the specified dates as described in this document. The delivery dates may change, and features may be added or removed at any time. It is merely an outline of our thoughts for the future, and is subject to change at our discretion.