Connect to your database. Design models for your tables. Choose presentation options. Enjoy the result. Every app comes with charting, calendar, grids, with sorting, grouping, advanced filtering, deep searching out-of-the-box. We live in a BYOD world. Let's treat your web app the same way. From the smallest of phones to the most "Pro" of devices, we have you covered. And with feature parity across devices, no need to compromise.

Creating apps to fulfill your business needs shouldn't be hard. And yet the traditional process for building applications involes a whole lot of work to put together frameworks, build up infrastructure, and compose forms from scratch. Put your time to better use by building your apps with the best app builder.

The ToDo List: Every App's Starting Point
In every business, users need to keep track of their tasks. These tasks can be orders, appointments, payments or any other unit of work. It makes sense to measure the strength of a RAD product by how quickly you can put a ToDo App together. Our ToDo App will feature grids, forms, calendar, charts, maps, business rules, and much more.

STEP 1 - Tasks
First, let's start with a single table that keeps track of tasks. Create Tasks table in a database hosted in Microsoft SQL Server, MySQL, Oracle, PostgreSQL, IBM DB2, SQL Anywhere, or Firebird. Code On Time app builder will "see" your table as the model below and turn it into an application.

A task management page will be created. This page will display a responsive grid of records. The user can search, filter, and sort data out-of-the-box. Tasks can be created, edited, or deleted. The calendar presentation style allows viewing data in a day, week, month, year, or agenda view when a date field has been detected. The mini calendar on the sidebar allows for quick filtering options by date. Data can be downloaded in PDF, CSV, Excel, Word, or TIFF format.

Start the app builder, and open the Project Designer. Create a business rule for tasks to set Created to the current date and time when the create form is opened. Create a business rule to set the Date to the next rounded half hour. Hide the Created and Completed fields from the create form, and mark them as "Static" in the edit form.

Add a "Complete" custom action. Add one more business rule to set Completed to the current date when the user presses the action.

Creating a new task will now automatically set the Date and Created fields. Created and Completed are not visible in the create form. Saving the task will reveal the Created and Completed values. Press the "Complete" action to mark a task as completed. The task will disappear from the list of active tasks. Switch the view to "All Tasks" - the completed task can be seen. The Completed field was updated with the date and time the user pressed "Complete".

Let's say you want to maintain a list of locations where tasks are performed. For example, some tasks may be completed at home, school, or the workplace. Create a table called "Locations" and set up a foreign key linking "Tasks" and "Locations".

Update "Tasks" data model to include "Owner" and "Creator". Enable ASP.NET Membership. Configure the two fields as a "User Name Lookup". Mark "Creator" as hidden in the create form, and static in the edit form. Add a business rule to assign the "Creator" and "Owner". Filter tasks to only display tasks where the owner or creator is the current user. Membership, user management, auditing, and filtering, just clicks away.

Catch your user's eye. Use conditional styling with a large libary of glyphicons to effectively communicate to the user.

One option would be to start with the database. This database-first approach would have you design the perfect database schema that fulfills all the predicted needs for your business. Once development of the schema is complete, it is time to move on to the forward-facing elements of the application – the user interface, API requirements, and so on. But which technology do you pick? There are dozens of frameworks and development tools that are introduced every year, and dozens more that go out of style in the same year. Many of these technologies focus on the presentation and data binding, with little thought towards the implementation of server-side components. This results in having to pick a combination of technologies that are synergistic. Once the tools are chosen, you will need to learn how to use the them to their fullest extent – this may take a long time.

Once the frameworks have been selected, you must spend a long time implementing the architecture required for your database structure. In addition, each and every page for each database object must be designed and written. Imagine how long it would take to create every screen picture below!

Another option would be to develop the user interface first, and build the database as you go. This option faces many of the challenges in the first option - developing user interface is difficult.

Even after the application has been completed, what happens in the following situations?

Project requirements change
New and improved framework or library released
Selected framework deprecated
Performance or scalability issues
The common solution to this problem is to rewrite a portion of the application, or sometimes even move on to a different technology stack. The sheer amount of time spent on this cycle can be cost-prohibitive.

A better solution would be to de-couple the shape and structure of your database from the appearance of the user interface and the behavior of the server-side piece. That way, the client library would provide a generic mechanism to render CRUD applications. The server-side library would be able to dynamically create SQL scripts based on the data model and handle requests in a generic fashion. It would then be trivial to extend this app with features, such as sort, filter, charting, scheduling, reporting, access control rules, etc. When changes need to be made in the app, only the model would need to be changed – these changes would then be reflected in both the server and client side frameworks.

Let us introduce you to a third option – Code On Time application generator. The first step is to design your database schema. Then, define data models for your business entities. The application generator will compose data controllers, views, fields, and all other necessary metadata. In addition, the server and client side frameworks are generated for immediate use. The data models can be reshaped in order to more accurately represent the business entities. If further changes to the models are needed, then the controllers can be customized directly – this will impact the display and behavior of the app. Finally, if in-depth customization is needed, the application can be extended with custom components, stylesheets, and code, in order to add the final touch. This iterative approach to application development greatly increases turnaround time for new features or changes to database schema, without wasting time on moving inputs or changing SQL scripts.