Tuesday, November 4, 2025Print Subscribe

RAD for the Digital Workforce: The Pivot to Rapid Agent Development

For years, the definition of "Rapid Application Development" (RAD) has been static: building forms and grids for humans faster than anyone else. At Code On Time, we remain committed to that mission. In our upcoming release, we are delivering top-notch development tools designed to make your everyday experience more productive and satisfying than ever before.

But we are also doing something more. We are taking the rigorous, metadata-driven architecture we perfected for human interfaces and using it to unlock something far more powerful.

We are pivoting. We are giving you the ultimate tools to build web apps today, while evolving into a Digital Workforce Platform for tomorrow.

Powered by our proprietary Axiom Engine, you will soon be able to deploy secure, autonomous digital agents in minutes. And you won't be building this future alone - you will have your own AI team to help you do it, if you choose so.

The Digital Workforce: Three Personas

The platform is built on three distinct AI personas. Two of them live inside your development environment to help you build, and one lives inside your deployed app to do the work.

1. The AI Tutor: Your 24/7 Expert

Role: The Mentor (Development Side)
Availability: Free in all editions (including the Builder Edition).
Power Source: Code On Time covers the cost using Google Gemini Pro with Context Caching.

The Tutor is your always-on, multilingual help desk. It provides instant answers based on a deep, cached understanding of the App Studio's service manual.

When you ask, "How do I configure a master-detail view for suppliers and products?", the Tutor doesn't just give you text. It understands your intent and generates clickable navigation pointers. If you give your consent, it can even see your live context (e.g., you are currently looking at the Suppliers page). It uses this to guide you directly to the specific node in the App Explorer, like a senior engineer pointing at your screen.

2. The AI Builder: The Automation Engineer

Role: The Maker (Development Side)
Availability: Powered by Builder Credits.
Bonus: Every new customer account gets a one-time $50 credit to try it out.

It is always your choice whether to prompt the free Tutor or use your credits for the Builder.

The Builder is the Tutor supercharged. With your explicit consent, it gains access to your app's live artifacts (your data controllers, pages, and schema) to provide context-aware assistance.

When you switch to "Builder" mode and give a complex instruction like "Create a dashboard for Sales with a chart showing quarterly revenue," the Builder analyzes your specific project structure. It generates a "Cheat Sheet" containing human-friendly, step-by-step instructions.

You remain in the director's seat. You can follow the steps at your own pace, or (because the Cheat Sheet also contains a machine-readable version of those steps) you can simply press "Apply All." The App Studio will then execute those instructions invisibly within the App Explorer. Crucially, the AI never touches your source code. It operates the configuration tools just like a human expert would, ensuring every change is safe and valid.

3. The AI Scribe: The Digital Consultant

Role: The Listener (Design Side)
Availability: Powered by Builder Credits.
Function: Requirements Elicitation & Rapid Prototyping.

The Scribe solves the "Blank Page" problem. It is designed for the moment before you know exactly what to build.

Whether you are in a stakeholder meeting or brainstorming solo, the Scribe listens. It captures your spoken conversation or stream-of-consciousness notes and uses the Axiom Engine to act as a "Clarity Gauge." As you speak, it builds an ephemeral plan in the background. If the plan looks wrong, you clarify verbally. If it looks right, you click "Apply All."

The Scribe turns a 30-minute conversation into a working Realistic Model App (RMA) instantly, eliminating the need for manual note-taking and translation.

4. The AI Co-Worker: The Digital Employee

Role: The Operator (Operational Side)
Availability: 100 Free "Employees" per app.

The Co-Worker is the result of your work. It is the secure, autonomous agent that your end-users will interact with to get work done. It operates the "invisible UI" of your application, inheriting the exact permissions and security rules you defined for your human users.

To enable this, your organization simply connects the app to your own LLM of choice (BYOK). Your data never leaves your servers; it is processed securely by the Co-Worker using only your approved AI provider.

The pricing is simple: The first 100 Digital Co-Workers (users with the Co-Worker role) are free. For deployments larger than 100 users, we charge an annual Digital Co-Worker License technology fee. Note that this fee covers the platform capabilities; LLM consumption is paid directly by you to your provider.

The Axiom Engine: How It Works

The Axiom Engine provides the infrastructure that powers these personas. We have designed a flexible consumption model that puts you in control of costs and data privacy.

The "Hosted" Model (Fast & Optimized)

By default, Code On Time handles the complexity for the development tools.

Context Caching: We maintain a version-specific cache of our service manual. This makes the Tutor incredibly fast and free for you.
Builder Credits: For the Builder, you can purchase credits (priced at $499 USD per unit) to fuel the heavy lifting of analyzing your schema and generating artifacts. These credits are shared across your team.

The "BYOK" Model (Private & Sovereign)

