While there are numerous NoCode platforms for designing and building presentation and data persistence layers, the market is sparse when it comes to developing intricate and complex business logic layers. This is likely due to the inherent difficulty in building a system sufficiently robust to handle the intricacies of any given industry while retaining the simplicity and ease-of-use that makes these systems popular with non-developers. As a result, most businesses develop this layer of their systems internally, or – in less critical scenarios – opt to substitute an automated solution with a manual one.
Most modern applications are based on a multi-tiered architecture where the presentation, business logic, and data management layers are decoupled. This approach allows developers to build reusable components and enables different teams to work on varying parts of the application.
The presentation layer deals with the user interface, while the data layer handles data persistence, such as database storage, logging, and analytics. The business logic layer consists of modules that facilitate the flow of data between the presentation and the data layers. It is comprised of the rules, algorithms, and calculations that correspond to a set of business requirements.
For example, let’s assume you are building a budgeting application where you aim to (1) collect data from different departments, (2) store the data in a structured format, and (3) aggregate reports around the stored data. The business logic handles all the rules and calculations related to that specific business’s budgeting process. It may also handle the process of aggregating the data into feed reports that are produced for the management teams. In a traditional coding approach, the business layer is where developers will often communicate with their business users to understand the requisite rules and logic.
How Do NoCode Platforms Handle Business Logic?
NoCode platforms are often excellent solutions when it comes to handling the presentation and data layers. Most NoCode platforms enable users to design attractive and user-friendly interfaces and to construct data tables with intuitive drag-and-drop components. However, they are not as powerful when it comes to handling business logic.
Logic in the User Interface
Most NoCode platforms provide some level of logic-building that is baked into the presentation layer, such as data validation, control interdependency, and customizable attributes (e.g. hiding and disabling contents).
For example, you may have a multipage data collection application where – depending on how a user answers a question on the first page – you will want to disable or hide some of the questions on the second page. This type of UI logic can be handled by generating conditional properties on each input control.
An example of this can be seen in the following sample life insurance quoting application:
If you answer Yes to the question “Have you ever used any tobacco product?” on the second page and hit the Next button, a page containing tobacco-related questions will appear. If you answer No, the entire page with tobacco-related questions will be skipped.
Logic in the Data
Similarly, some NoCode tools provide if-then-else logical blocks, as well as the ability to write mathematical operations into data fields.
For example, you may have an invoicing application where you calculate a sales tax. You can add a new data field and write a simple formula (e.g. SalesTax = TotalAmount * 0.06, assuming 6% tax rate). Of course, if you want to handle location-based sales tax, the equation will get more complicated and you will have to incorporate other variables, such as the State. You may be able to accommodate this with a bunch of if conditions and corresponding formulas, but any further complications may make it significantly more difficult and less maintainable in standard NoCode approaches, defeating the purpose of using a NoCode platform in the first place.
There are also workflow-building platforms that can connect NoCode applications to other services. For example, you can send data from your NoCode application to SalesForce for your sales team, generate a Word document in Google Docs, and send that document to a list of email recipients through Mailchimp. These tend to work seamlessly but they are also typically asynchronous operations, where the workflow can be configured to trigger every so often. In most scenarios, this type of delay does not pose a problem; however, if your application requires generating and downloading a document in real-time (e.g. the user presses a button to generate a document), then that integration may still need to be built separately.
There are other types of logic that cannot be handled in the user interface, database, or workflow operations. Just a few examples of these:
- Financial models that include recursion
- Quoting costs for configurable products
- Engineering applications and scientific tools
- Product configurators for manufacturing companies
- ROI tools
- Project cost estimators
Unfortunately, most of the logic that resides in business applications fall within this category. This is where a different type of approach is needed to handle complex logic without coding.
Using spreadsheet software, business users have been building logic-heavy applications for a long time. However, spreadsheets are not an ideal NoCode platform for designing user interfaces or data modeling. I discuss the specific reasons for this in a separate article, which I encourage you to check out (https://www.spreadsheetweb.com/the-first-nocode-platform-spreadsheet-software/). Instead, let’s focus on combining this spreadsheeting know-how with NoCode.
We developed SpreadsheetWeb to empower users to build logic-heavy NoCode applications directly from their spreadsheets. It uses the business logic that is built into the spreadsheet model without requiring any modification or translation. It incorporates a drag-and-drop module to build the user interface and an intuitive interface to build a relational data model, like many other NoCode platforms. The distinction is that these elements are then bound to references (i.e. individual cells or ranges) in the spreadsheet. As a result, it is a unique NoCode platform that incorporates the ability to build complex business logic directly into your applications.
Building an Insurance Quoting Application
Insurance is a logic-heavy industry. Many insurance operations involve complex business logic and rules, which makes developing insurance applications more challenging from a NoCode perspective. At the same time, the insurance industry has a strong reliance on spreadsheets: you can find complex spreadsheet models used everywhere in insurance companies.
Let’s take the example of an insurance quoting application. Below, you’ll find a simplified rendition of a quoting spreadsheet. The interface includes five inputs (Name, Effective Date, ER Zip, SIC Code, and Number of Eligibles) and produces a table of results that list calculated premiums for six health insurance plans.
There are other worksheets in this workbook that handle calculations and store reference data for lookups, which is where the business logic resides. There are over 2,000 formula cells representing actuarial calculations in this relatively simple workbook, which should give you a rough idea regarding the level of logical complexity that insurance companies require when quoting. Spreadsheet models with hundreds of thousands of formulas are not uncommon in the insurance industry.
With SpreadsheetWeb, turning this Excel file into a web application with a database takes less than five minutes. You can see this process in the accelerated video below.
A link to this application is provided, as well, and can be accessed from a desktop or mobile device. The sample will also give you an idea regarding the application’s performance. Each input change triggers a recalculation, which updates the insurance premiums based on the modifications.
This is just one example of an application built to the specifications of a given business operations in a given industry. There are a huge number of similar operations that require moderate-to-advanced levels of logic across a variety of other industries, such as financial services, investment, banking, engineering, education, and manufacturing. The ability to incorporate spreadsheet-based business logic within the application development process can make NoCode development much more appealing to businesses and significantly expand the scope of applications that can be produced without coding.