The philosophy of Jitterbit App Builder

Introduction

Building applications with App Builder is different from traditional programming. To get the most from it, you must get a feel for the core philosophies underpinning it, and the terminology it uses. This page explains App Builder's approach to web app development, its fundamental concepts, and the design principles that guide its functionality. With a good grasp of these ideas, you'll appreciate how App Builder works, and be better equipped to build applications within its framework.

Configuration over code

App Builder lets you, as a non-programmer, create robust, enterprise-grade web and mobile apps. Rather than coding, you build applications using visual tools, wizards, and configuration screens. This makes the development process faster and easier than trying to learn to program the same functionality.

In App Builder, you focus on what your app needs to do, not on how to do it. You define business rules, connect your data, and design how your app looks and works. The platform does most of the hard work, automatically handling technical details like creating database queries or selecting indexes. With mvSQL, App Builder's own SQL dialect, you can write complex rules that work on any database.

A core principle of App Builder is that your apps should work everywhere, on different devices, and on different operating systems. With App Builder, you build your app once, and its panel layout algorithm automatically adjusts your pages, panels, and controls for any screen size. This makes sure your app looks and works the same everywhere, so you don't need to build different versions for different devices.

Thinking in layers

A key App Builder concept is how it divides an app into four distinct layers, each responsible for a different aspect of an app:

• Data Layer: This is the base; here, you connect to your data sources, define tables, and establish relationships between them to ensure data integrity. You can also control insert, update, and delete permissions at the individual table level.

• Business Layer: The 'engine' of the app, holding all the rules, logic, calculations, and processes that work with your data. This is where you use mvSQL to build Business Objects and Subqueries, which serve as the single source of truth for your application's logic. These objects come in several specialized forms, such as Source Objects to expose data tables, List Objects to efficiently populate dropdown menus, Validation Rules to enforce data quality, and powerful CRUD (Create, Read, Update, Delete) Rules to perform actions on many records at once.

• UI Layer: What your users experience; the pages, panels, menus, charts, and controls that make up your app's visible parts. This includes specialized panels for showing data in different ways, such as standard grids, aesthetic Board Panels, or visual Chart Panels.

• Security Layer: The app's gatekeeper, managing who can log in (authentication) and what they are allowed to see and do (authorization). This includes not only what users can do, but also what data they can see through a powerful row-level security feature known as Reach.

graph TD
  subgraph " "
    direction TB
    SecurityLayer["<b>🛡️ Security Layer</b><br/><br/>Roles, Privileges, Authentication, Reach"]
    UILayer["<b>🖥️ UI Layer</b><br/><br/>Pages, Panels, Controls, User Experience"]
    BusinessLayer["<b>⚙️ Business Layer</b><br/><br/>Logic, Business Rules, Validation, mvSQL"]
    DataLayer["<b>🗃️ Data Layer</b><br/><br/>Data Sources, Tables, Relationships"]
  end

  SecurityLayer --> UILayer --> BusinessLayer --> DataLayer

App Builder does not make you build an app in a specific order: you can start with the Data Layer, setting up your tables and how they relate; you can start with the UI Layer, designing how your app looks and then building the data structures to support that design; or you might begin in the Business Layer, defining complex logic that you will later connect to both your data and your app's interface.

Core concepts and design principles

Another core principle is that your application should be able to securely access data no matter where it lives. App Builder is designed to connect to many different data sources, such as traditional databases, REST APIs, or cloud services, and treat them as if they were part of your local system.

App Builder includes features that simplify and accelerate common development tasks. You can use its wizards, which are step-by-step guides for creating applications, pages, tables, and controls. The Live Designer is an interactive environment where you can edit pages and see your changes in real-time. The App Workbench and Design Center also act as centralized hubs, offering quick access to the most common development tasks, organized by the four application layers.

graph LR
  subgraph " "
    direction LR

    Hub("🚀<br/><b>Accelerators</b>")

    subgraph <b>Tools</b>
      direction TB
      Spoke1["🖌️ <b>Visual Tools</b><br/><br/>Live Designer, Drag & Drop"]
      Spoke2["✨ <b>Guided Setup</b><br/><br/>Application & Page Wizards"]
      Spoke3["♻️ <b>Reusable Logic</b><br/><br/>Business Objects & Templates"]
      Spoke4["🧰 <b>Centralized Hubs</b><br/><br/>App Workbench & Design Center"]
      end
  end

  Hub -- " " --> Spoke1
  Hub -- " " --> Spoke2
  Hub -- " " --> Spoke3
  Hub -- " " --> Spoke4

App Builder further accelerates development through smart, reusable components. You can define a column's Usage (such as Title or Subtitle), and the platform will automatically use it to configure components like dropdown lists. For application interactivity, you can implement a Bridge to send notifications and alerts to users via email or on-screen popups, enabling complex, human-in-the-loop workflows.

With App Builder, security is considered a fundamental aspect of your application's design, rather than an afterthought. App Builder's security model uses roles and privileges. You don't grant access to pages directly; instead, you manage access through the underlying data objects. If an app user lacks permission to see specific data, the parts of the user interface that display it, such as panels, links, or buttons, are automatically hidden or disabled.

The look and feel of your applications is managed centrally using themes and styles. Business Objects let you create a single, authoritative business rule that can be reused across many different pages and panels. App Builder also uses column templates, which means it remembers your column configurations (such as name, data type, and control type) to make future table creation faster.

Think like an App Builder developer

To get into the App Builder mindset, you should first break down your application idea into the four distinct layers: Data, Business, UI, and Security. Think about what data you need, what rules apply to it, how your app should look, and who can access what.

When designing a page, always connect your panels to a business object in the business layer, not directly to a table in the data layer. This gives you the flexibility to add logic, calculations, or security restrictions later without having to rebuild your user interface.

Design your pages with a logical flow and grouping of panels. Let App Builder's responsive engine handle how your app adjusts for different screen sizes. Avoid trying to force a pixel-perfect layout for just one screen size.

graph LR
  subgraph " "
    direction LR

    Theme("🎨 <b>Theme & Style Configuration</b><br/><br/>Colors, Fonts, Logos")

    subgraph "Renders on:"
        direction TB
        Desktop["🖥️ Desktop"]
        Tablet["📱 Tablet"]
        Mobile["🤳 Mobile"]
        end
    end

    Theme -- " " --> Desktop
    Theme -- " " --> Tablet
    Theme -- " " --> Mobile

Finally, use the hub menus for navigation and building: the IDE, App Workbench, and Live Designer. These are designed to guide you through the intended workflow and provide context-aware options. Adopt the platform's naming conventions (such as TableName (Purpose) for your business rules) to keep your application organized and maintainable as it grows.