Roadmap 2017 / 2018

See what's coming next for Forms, Reports, Apps.
Build and deploy rapidly. Use offline, online, on-premises.

Roadmap 2017/2018 | 2016 | 2015

Touch UI (February 2018)

We have made an enormous investment in creating a mobile- and desktop-friendly user interface called Touch UI. The purpose is to enable RAD implementation of apps that are friendly to both mouse and touch-enabled devices. We have spent close to 2 years working on perfecting this exciting technology. A few remaining features are being finalized as we speak. This is a summary of features that are expected to be fully completed in October/November of 2016.

Keyboard Shortcuts for Actions Completed in Release

Developers will be able to define keyboard shortcuts for each action. For example, configure Ctrl+S to trigger the Update action on a form, or Esc to trigger the Cancel action to close the form.

Advanced Search and User Defined Filters Completed in Release

The new Advanced Search will utilize survey controllers to allow the use of our suite of powerful field inputs. Type-specific field filters will integrate with the new Advanced Search and permit the user to rapidly add and customize search operations via shortcuts in the user interface.

Quick Find Enhancements Completed in

The developer can limit the scope of Quick Find queries by adding “$quickfind” to the Search Options of a field. Completed in

Users will be able to interactively select fields defining the scope of Quick Find. Presently, Quick Find includes all fields in the query.

Quick Find will show a panel below that displays suggestions based on known values from the currently displayed rows, as well as previous searches. Quick Find will also support operations (for example, UnitPrice>=10). The panel will also defining the search scope to limit the query to a specific set of fields from the main data view or relevant child data views.

Rich Text Completed for Release (July)

Enable the editing of HTML content across all devices in an easy-to-use fashion. Learn more

Inline Editing Scheduled for Release (February 2018)

The ends users will be able to edit data directly in the grid, list, or cards, exactly in the same fashion as editing is done in forms. Complex data fields such as radio button lists or checkbox lists will be displayed in popups in order to preserve the layout of the view.

Drawers in List/Card/Grid Scheduled for Release (February 2018)

An optional form layout can be defined for list, card, and grid items. The end users can expand any number of rows/items at runtime if a drawer form is defined for the “grid” view. Drawer forms may contain tabs, categories, and fields of any type including “data view”.  The data view fields in drawer forms may also have their own drawer layouts, which enables infinite master-detail relationships and hierarchies. This type of presentation is frequently called “grid-in-grid”.

Data view fields configured to display charts or maps can be placed in the drawer layout in order to provide complex dashboards for each row/item presented to the user.

If a memo, image, or data view field is present in “grid1” and no custom layout is defined, then the field will not be displayed as column. Instead, a drawer form will be created to display all such fields.

List and Cards view styles will have automatically created “drawer” layouts for data view fields.

These presentation styles will also support custom templates to define the layout of list item or card. If a custom definition is not provided, then an automatic item/card layout will be created.

Hyper-scrolling Scheduled for Release (February 2018)

The grid, list, and card view styles will offer a vertical scrollbar with the ability to scroll to an exact location in the data. A floating tooltip will be displayed showing the row numbers that will be loaded when the user releases the scrollbar. When “Search By First Letter” is enabled for the data view, the scrollbar will represent letters in the alphabet. The tooltip will show the first letter at the current position.

Client-side Manipulation of Grid Scheduled for Release (February 2018)

The user will be able to rearrange, resize, and hide columns in the grid view. These customizations will be saved in the cache of the user’s browser.

Group Aggregates Scheduled for Release (February 2018)

Groups defined by the developer or user will display counts, sums, and any other aggregates configured in the Project Designer. Groups will also be collapsible.

Paging in Forms Scheduled for Release (February 2018)

Forms will allow paging/swiping between records and work interchangeably with grid/list/cards.

Notifications Completed in Release (December 2017)

Slide-in notifications are displayed in response to many actions, such as Update, Insert, Delete, Search, Sort, etc. The flow of user interaction with the application is not interrupted while providing confirmation of user actions. Learn more

Tab Bar Completed in Release (December 2017)

Tab Bar provides convenient access to the most frequently used pages of your app. Tabs are displayed at the bottom of the screen. Learn more

Multi-File Upload Scheduled for Release (December 2017)

A new command "Upload" allows users to select multiple files. Application framework automatically initiates a series of Insert/Upload actions in the view with BLOB fields without user involvement.

Search-by-Form Scheduled for Release (February 2018)

If search is activated in the form view, then the form will switch into a special search mode. Values entered in the fields will be used as "equals" criteria to search. Form buttons will be replaced with "Search" and "Cancel".

Promoted and Swipe Actions Scheduled for Release (February 2018)

Promoted actions that will be displayed under the floating “promo” button displayed in the bottom left or right of the screen. Swipe actions will be triggered or displayed when a user swipes left or right in grid, list, or card view. Swiping gestures will enable navigation between data rows displayed in forms.

Re-Authorization for Sensitive Data

A single tag will require the user to re-confirm their identity before they can edit or submit a form, even if the user has already logged in.

One-to-One Relationship