For organizations with strict data governance, we offer a Bring Your Own Key (BYOK) mode.

Total Privacy: You configure your own LLM API key. The entire prompt (including the service manual, your app’s schema, and your request) is submitted directly to your provider.
No Caching: There is no context caching in this mode; you have full control over the data flow.

Built-In, Not Bolt-On

The Axiom Engine isn't a separate server you have to install, manage, or license. It is compiled directly into the core of every application you create. When you deploy your app, you are deploying the Engine. The HATEOAS API, the State Machine, and the Heartbeat are all contained within your application's binaries, running on your infrastructure, under your control.

You can use the platform purely to architect your system, generate the specs, and then hand the SRS to your own team to build a custom front-end. You can even continue to use the built-in HATEOAS API as your backend, letting you keep the "agentic" power while having total freedom over the UI.

The "Escape Hatch": High-Value Outputs

We know that developers fear lock-in. That is why the Digital Workforce Platform is designed to be the ultimate specification generator.

Using Builder Credits, you can ask the platform to generate high-value artifacts from your application:

PRD: Product Requirements Document. Captures the business logic, user flows, and data rules of your running application to validate requirements with stakeholders.
SRS: Software Requirements Specification. A complete technical blueprint of your app that can be handed to a development team to build a custom project in any stack.
LOE: Automated Level of Effort. An objective, AI-calculated analysis of the time and cost required to build an equivalent application in a specific tech stack (e.g., React, Angular, or Blazor).
GEN: Scaffolding Code. Generates a starter project for other frameworks (e.g., generate a Next.js + React app structure) based directly on your application's schema and logic.

You can use the platform purely to architect your system, generate the specs, and then hand the SRS to your own team to build a custom front-end. You can even continue to use the generated HATEOAS API as your backend, letting you keep the "agentic" power while having total freedom over the UI.

Conclusion

The future of development isn't just about writing code faster; it's about generating a workforce. With the upcoming release of the Builder Edition, the Tutor, and the $50 starting credit, we are removing the barriers to entry.

We are delivering the best RAD tools in our history. And as a bonus, every app you build with them is now an Agentic Platform by default. You get the productivity you love, plus the workforce you need, all in one click.

We are no longer just a RAD tool for databases. We are the Rapid Agent Development (RAD) platform. Your new team is waiting.

Labels: AI, Digital Workforce

Thursday, June 19, 2025Print Subscribe

Beyond CRUD: Tailoring Your App with Custom Actions

Automatically generated apps are a fantastic starting point. With a few clicks, you have a powerful, professional-looking application with robust capabilities for creating, reading, updating, and deleting records (CRUD). But real-world business requirements are rarely that simple.

What happens when your users need to do more than just edit a product? What if they need to trigger a specific business process, like marking a product as discontinued, changing its supplier based on complex rules, or applying a batch update to dozens of records at once? This is where a standard CRUD interface reaches its limit, and the true power of your application platform needs to shine.

From Simple Clicks to Smart Operations

In Code On Time, the answer lies in a powerful, decoupled system of Actions and Business Rules. Think of it this way:

An Action is the user-facing component—a button in a form or an option in a context menu that a user can click. You define what it looks like, where it appears, and what it's called.
A Business Rule is the server-side logic that executes when the Action is triggered. This is where you define what actually happens.

This separation is key. You can have multiple actions in different parts of the UI trigger the same underlying business rule, ensuring consistency and reducing code duplication.

For example, a "Mark as Discontinued" option can be added to a row's context menu with just a few property settings.

Clicking the 'More' icon next to the first column displays the row's context menu, which is populated with actions defined in the 'Grid' scope group. The tooltip that appears on hover, "Remove product from the catalog," is pulled directly from the action's `Description` property, demonstrating how configuration directly maps to the user experience.

And you can easily add a confirmation dialog to prevent accidental clicks, providing a crucial safeguard for important operations.

A simple modal confirmation dialog appears when the action is invoked, serving as a crucial safeguard against accidental operations. This dialog, generated from the action's `Confirmation / Text` property, is intuitive for the end-user, who can dismiss it with the 'Esc' key or confirm it with the 'Enter' key.

Collecting User Input for Complex Tasks

Some business processes require more information. Replacing a product's supplier isn't a simple "yes/no" decision. You need to know which new supplier to choose.

This is where you can leverage a "Confirmation Controller"—a dedicated form designed to collect additional parameters from the user before an action is executed. This technique allows you to create complex, multi-step operations that feel seamless to the end-user.

