Database Workbench is a browser-based IDE — no local install, no toolchain to manage. The platform's standard library has more than forty namespaces covering database access, HTTP, cryptography, cloud, AI, document generation, image processing and more. Playbook runs and debugs server-side scripts. TypeScript declarations give every IDE full autocompletion. Build on the platform you are about to ship on, from inside the platform itself.
Business logic runs on the platform's servers, never on the user's machine. Write it in JavaScript, Python, Groovy or a business 4GL — the platform provides the runtime for all four, so there is nothing to install or license. Java extensions can be added to the cluster without downtime. One security model and one audit trail cover all of it.
Java libraries surfaced as namespaces in the scripting languages, so a script calls them natively. Databases, documents, printers and point-of-sale devices, MQTT, cloud services, signing and e-invoicing, OCR, charts and AI — built once, available to every script.
Multi-tab SQL editor with Monaco syntax highlighting. Server-side script execution from the browser. AI code completion. Object tree, ER diagram generation, import / export with progress streaming.
Server scripts, database routines and the objects they act on are records in the metadata repository. They are versioned, diffed, checked out and committed where the runtime will execute them — not files on a developer's machine waiting for a deployment step.
Business logic never runs on the device someone is holding. It runs on the servers the platform is deployed to — your own infrastructure, or hosted for you — next to the data, where the company's security rules and audit trail apply. The platform provides the runtime for all four languages, so there is nothing for the customer to install, license or keep patched. A team picks the language that fits the task; all four read the same data, on the same connection, with the same permissions.
The most widely written language in the world, used here for application logic, integrations and batch work. Most organisations already employ people who write it, and the ones they hire next will too.
The language data and machine-learning work is written in. Analysts and data engineers use what they know, against production data, without exporting it anywhere or standing up a second system to run it on.
Compiles and runs on the Java virtual machine, so it is as fast as Java and can call anything Java can. Numbers are exact by default, which matters when the code handles money.
A language made for business calculation. Amounts are exact rather than approximate, database queries are part of the language instead of an add-on, and the code reads the way the rule reads. PL/SQL is the nearest relative most people will know.
When a requirement genuinely needs Java, Java is added — and it goes live across the whole server cluster without rebuilding the product, restarting anything or booking a maintenance window.
The application is written, deployed and executed on server infrastructure, whether that is the customer’s own data centre or a hosted environment. A laptop, a tablet or a phone reaches it through a browser and receives rendered results over HTTPS — there is no client to install and no device that holds logic, credentials or data. Everything of consequence stays inside the server perimeter, under one security model and one audit trail, whichever language it was written in.
The platform does not impose a language. It provides the runtime for all four, so a team picks whichever fits the task — and the choice is not exclusive: one application can mix them, a 4GL batch beside a Python analysis beside a JavaScript endpoint, all reading the same data on the same connection, under the same permissions and the same audit trail. Below, the same invoice is computed once in each language — same fixtures, same rounding rules, the same totals to the cent. Each card holds the whole program; open one to read it at full size.
The language teams already have, on the same numbers.
JavaScript does the same work through arbitrary-precision decimals with the scale set by hand, on the same runtime and the same connection. Same inputs, same rounding, same totals — because the rules are the rules, whichever language states them.
The same rules, restated in exact decimals.
Python reaches identical figures using `Decimal` values quantised half-up at each step. Nothing is approximated and nothing is left to binary floating point — but the precision the 4GL carries in the declared type has to be restated at every operation, and the SQL runs through a statement and a result set.
Compiled onto the JVM, with exact decimals for free.
Groovy is the one of the four that is not scripted — it compiles and runs on the Java virtual machine. A decimal literal is already an exact decimal, so the money arithmetic needs no wrapper type, and database access goes through the platform library directly. Same invoice, same totals.
Money is a type, SQL is part of the language, and rounding happens once.
Quantities, prices and discounts are declared with the precision they are held at — four decimals while the arithmetic runs, two once the value becomes a line total — so the rounding is a single assignment in a single place. The VAT lookup is one statement written inside the language rather than a statement object, a result set and two blocks to close them.
An SDK for enterprise business applications. Forty-two namespaces holding several hundred ready classes, each one a Java library surfaced directly into the languages above, so a script calls it as though it were native — nothing to install, pin or reconcile. Grouped below by the job it does, as it appears in the platform’s own developer documentation.
The database tier as a call rather than a project.
What the business sends out, and what it receives back.
The equipment an operation runs on, which is rarely all web services.
Getting data in and out of systems you do not own.
Called as functions, with the platform’s credentials and audit trail.
The parts an auditor asks about.
Part of the library, not an add-on beside it.
The small things that otherwise become dependencies.
Server scripts, database routines and the objects they act on are records in the metadata repository — not files on a developer’s machine, and not a deployment step that happens later.
Write a server-side handler. Save. The endpoint is live cluster-wide. No JVM restart, no redeploy, no maintenance window — because the endpoint is a metadata record, not a compiled file. The deploy cycle that every conventional framework — Flask, Django, Express, Spring, JAX-RS — forces on a new endpoint is engineered out of the platform.
Open Database Workbench in the browser. Write the handler in JavaScript or Python. Configure the path pattern, the HTTP method and the role binding. Save. The whole authoring loop is inside the same web application the API runs in — no toolchain, no local Maven, no npm. The endpoint is a record in the platform's metadata repository, not a file in a build artefact.
On save, the runtime broadcasts a cache-eviction event through Redis pub/sub. Every node in the cluster clears its local metadata cache. The next request matching the route fetches the new handler from the metadata repository and compiles it. Existing in-flight requests continue under the old version; new requests pick up the new one. No maintenance window. No node restart. No version drift across the cluster.
The endpoint runs inside the same supervised runtime that runs every other request on the platform. The same eight authentication mechanisms apply — OAuth, OpenID Connect, SAML, JWT, mTLS, Basic, Digest, Form + 2FA — without the developer wiring any of them. Row- and column-level security is injected into every query the handler runs. Multi-tenant boundaries are enforced at the JDBC layer. Every invocation is captured in the platform's audit trail — the same one packaged Apps generate, queryable as standard SQL.
Every handler gets the platform's 40+ namespace standard library on the first line. Database access for native SQL across all ten engines. Outbound HTTP requests. Governed model calls into the AI providers configured for the tenant. SMTP mail. Signing and encryption. PDF rendering. Image thumbnailing and OCR. Cloud connectors for S3, Drive, SharePoint, Slack, Teams. CORS, multipart upload, server-sent events and streaming response bodies all available through the platform's HTTP layer — not glued together from a dozen npm modules.
The Application Editor persists the form definition to the metadata repository. The form is data in a database, not a file in a build artefact. Version control, branching, promotion between environments, audit — all the things that apply to data apply here too.
On save, the platform clears the metadata cache and propagates the invalidation across the cluster via Redis pub/sub. The next request on any node fetches the new metadata from the database. The cache invalidation completes in milliseconds — the new form is live cluster-wide in the time it takes to round-trip a message.
Users currently inside the form continue with the version they loaded. New users opening the form, and existing users who refresh, render the new version on their next request. There is no forced reload, no maintenance window, no service interruption — the new version is picked up as users move through the application.
Server-side JavaScript and Python scripts authored against the platform's standard library follow the same pattern. Edit the script in Database Workbench, save, the next invocation picks it up. Java-tier changes (the platform itself) still require a rebuild and a JVM restart — but applications built on the platform do not.
Material Design 3 foundation, the established colour roles, compact density. The platform is opinionated about data-density for enterprise screens. Sane, accessible, visually neutral — designed to recede when the company's brand is applied.
The company applies its branding once — primary and accent colours, logo, default locale, default density, allowed feature surface. Stored in the configuration database. Every user under the company inherits the baseline. Brand-critical decisions cannot be overridden by individuals.
Departmental overrides for role-based visibility on UI elements, menu customisations, default landing pages, dashboard templates. A finance team's default screen differs from a warehouse team's; both live under the company's branding.
Per-user appearance (light or dark), density (compact, normal, comfortable), menu style, button style, input style, theme variant. Applied on login. The user adjusts their own working comfort; everything load-bearing for the company stays under the company's control.
An enterprise platform's quiet differentiator: every application built on it looks and behaves the same way, because the architecture decides where things live — not the individual developer.
Database engineers handle the database tier. Business analysts author the metadata repository. Server-side JavaScript or Python developers handle batch and middle-tier logic. UI is generated. The full-stack-developer dependency that bottlenecks most modernisations is engineered out of the critical path.
Database business logic lives in the database. Application metadata lives in the metadata repository. Middle-tier scripts live in the platform's runtime. UI lives nowhere — it is generated from metadata. The platform makes the right place obvious, and the wrong place difficult.
The application surface is generated from a shared design language, governed by company-level UI rules. Developers do not customise screen-by-screen; the company customises once and the change applies everywhere. The result is an application portfolio that looks like one product, not seventeen.
When the developer who understood the old system retires, no one replaces them. JavaScript and Python developers, on the other hand, are abundant — and the platform's standard library puts them productively to work on day one. The migration is not just an application migration; it is a talent migration onto a sustainable foundation.
Because the entire application is metadata — every form, screen, role, query and batch is a database record — AI development agents author the same graph developers do. Natural-language instructions compile to XDBL ; agents scaffold forms, write stored procedures, propose schema migrations, refactor workflows. No file tree to parse, no inconsistencies to fight, no dialect-by-dialect SQL to memorise. The developer and the agent share one abstraction ; the platform's compiler and security model apply equally to both. This is the structural multiplier AI gets on a metadata-native runtime that it cannot get on a file-based codebase.
A full development and DBA environment, reached by URL. No JDK install, no Maven, no Docker, no local toolchain — and no credentials on anyone’s laptop. What a person finds in it is issued to them: the environments they are entitled to, and inside those, the objects they are entitled to. Works across every engine the platform supports — Oracle, PostgreSQL, SQL Server, DB2, MySQL, Informix and more.
Each environment is a separate registered connection, labelled as such and listed on its own. Moving between them is a click rather than a different tool, a different credential file or a different machine — and because they are labelled, which environment a statement is about is never in doubt.
A connection appears because it was assigned to the person or to a role they hold. There is no host to type, no port to know and no password to circulate. Access is provisioned centrally and withdrawn the same way; someone who leaves a team stops seeing the estate that team owns.
Entitlement does not stop at the connection. What can be read, what can be written and what can be executed follow the same grant — so a developer with read access to production and write access to their own development schema sees exactly that, in one tree, with no way to exceed it.
Connections, credentials and the entitlements over them are administered in one place and audited there. The organisation can answer who has access to which environment, and what was run against it, without collecting answers from individual workstations.
Monaco-based editor with syntax highlighting for SQL, JavaScript, XML and XSLT. Per-user query history, persistent across sessions and devices. Connect to multiple databases in the same session — PostgreSQL and Oracle side by side, SQL Server and DB2, or any combination of the platform's supported engines. Result-set inspection with row selection, sorting and export.
Browse the database object catalogue for any connected engine: tables, views, stored procedures, triggers, indexes, constraints. Generate ER diagrams from a live schema. Inspect query execution plans (EXPLAIN / SET EXPLAIN). Write and run schema migrations against the target engine; the platform's schema compiler validates XDBL against the engine's type system before execution. Import / export with server-side streaming progress.
GraalVM JavaScript execution from the browser, against the databases that person is entitled to, under their own permissions rather than a shared service account. The same execution model production scripts run in, and the same audit trail records it.
LLM-backed code completion through the configured AI provider. The completion runs inside the customer's permission perimeter; suggestions are not transmitted outside the configured provider.
Inspect Redis keys, TTLs, pub/sub channels. Browse Qdrant collections, points and similarity searches. The supporting infrastructure is queryable from the same IDE the application database is.
Manage SSH connections, key material and tunnel configurations for the database servers in the fleet. The DBA and the developer operate from the same tool.
One session against a benchmark warehouse of roughly sixty million line items. The catalogue, the data, the query and the assistant are the same tool, reached by URL.
The first thing a developer notices on Airtool is the absence of toolchain. There is no JDK to install, no Maven repository to configure, no Docker image to build, no local database to seed. The browser is the IDE. The runtime is the production runtime. The library is the standard library. Code runs where production code runs, against the data production code runs against, under the same security model.
The second thing the developer notices is that the platform generates most of what a developer would otherwise hand-write. Tables, screens, REST endpoints, role checks, audit trails — all metadata. The developer's job moves up a layer: from writing the application surface to authoring the model the surface is generated from. The same developer ships more application, with less code, against the same engineering rigour the platform itself maintains.