Three new lookup item styles will be introduced: "OneToOne", "OneToOneLookup", and "OneToOneAutoComplete".

These lookups will behave like their counterparts, "Lookup" and "Complete", with one exception:

When the entered text is not matched to an equivalent lookup value, the value will remain as-is. The user interface will not display the "Create New" option. Instead, the lookup value will be processed on the server. The generic server-side handler will insert or update to the lookup controller as necessary. "Borrowed" fields specified in the Copy property will be included in the update or insert expression. The "Upsert" will execute in the context of a database transaction.


With the above features completed, Touch UI becomes a world-class framework that works across all browsers and devices, and covers a vast number of use cases when creating line-of-business web applications of any complexity. Our unparalleled data input user interface allows your users to get their jobs done easier and faster.
Back to Top

SaaS  (Oct 2017)

SharePoint Online, Google, Facebook, Windows Live Completed in Release

Code On Time and Cloud On Time apps will offer the ability to run in Software-as-a-Service (SaaS) mode, allowing developers to bring their web apps into other popular portals and products such as Office 365, SharePoint, Google Apps, and DotNetNuke.

SaaS feature will have to be enabled on the application level. We will provide themes to match several hosting environments. The server components of apps will respond to requests from authorized hosts in SaaS mode.

Native connector components (web parts, modules, etc.) will be provided for popular portals. Native component will require a registration key from the SaaS-enabled application for configuration. The live portal page of the hosting environment will connect to the SaaS-enabled app running on your server.

A connector instance on the portal page will perform requests to an externally hosted Code Time or Cloud On Time application. The connector will communicate the user identity, roles, and registration key to the app. The app will validate the registration key, perform single sign-on, and display the application content in the portal page.

DotNetNuke Completed in Release

A native DNN component will be implemented to operate as an Open Authentication provider. It will be able to confirm user identity and serve roles and tokens as claims to client applications. An Open Authentication Handler compatible with the DNN provider will be included in Code On Time apps to allow using DNN as a source of user identity.


Developers will be able to integrate their applications into 3rd party products and popular portals.
Back to Top

Native Apps Scheduled for (Dec-Feb)

Currently, users can access applications created with Code On Time via their web browser. These applications offer a responsive touch-friendly user interface accessible from all modern touchscreen or mouse-enabled devices. The user can also choose to add the site as a “web app” on their home screen. Our customers have successfully created lightweight native wrappers for mobile devices using tools like PhoneGap and Xamarin. We certainly want to make it easy to create true native hybrid apps produced by the app generator without the need for third-party tools. Application generator will create custom native apps for iOS, Android, MacOS, and all modern variants of Windows including Windows 7, Windows 10, and Windows 10S.

In a world where apps are everywhere, it makes sense to package your application in a native shell on all platforms, be it Windows, iOS, or Android. Such shell must not merely provide a custom online browser. The shell must host a local set of client-side application files while using the server components of the app to read and write data. This will not only increase speed of page loading (all required files are already on the device), but will also enable access to the device equipment and make it possible to work in a disconnected mode.

Users working on mobile devices will have two new options to access applications deployed to the web server.

Universal App

We will provide a native application for major mobile platforms available through the respective app stores to instantly try and work with a deployed application on a mobile device. The user will first install the universal app to their device. Then, they will connect to the application on the web and sign into their account. The universal app will detect successful sign-in and transfer JavaScript files, HTML pages, CSS, images, and font resources to the local device in the correct language and user interface culture. The connected app will display as a “cloud” in the menu of the universal app. If a cloud is selected, then the device navigates to the locally stored pages and the pages will connect to the remote app to read and write data. Multiple application clouds can be registered within the same universal app, including those on your local development machine.

This will be the fastest way to give your end users a native experience as soon as you deploy your application. Clouds will also work in “always offline” mode in applications with Offline Sync Add-On.

A “cloud” has the following components:

  • An application created with “Code On Time” deployed to a web server.
  • Local copy of HTML, CSS, JS, images, and fonts on the native device.
  • Data controllers in JSON format in “always offline” mode on the native device.
  • Raw data in JSON format in “always offline” mode on the native device.

Custom Apps

If you want to have a custom native app available in an app store, then you must setup a developer account, confirm your identity, pay registration fees, which may take a few days.

The app generator will offer an option to generate a customized and branded Custom App for projects created with Code On Time. This Custom App will be a variant of the Universal App but capable of only running your cloud. Developers will have the choice to get a compiled version of the Custom App, or download its source code for further customization and development.

Both Universal and Custom Apps will deliver “native experience” for your end users in a form of hybrid mobile app connected to the application on a web server.

“Native Experience” Delivery Pipeline