The `view1` form of the `Products_ChangeSupplier` is shown when the user is selecting a new supplier for the product. The form is displayed when app users initiate the `changesSupplier` action in the `Products controller. This modal form acts as a temporary data collection tool. This powerful technique allows for the creation of complex, multi-step operations that require additional user input without cluttering the primary interface.

Bringing Intelligence to the Front-End, with SQL

The most innovative part of this system is how you can control the entire client-server interaction without leaving the comfort of a familiar language like T-SQL. The business rules you write on the server can intelligently direct the user interface on the client.

Imagine the "Change Supplier" action requires that the new supplier must already provide other products in the same category. You can write a simple SQL business rule to validate this logic. If the user selects an invalid supplier, the rule can instruct the front-end to:

Stop the action from proceeding.
Set the focus directly on the invalid input field.
Display a precise error message right where the user needs to see it.

This targeted error message showcases intelligent server-client communication. Instead of returning a generic error, the server-side business rule uses the `@Result_Focus` parameter to instruct the client-side UI to focus on the specific field that failed validation and display a helpful message directly next to it. Use a comma to separate the field name from the message. The front end will automatically activate the tabbed category or category associated with another wizard step if the field input is not visible at the moment.

This entire sophisticated, client-side interaction is commanded by your server-side SQL script. You don't write a single line of JavaScript to make it happen. The framework handles the complex plumbing, allowing you to focus purely on the business logic.

Ready to Build Your Own?

From simple confirmations to multi-step, validated batch operations, Custom Actions provide the flexibility to mold your application to fit any business need. This high-level overview just scratches the surface of what's possible.

To learn how to implement these features step-by-step, from creating your first action to programming conditional validation logic, dive into our comprehensive tutorial.
Read the Full Tutorial: Custom Actions

Labels: Business Rules

Tuesday, May 20, 2025Print Subscribe

Clear Choices, Clean Data

In the world of data-centric applications, clear data input and representation are key to a smooth user experience. Often, fields that store numeric or coded values, while efficient for databases, can be a source of confusion for end-users, leading to potential data entry errors. If you've ever had users puzzled by what a specific number or code means in a form, this is for you.

This document explores how Static Pick Lists in Code On Time applications can transform these challenging fields into user-friendly controls. Imagine turning a simple numeric input into an intuitive Drop Down List or Radio Button List. For instance, the Products.ReorderLevel field in the Northwind database, which contains discrete numbers, can be enhanced to show descriptive text labels.

The Static Pick List Solution

Code On Time enables developers to define a list of value-text pairs directly in the application's metadata for a specific field. The application will store the actual data value in the database, but users will interact with meaningful, descriptive text. This approach neatly separates the user interface from the stored data format, which is especially useful for values that rarely change.

You can manage these configurations within the "Pick List" group of properties for a field in the App Studio. For the Products.ReorderLevel field, instead of users typing numbers like 0, 5, or 10, they can select "Zero," "Five," or "Ten" from a list you've defined. This not only looks cleaner but also significantly reduces the possibility of data input errors. These helpful text representations will also appear in filters and search screens, making data interaction consistent and clear throughout the application.

Enhancing Boolean Fields Too

The power of Static Pick Lists isn't limited to numeric fields. Boolean fields, often represented as simple checkboxes, can also be made much more descriptive.

Take the Products.Discontinued field from Northwind, for example. While a checkbox is functional, you can provide users with clearer options. By configuring a static pick list, you could relabel this field as "Inventory Status" and offer choices like "Available" (representing the false value) and "Discontinued" (representing the true value). This makes the field's purpose immediately obvious.

The user-friendly `Discontinued` and `Available` options of the *Inventory Status* provide a user-friendly interface for the *Products.Discontinued* flag.

Why Implement This?

Improved Data Integrity: Clear choices lead to fewer input mistakes.
Better User Experience: Users face less confusion and can interpret data more easily.
No Database Schema Changes: Enhance usability without altering your underlying database structure.

How It's Done (A Glimpse)

Setting this up involves a few straightforward steps in the App Studio. After selecting your field, you'll work with its "Pick List" properties. You'll set the "Input Style" to your preferred control, like Drop Down List. If the field isn't already set up for list items, an action like "Convert to Static Pick List" can get you started. Then, you define each static item by providing its actual Value (what's stored in the database) and the Text (what the user sees).

The custom configuration of the *Discontinued* field is shown in the App Explorer panel overlaying the live application. The inspection frame is placed over the field value in response to the selection of the corresponding field.

Ready to Improve Your App's Clarity?

If you're looking to make your Code On Time applications more intuitive and reduce data entry errors, implementing Static Pick Lists is a fantastic step. For a comprehensive guide on how to configure these for both numeric and boolean fields, including detailed steps and more examples, please refer to our documentation.

Dive into the full details here: Enhancing Data Input and Representation with Static Pick Lists and start building more user-friendly applications today!

Blog

Build secure apps for humans today and deploy a Digital Workforce tomorrow using the exact same blueprints.