We are planning to offer the following deliverables to enable “native experience” for your end users.

  • UMA-W7 - universal app compatible with Windows 7 based on embedded Chromium browser to run multiple clouds.
  • UMA-W10 - universal app compatible with Windows 10, Windows 10S based on native WebView to run multiple clouds.
  • UMA-iOS - universal app compatible with iOS 11 based on native WebView to run multiple clouds.
  • UMA-Android - universal app compatible with Android based on native WebView to run multiple clouds.
  • UMA-Mac OS - universal app compatible with Mac OS based on native WebView to run multiple clouds.
  • CMA-W7 - custom branded app compatible with Windows 7 based on embedded Chromium browser to run a single cloud.
  • CMA-W10 - custom branded app compatible with Windows 10 based on native WebView to run a single cloud.
  • CMA-iOS - custom branded app compatible with iOS 11 based on native WebView to run a single cloud.
  • CMA-Android - custom branded app compatible with Android based on native WebView to run a single cloud.
  • CMA-Mac OS - custom branded app compatible with Mac OS based on native WebView to run a single cloud.

Over the past years, we have developed multiple prototypes for native apps on various platforms. Some of them were based on PhoneGap. Some of them were native applications. We have evaluated wrapper WebViews running the online site directly from the web server but rejected the idea since it makes it impossible to create a cross-platform solution working in a completely disconnected mode. A true offline mode requires application files and data to be located on the device. We have decided to provide a single solution for both online and offline mobile users and selected an architecture that places core framework files on the device (HTML, JavaScript, CSS, images, fonts) and optionally downloads application data to be stored locally.

As of release, we have introduced the following changes in the application framework:

  • Every application can respond with a manifest of static resources that must be downloaded from the server to the local storage of the native app.
  • We have modified the folder structure on the server to be compatible with native apps. Folders with HTML, JavaScript, CSS, fonts, image files are transferred to exactly the same relative locations on the device.
  • We have developed a host API implemented in JavaScript to perform transfer of server resources and data to the client.
  • Universal Mobile App for Windows (UMA-W7) has been developed and is capable of providing the host API with additional native features (file management, HTTP requests)
  • UMA-W7 is based on Chromium browser for superior performance on all Windows platforms. A Wix-based installer has been created to provide smooth installation of UMA-W7 on Windows platforms.
  • We have also implemented Universal Mobile App for Windows 10 (UMA-W10) to match file management and HTTP request capability on UMA-W7.
  • The JavaScript host API is shared on both UMA-W7 and UMA-W10. The same API will be used on all other mobile platforms.
  • We have reimplemented culture-specific globalization explicitly in JavaScript files located at ~/js/sys/culture folder for both online and native clients.

For the foreseeable future, here are the targeted milestones:

Go Live for UMA-W7, UMA-W10 (Release Dec 7

Presently, we are working on the following items for UMA-W7 and UMA-W10:

  • Native hybrid application pages are loaded in a local WebView from the file system of the device. It is not possible to track user session with the help of cookies. Instead, we are implementing identity and session handling for native apps via a variable passed in the header of each HTTP request created when the user is signed into the app during installation of the cloud.
  • Uploading of binary large objects must be implemented via the native application since WebViews do not provide an option to run custom code when binary submission has been completed for security reasons in pages loaded from local file system. We are implementing uploading via the host application when BLOBs are submitted.
  • Localization of resources in native apps will be performed on the client by merging local culture resources with HTML pages.
  • A theming engine requires an alternative implementation in native apps to add accent processing for themes without making a request to the server.
  • Universal Mobile App (UMA) will allow registering multiple clouds. Host API will be extended to make possible adding and removing clouds on the mobile device. Single UMA will allow accessing any number of local or remote clouds.
  • UMA will have a dedicated screen to manage downloaded reports and BLOBs.
  • Both UMA-W7 and UMA-W10 will be integrated in the app generator to allow previewing the app. The following options will be available:
    • Web Browser - launches the default browser of your operating system
    • Windows App - launches UMA-W7 in either “native” mode or “online” mode. Requires separate installation of UMA-W7 from
    • Universal Windows App - launches UMA-W10 in “native” mode. Requires separate installation of UMA-W10 from Windows App Store.

Offline Sync Add-on, CMA-W7, CMA-W10 (Release Dec 22

Presently, the app generator offers a number of Publish options for deployment to a web server. After an application is published for the first time, an “App Store” option is displayed. The option is not implemented in the current release.

Generator will display “App Store” option on the Publish screen as soon as you publish your application to any of the supported targets (Azure, File System, FTP, etc). Deployed application is available on internet and native apps can access services provided by the server components of the app.

The Publish / App Store option will be expanded to allow getting access to the native implementation of the app for each supported mobile platform. The initial implementation will offer two options:

  • Mobile App for Windows - this is a customized version of the Universal Mobile App based on embedded Chromium browser (CMA-W7). Developers will be able to download the installation package for the app directly. Unlimited Edition users will have an option to download the source code as well
  • Universal Windows App - this is a customized version of the Universal Mobile App for Windows 10 and 10S (CMA-10). Developers will be able to download the installation package for Windows App Store. Unlimited Edition users will be able to download the source code as well.

Offline Sync Add-on makes its appearance in this release. The add-on will be available for purchase at The purchase will be delivered to you as a zip file with the name “”. Copy the zip file to ~/Documents/Code OnTime/Addons folder. The application generator will automatically expand the contents of the file when the app is generated.

Installed addon will enable “always offline” mode in your application. Any pages marked for offline will magically become fully autonomous. The relevant data will be downloaded when application is installed on the native device. Any data modifications will be executed locally while requests to change data are logged and saved. User interface will expose Sync option in the menu. If synchronization is requested, then the log of changes will be submitted to the application server and requests will be executed as a single transaction. If there were no errors, then the transaction is committed. Otherwise, the user will have the option to reconcile issues for each individual error and attempt to resubmit the entire change log.

Here is a screenshot on app with Offline Sync Add-On installed. The tablet-sized screen will display synchronization status icon as a cloud in different states. In this case, all data is downloaded and there are no pending changes.

User can access “Sync” option in the context menu of their app shown next. This option is always present in the app enhanced with Offline Sync Add-On. It provides additional settings such as automatic synchronization.

Universal Mobile App for iOS (UMA-iOS) January 18

Our next target is Apple iOS. We will create a native implementation of Universal Mobile App for iOS based on the core code developed for Windows. UMA-iOS will use exactly the same JavaScript Host API shared by all platforms, which will drastically reduce the required coding to cover only native aspects of working with the native WebView, interacting with the file system, and making HTTP requests in an asynchronous fashion.

UMA-iOS will be available in Apple App Store as soon as the app is completed and approved.

Universal Mobile App for Android (UMA-Android) Feb 2

Android users will be able to test and work with their clouds in the native Universal Mobile App for Android. The same approach will be utilized to create a native implementation of the Android host application handling WebView, file system, and HTTP. Shared JavaScript Host API will support Windows, iOS, and Android at this point.

UMA-Android will be available in Google Play Store upon approval.

Custom Mobile Apps for iOS (CMA-iOS) Feb 9

We will enhance Publish / App Store with the option to download the compiled application package and upload it to the Apple App Store using Application Loader.

Another option for entrepreneurial developers is to download the source code of the app. You will be responsible for compiling and distributing the app to the App Store. This option will be available to Unlimited Edition users.

Custom Mobile Apps for Android (CMA-Android) Feb 16

The next iteration of Publish / App Store screen will expose an option to download a package for Google Play Store. The source code alternative will be available for Unlimited Edition users.

Universal & Custom Native Apps for MacOS (UMA-MacOS, CMA-MacOS) March 9

MacOS is a popular platform gaining momentum thanks to the popularity of Apple iPhone. Currently, we are considering providing a native option to access apps created with Code On Time for MacOS. We want to provide both Universal Application distributed through the Mac App Store as well as custom applications. We expect that our iOS implementation can likely be borrowed for MacOS equivalent.


These days, more people are using mobile devices than traditional desktop computers. Every business intent on staying modern needs to have a foothold into mobile apps. Code On Time native apps offer the ability to instantly take that step into the future. Native apps offer the ability to provide a consistent and integrated experience to end users on their mobile devices, and allow your app to always be in your user’s pocket. Integration with device notifications enable a persistent connection with your data. The web browser is always there as an alternative option.

Back to Top

Offline  (December)

Disconnected data input is a requirement for many business apps, particularly those on mobile devices. Traditionally, developers create a master database using Microsoft SQL Server, Oracle, MySQL, or other database engines. Then, a custom Web API is implemented for this database. Native applications interact with the Web API to read and write data. Downloaded data is frequently stored on the mobile device in SQLite or other custom data files. Native application changes local data and either sends modifications to the server via the Web API or employs data synchronization to move records from SQLite to the production database.

As you can imagine, traditional “offline” (disconnected) application development requires numerous technologies and a significant amount of custom development. You will likely end up building additional “online” application to access the master database.

Code On Time has developed a “magic potion”, a “silver bullet” that turns online applications created with our app generator into an instant native offline application. This silver bullet is called Offline Data Processor (ODP).

ODP is a data manipulation engine written in JavaScript. It replicates some functions of a database server but does so on the client side. This is not a general purpose client-side database equivalent to SQLite. Instead, we have designed ODP to service requests coming exclusively from Code On Time apps directly on the client device, instead of passing requests to the server. ODP downloads data from the server on-demand or pre-emptively in JSON format. ODP simulates the effect of server-side actions on local JSON data while storing server requests in a transaction log. By default, ODP commits the entire transaction log to the server when the user saves the master record.

A separate product called Offline Sync Add-on enables accumulating multiple transaction logs and synchronizing them with the server when an internet connection is available, which enables “always-offline” execution possible. Offline Sync Add-on also downloads data pre-emptively to the device when application is installed.

Why ODP?

There are five distinct benefits of Offline Data Processor for the apps created with Code On Time. Here is the brief summary:

  1. Transactional Data Input
  2. Entering data for child DataView fields in "New" mode.
  3. Ability to configure createForm1 as a Wizard collecting data for child DataView fields along with the master record.
  4. Surveys collecting user input as DataView fields that are not based on a database table.
  5. Confirmation Controllers displaying DataView fields and submitting their values to business rules as JSON/DataTable

The server implementation of application framework handles database connections, transactions, and execution of update/insert/delete commands and business rules for transaction data input.

Offline Data Processor will be included in all product editions (Free, Standard, Premium, Unlimited) - this is the core feature of application framework. It will work in Touch UI only. Transactional Data Input By default, ODP is enabled for all data controllers in the new projects and remains disabled in "old" projects as of release Developers can override this behavior with a few lines of code.

If ODP is enabled then DataView fields will be visible in forms in "New" mode.

ODP is engaged automatically when the user starts creating a new master record or when the user tries to Insert/Update/Delete a record in the child DataView field. If any of these conditions are detected, then ODP will pause data manipulation operation initiated by the app and download any relevant controller definitions and raw data from the app. Next the execution of the data manipulation operation will resume entirely on the client - ODP will select, update, delete, and insert data in JavaScript arrays of records while logging the original requests to the server. The user will have an illusion of data being persisted in child data views, while in reality nothing is being saved to the database.

ODP stops being engaged when the user initiates Insert or Update on the master record. The entire log of changes will be submitted at once to the server. The server code will start a database transaction and execute each command within the transaction scope. If there were no issues, then the database transaction is committed and ODP is disengaged. If an error is detected, then the server code will rollback the transaction and inform the client framework about the error. The framework will display a generic data reconciliation window similar to Batch Edit. User can correct data and resubmit the master record.

ODP will also disengage if the editing session of a master record has been canceled.

ODP will also support "offline on edit" mode to support scenarios with unreliable online connection. If you tag the master data view as "offline-enable-on-edit", then all relevant data will be downloaded from the server as soon as user starts creating new record or edit an existing one. Mode "offline on edit" will work slower compared to "offline on-demand", but will allow the user to work in fully offline mode until the master record is updated or inserted.

Offline Sync Add-On

New product called Offline Sync Add-On is a DLL installed in the binary folder of the app. Application Framework will detect its presence and will let the add-on to perform additional processing when the server code is being accessed from the Native Mobile Apps only.

Native Mobile App downloads HTML, JavaScript, Images, CSS resources from ~/js, ~/css, ~/images, ~/fonts, ~/pages folders of the server app to the client device. Offline Sync Add-On will supply additional JavaScript code to the native app.

Developers will mark the desired data pages of the app as "offline".

Native Mobile App enhanced with Offline Sync Add-On will perform a pre-emptive downloading of data controllers and raw data along with the static resources. Offline Data Processor will be engaged whenever the user is visiting a page marked as "offline". Any select/update/insert/delete operations will always be performed against the downloaded data only.

The app enhanced with Offline Sync Add-On will also provide a "Sync" option in the context menu that will initiate transactional processing of data created on all "offline" pages in a single submission. If the data changes were committed, then the fresh static resources, controllers, and data will be re-downloaded from the server app.

These are the states of the Sync command in the user interface.

Offline Sync Add-On will also provide automatic sync options that do not require user involvement. The sync will be performed when online connection is detected.

ODP will also perform local transactions in “offline” mode when master records are inserted or updates. Sequences of logged data manipulation requests will be persisted along with the simulated effects of those requests to the device storage. If the user decided to cancel a sequence of changes by cancelling the master record then the previous versions of the JSON data and logged requests are restored from the local storage.

Always Offline

Offline Sync Add-On extends ODP making it possible to work "always offline" as follows:

  1. Add-On downloads data and controllers preemptively when the app is initialized.
  2. Add-on executes requests to select/update/insert/delete data by using local copy of data and controller definitions.
  3. Add-On interacts with the host app to save the state of data and sequences of logged server requests to the local storage of the device when local "transactions" are committed (when master records are Inserted or Updated).
  4. Add-On synchronizes logged server requests with the app when user initiates Sync command. It repeats step 1 upon successful synchronization.

Ability to build a single app that work both Online and Offline will be unique to Code On Time. This is the result of years of work we have put in the product development.

Offline Sync Alternatives

Offline Sync Add-On uses ODP features to implement "always offline" mode. You can develop your own version of Offline Sync if desired.

You can also build native apps against API exposed by Code On Time server-side code with any other tools available on the market, if you feel that having two apps is better than one that supports both “online” and “offline” execution.

Note that Offline Sync does not require any additional software to be installed on the client device.

Pricing for Offline Sync Add-On

Apps created with Code On Time do not require an end-user license. Only developers require a licence to operate the app generator.

Offline Sync Add-On is an optional component that will need to be purchased separately. The pricing will be per-device.

We believe that the automatic "always offline" execution and data synchronization in the apps will provide an enormous value to the end users of the applications created with Code On Time. Instead of raising the price of the developer license to reflect the value of “always offline” mode we will keep the prices intact and will require an end-user license only for the apps that will work in “always offline” mode in native apps.

Pricing details will be announced when the Offline Sync Add-On becomes available for purchase in the middle of December 2017 at

We turn an online app into an offline app while requiring no effort on part of developers.

The licensing will likely work as follows: The buyer of the application created with Code on Time can purchase Offline Sync Add-On for fixed number of devices and install it in any number of apps build with Code On Time for internal use. Offline Sync Add-On will accept requests from up to the fixed number of devices from users working offline with any of the apps built for internal use.


  • Developer builds 3 apps used by 200 employees of a customer. Only 10 of those employees will require offline access to some of the apps on their mobile devices. The customer will need the Offline Sync Add-On license for 10 devices only.

We have done extensive market research on the subject. The price for offline access is frequently valued at hundreds of dollars per user per months. Our offering will be very competitive and will not create a dent in your budget of the budget of your clients.


Offline "silver bullet" turns your online application into an application that works permanently in a disconnected mode, periodically synchronizing data with the online server. Access your data (SAP, Salesforce, SharePoint, Office 365, Google Cloud Datastore, MongoDB, custom SQL database) in always offline mode without writing a single line of code!

Back to Top

Data Driven Surveys (December)

Survey data controllers offer a lightweight method to capture arbitrary data from the user. One can think of survey data controllers as “smart forms”. These smart forms can be designed visually using COT v9 or Cloud On Time.

This feature has a dependency on the support of DataView fields in surveys, which is expected to be delivered with Offline Data Processor.

The JavaScript definition of the survey data controller can be stored in the rows of a database table. A dedicated feature will be offered for our customers to allow capturing survey responses at runtime. Developers will be able to set up catalogues of smart forms. Dedicated tables of smart form assignments will capture user responses.

One can envision the following use cases for data driven surveys within the custom application:

  • Integrated survey capabilities.
  • Medical form management
  • Student enrollment forms.
  • Audit systems.
  • Scientific data collection.

Any time it is necessary to collect data with a structure not known at design time, the data driven survey will prove to be an invaluable tool.

Here are instructions for building a hypothetical audit system:

  1. Configure a database with the following schema:

  2. Create an app and use the Project Designer to make the following changes:

    1. Tag "Definition" field in "Surveys" controller as "survey-form".

    2. Tag "Response" field in "Audits" controller as "survey-data".

  3. Run the application and define a few surveys. An example of a survey is shown below:

    A survey is a hierarchy of topics and questions. The questions are equivalent to inputs in Touch UI. In fact, a survey without a topic is a standard form - this technology is used throughout Touch UI. Dynamically created surveys are used to implement batch edit, import, and advanced search screens. It is possible to create complex surveys with hundreds of topics and questions, and have them rendered as wizards and tabs.

  4. When the user starts working with an audit record, the Response field will render as a special round button that displays the completion progress.

  5. Activating the Response field will open the survey form. The user can create a new response or update an existing response.

  6. Saving the form will write the JSON-encoded answers to the Response field.

        "Customer": "abc",
        "Order": "xyz"
  7. Developers can create business rules to parse the response and write the data to separate tables or external systems when necessary.

  8. Code On Time v9 will have the ability to visually design survey forms. Alternatively, developers can dynamically generate survey forms.

  9. A product called Survey Form Editor will be available. If the Survey Form Editor is installed in the binary folder of the app, then data fields tagged as “survey-form” will display a visual form designer directly in the application at run-time. The Survey Form Editor will have a subset of capabilities in COTv9 Form Designer. It does not require Code On Time to be installed. It will include the ability to map survey question answers to the columns of the application tables. When the survey response is captured, the mapped answers will be distributed to the specified tables automatically.

    Price for Survey Form Editor will be per device and will cost $199 / month.

    Software maintenance releases are included. There are no restrictions on the number of users filling out surveys. If only one end user is responsible for maintenance of forms, then only one license is required.

Code On Time v9 will further enhance data-driven surveys with the ability to design survey forms visually in the Form Builder in March of 2018. Form Builder is a standalone design component of v9 that can be embedded into apps created with Code On Time.


Many business applications require custom data collection. Built-in data driven surveys make on-demand data collection possible at a fraction of a cost of typical implementations. The world class data input capabilities of Touch UI will make simple the data gathering on mobile and desktop devices online and offline.
Back to Top

Code On Time v9  (April 2018)

Code On Time developers use the Project Designer to customize the application configuration, regenerate the app, and preview the result in the web browser. This requires frequent switching between a live app and the design environment.

We decided to integrate design capabilities directly into live apps and improve your rapid application development experience. For example, if the text of a label in the form needs to be changed, then you will do it on the spot in the live app. If the position of a field in a form or the column of a grid requires adjustment, then we want you to drag the user interface element to the desired location. Missing a field in the form? Drag the field from the Project Explorer, drop it in the live form, and instantly see the result.

To make this possible, the Designer will be integrated into the live app, and will appear alongside the application pages when activated.

Code On Time v9 has a brand new mode of operation on top of the original foundation.

  • New projects are created as empty web applications containing a single Welcome page. Only the name of the project, and programming language need to be specified.
  • An instance of IIS Express will be started pointing to the generated app.
  • Code On Time will load the web address of the application in the integrated web browser. Alternatively, Code On Time may launch a custom Universal Windows App with a hosted browser pointing to the address of your application. Also, you can have the default system web browser to be launched for that address. One of these three options is selected when the project is created.
  • The end user will see a dedicated “Design” menu option in the application user interface. This option is only displayed by the application if Code On Time is installed on the same computer where the app is running.
  • The Project Explorer tree will be displayed within the application page content. It is implemented as an HTML-based tree. The hierarchy of project configuration elements is similar to the counterpart of the original Code On Time. It does display some additional nodes. User can continue interacting with the application., The Project Explorer will track the current selection when the mouse is moved over user interface elements.
  • Selecting project configuration elements will activate property pages on top of the application content. When changes are made, the user interface of the application will be frozen while the code of the application is rebuilt behind the scene. The application page is refreshed when the code generation is complete.
  • The user will change layouts of live pages in WYSIWYG mode or manipulate them in the Project Explorer.
  • All the current features including in Model Builder are present in COT v9.

Previous releases of the application generator rely on a WebBrowser component embedded in a native Windows Forms application. Locally stored HTML pages are loaded in the browser. The pages provide configuration screens implemented with Desktop UI allowing design-time configuration of project elements. A native tree component provides the foundation of the Project Explorer. When the application is generated, the app generator performs steps defined by the project configuration to create the web app. An instance of IIS Express is started pointing to the generated application. The default browser is launched with the local web address of the application. Browser requests are served by the IIS Express instance.


Code On Time v9 will greatly enhance the productivity of Code On Time developers and shorten the development cycle when building line-of-business apps. Instant visual tracking of user interface elements allows quickly finding configuration properties. Task-oriented wizards will be available throughout the Project Explorer hierarchy. They will provide a quick and convenient shortcuts for common multi-step tasks, such as adding connection strings, defining project logos, configuring many-to-many fields, adding data view fields, and etc. Even expert users will benefit from rapid execution of various tasks through wizards.
Back to Top

Cloud On Time  (April 2018)

Code On Time v9 will be enhanced to run in the cloud. We will be calling it Cloud On Time.

Public Cloud

It will...

  • Provide each customer with a dedicated private database in the cloud.
  • Use built-in CMS to store generated data controllers, pages, and view layouts in the database. The same CMS can be integrated in your apps today.
  • Include an integrated database designer.
  • Automatically create table columns for the fields placed on the form layouts when needed.
  • Have almost every feature of applications created with Unlimited edition.
  • Be possible to extend application behavior with SQL, JavaScript, and Email business rules.
  • Provide instant application availability across all devices.
  • Allow app development on all kinds of devices including phones and tablets, such as iPad Pro.
  • Have a low monthly subscription fee with free trial period. Multi-developer subscriptions will be available. Subscriptions can be canceled at any time.
  • Serve as a flagship demonstration of Code On Time capabilities and features.

Updates of COT v9 and it’s cloud counterpart will go hand-in-hand. It, in fact, is exactly the same product.

Private Cloud

Cloud On Time offers a vastly superior RAD environment to life-of-business application developers with any skill level. The hosted environment eliminates the need to maintain servers and software releases. A low monthly subscription fee makes it affordable to most budget constrained organizations and individuals.

However, privacy- and security- conscious customers may require complete control over their database and application. In order to offer the terrific features of Cloud On Time in a private and secure fashion, the software will be provided as the pre-compiled and ready to run Private Cloud option.

A perpetual license will allow customers to install the software on their own private infrastructure. Maintenance updates will be included with the purchase. Renewal maintenance licences will also be available.


The unified application development experience across both private and cloud environment will allow Code On Time customers to leverage their expertise and comfortably selecting the right environment for a given project.

Users will have access to all of the latest features from the palm of their hand. Gone are the days of experimenting and installing different versions of .NET frameworks, connector components, databases, and Visual Studio. Cloud On Time gives a new definition to “Rapid Application Development”.

Back to Top

ERP Integration & NoSQL Support  (May 2018)

Code On Time is a perfect tool to create custom applications for your ERP installations. You can rapidly build applications on top of your ERP database schema with Single Sign-On based on Open Authentication. Custom applications do not require any additions to the ERP database while producing powerful data entry forms with the ability to work offline and online. Application framework also allows creating custom data controllers to read and write data from abstract sources such as REST APIs and NoSQL databases. Application generator defines templates for implementation of methods to select, update, insert, and delete data. Custom processing for binary large objects can be implemented when needed.

Future iterations of the application generator will further enhance automatic ERP integration features available to developers.

Open Authentication Integration Completed in

Integrating with SharePoint relies on Open Authentication. The application captures an OAuth access token when registering SharePoint Single Sign-On as explained here when pressing “Add System Identity”.

The same capabilities will be implemented for Google SSO and Microsoft Graph SSO (Azure AD, Windows Live, Office 365).

Enterprise Blob Adapters

Upload your BLOB content to SharePoint, Google Drive, and more. Additional blob adapters for SharePoint and Google Drive will be available.

OAuth Membership Providers without Database

Generator will be able to produce apps without a database and have them configured with a custom membership provider based on OAuth for SharePoint, SAP, and Salesforce. Application data controllers will be interacting with REST endpoints of the corresponding data sources.

This will make it possible to create custom forms, reports, and apps to work offline, online, and on-premises with Office 365, SharePoint, SAP, and Salesforce.

Data Controller Models based on REST APIs (SharePoint, OData, etc)

The last component of the ERP Integration strategy is the ability to create data controllers from any REST API. The Data Model Builder will allow creating data models defined by the output of an API request. Optional specifications to Create, Update, and Delete data will be available for each Data model based on REST protocol. The application generator will make use of the configuration at runtime to perform data operations.

Model Builder will support creating Data Models from OData Sources.

Model Builder will also support creating Data Models for SharePoint Lists with simplified automatic configuration of REST endpoints out-of-the-box. It will make possible creating apps that work on top of SharePoint with the direct read/write operations.

We are planning to add more “known” APIs to simplify creation of data controllers based on user-specified REST endpoints.

Cloud Identity Provider/Consumer (April 2018)

We are migrating from ASP.NET Membership to a custom database schema compatible with supported database engines that will enable creating applications with a security system based on Open Authentication 2.0 (OAuth). Any application will be able to act as an Identity Provider and Consumer if membership is enabled.

If a collection of applications is being developed, then one app can be identified as the Identity Provider, and the rest of the applications will become Identity Consumers interacting over OAuth 2.0 protocol with the provider application to verify users and obtain claims such as roles, permissions, etc. Having one application responsible for management of user information will simplify maintenance of the entire collection and enhance the security of the solution.

Entity Framework, MongoDB, and NoSQL Databases

REST endpoints frequently represent Web APIs built on top of data access layer created with Microsoft Entity Framework or accessing directly NoSQL MongoDB or other NoSQL databases. Model Builder or REST APIs described above will make it easy to create apps on top of such services.

Application generator will also offer the option to create embedded endpoints built with Microsoft Entity Framework or connect directly to MongoDB or other NoSQL databases with methods tailored to support Code On Time data manipulation facilities. Embedded endpoint is a class defined directly in the application source code. Application framework will recognize Entity Framework models in the project. Model Builder will allow defining embedded endpoints and the app generator will produce the required code automatically.

We are also considering other NoSQL data engines such as Cosmos DB and other database engines with limited SQL features like Informix to be provided with custom embedded endpoint generator.


Online and offline access to ERP data sources and NoSQL databases.
Back to Top

Assistant UI  (August 2018)

We will introduce a new type of user interface called Assistant UI to compliment Touch and Classic. The purpose of this user interface is to enable alternative means of interacting with an app that do not involve a computer display or smart phone.

For example, a voice command will allow an application user to insert, update, delete data, or execute a custom action. A sentence in an email sent to a particular address will result in data being changed.

Assistant UI will allow interaction with an application without a display.

Automatic integration of generated apps with Actions on Google will enable data controllers to accept voice-activated data input from Google Assistant and Google Home. Unique architecture of apps created with Code On Time makes it possible to offer voice alternative to Touch input. We will use Google Natural Language API to analyze the commands received from voice and email agents to perform data manipulations in the app.

Assistant UI is possible thanks to a unique architecture of applications created with Code On Time. Selection of data and execution of commands with any number of entity types requires only two API endpoints. The application framework will be enhanced with server-side data cursors that can be moved or acted upon via voice or email. The session cursors will be automatically initiated via voice or emails. Authentication of external agents via OAuth to deliver commands to cursors will ensure robust security.

We will also consider voice command and data input integration for Amazon, Microsoft, and Apple devices as the next steps of evolution of Data Aquarium Framework and Touch UI.


Effortless data manipulation in the generated apps with voice and email as an alternative to physical data input devices.
Back to Top


Action Notifications Implemented in

Brief, non-modal messages will be shown in response to user actions or triggered by business rules, confirming the completion of actions such as “Saved record”, “Created record”, etc.

Google reCAPTCHA Integration for Public-Facing Forms

A single tag will enable Google reCAPTCHA in public-facing forms to ensure that only humans are entering data.

Back to Top

Node.js  (2018)

Code On Time v9 migrates XML data controllers to JSON format. The development environment of CoTv9 and Cloud On Time is one and the same. The JSON controllers will be modified, and data controller logs will be produced directly in the browser. We will provide an alternative implementation of the server-side framework written/generated completely in JavaScript. There will be no dependences on .NET. The framework will be extended with additional support for MongoDB and DocumentDB as server-side database engines. It will be possible to write server-side business rules completely in JavaScript. We will also provide a mechanism to invoke business rules written in C# or other languages through REST APIs.

Code On Time developers will have a choice to implement their apps using the Microsoft platform with C#/Visual Basic, or Node.js with JavaScript. The objective is to give our customers the option to write universal business applications on a platform of their choice. If your app exclusively uses SQL and JavaScript business rules, then your app can be hosted on either a Linux or Windows server.


Provides additional deployment options for Code On Time v9 apps to Linux and Mac OS X platforms.
Back to Top
Disclaimer: This roadmap does not represent a guarantee that the features 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.
Talk to us: Let us know what you want to see in the product. Open a support ticket or share an idea with the community.