Build Internal Tools Fast with Our Library for [TypeScript]

From Database to UI: The All-in-One library suite for internal tools development with integrated authentication in your language of choice.

Book a Call
Demo screenshot
View Live Demo
An application built with subZero

Building Blocks for Internal Tools

Leverage our suite of libraries for rapid development of internal tools.

Simplicity

Integrates in your existing codebase

Instead of combining multiple tools and managing complex production infrastructure, subZero integrates into your existing codebase and runs as part of your code.

Self-Configuration

Automatic database introspection

There is no need write custom code for each endpoint, just point subZero at your database and it will automatically introspect your schema and create a REST API for you.

Security

Built-in authentication & authorization

Complete user registration and authentication flows out of the box. To implement authorization you can rely on grants and policies from your database or specify them separately in a JSON file.

No Lock-In

Standardized API format

subZero's API format is compatible with PostgREST and GoTrue, so you can use the open-source client libraries and tools in your frontend code.

Adaptive UI

Automatic Interface Generation

Complete auto-generated CRUD interfaces using React-Admin, covering 80% of typical use cases. Seamless adaptation ensures no code changes when the database schema evolves. The rest is fully customizable.

Productivity

Rapid Development

The automatic creation of APIs and UIs reduces manual coding, allowing for rapid tool creation and faster project timelines.

Harness subZero's Power in Your Preferred Backend Language

subZero now bridges the gap between your favorite development frameworks and the power of subZero with new language bindings.

TypeScript (Express)

Harness the full-stack capabilities of TypeScript with Express. This integration empowers frontend developers to build full-stack admin applications with ease, as the backend development is almost fully handled by the subZero library, ensuring a seamless and efficient project workflow.

Rust (Rocket)

Leverage Rust's unparalleled safety and performance in your applications. This integration ensures rapid, error-free development, making the most of Rust's compile-time guarantees and Rocket's expressive syntax for high-speed, secure web services.

Java (Spring Boot)

Java's Spring Boot integration accelerates development within enterprise settings, making it simpler for IT departments to deliver projects swiftly. This approach utilizes subZero's capabilities to enhance backend efficiency, directly supporting fast-paced enterprise demands with minimal overhead.

C# (ASP.NET Core)

For C#, subZero supercharges development by providing powerful REST APIs for database interactions and streamlined authentication flows. This integration is especially advantageous in enterprise settings, where it facilitates quick, secure access to data, aligning perfectly with the needs of businesses leveraging Microsoft technologies.

Built for developers

Build more while worrying less. Reduce errors and boosts productivity.

Seamless Backend Integration

Unlike competing products that require your code to adapt to their framework or lock you into their SaaS, subZero, as a library, seamlessly integrates into your existing backend (Express, NextJs, Spring Boot, Rocket, etc.). It becomes an integral part of your codebase, giving you control over how your product is built and deployed.

Backend
import express from 'express';
import { Client, Pool } from 'pg';
import { init as authInit, getRequestHandler as auth } from '@subzerocloud/auth';
import { init as restInit, getRequestHandler as rest } from '@subzerocloud/rest';
//...
const dbPool = new Pool({connectionString: 'postgresql://localhost:5432/db'});
const dbSchemas = ['public'];
const app = express();
app.use('/auth', auth());
app.use('/rest', rest(dbSchemas));
//...
app.listen(3000, async () => {
await authInit('postgresql', Client);
await restInit(app, 'postgresql', dbPool, dbSchemas);
console.log('Listening on port 3000')
});

Streamlined Frontend Development

While the choice of frontend framework ultimately lies in your hands, subZero has been fine-tuned to take full advantage of React and React-Admin. This combination enables an automated, efficient, and superior frontend generation.

Frontend
import {Admin, Resource} from 'react-admin';
import {loadSchema} from '@subzerocloud/ra-subzero';
//...
useEffect(() => {
loadSchema(client).then(schema => setSchema(schema));
}, []);
//...
<Admin>
{Object.keys(schema).map(model => {
return <Resource key={model} name={model} /* ... */ />
})}
</Admin>

Comprehensive and Versatile Security

Secure your application with a wide array of authentication methods tailored to your needs.

Authorization
-- grant read access to the customers table for employees
grant select (id, name) on customers to employee;

-- filter customers to only those belonging to the current user
create policy 'Access to own customers'
on customers to employee
using (account_manager_id = auth.uid()) ;

Advanced Access Controls

Granularly control what users can access by leveraging your database permissions system (grants and row level security). For databases without these features, subZero provides an equivalent external configuration option.

Authentication
client.auth.signInWithPassword({
  email: 'alice@email.com',
  password: 'secret-password'
}
);
client.auth.signInWithOtp({email: 'alice@email.com'});
client.auth.signInWithOAuth({provider: 'google'});
client.auth.signInWithSSO({domain: 'company.com'});

SAML SSO, 2FA, and More

subZero offers versatile authentication with SAML SSO, 2FA, and multiple sign-in options, including Google, Okta, and traditional email/password. It supports OAuth flows and ensures high security standards for your application.

Simplify your infrastructure.

Eliminate countless services that need to be managed and maintained.

Simplicity

All you need is your database and a way to run JavaScript.

Other solutions require deploying multiple services or lock you into a specific SaaS. subZero provides all the benefits of auto-generated APIs without the hassle of managing complex backend infrastructure.

No Lock-In

You can use subZero with any database, on any platform.

By providing a clean interface consisting of pure functions, our library can be used on any platform with a JavaScript/Java/Native runtime and any PostgreSQL/MySql/SQLite/ClickHouse compatible database.

Zero-Dependency

Almost a full backend in just 322 kB package.

With such a small footprint, our library can be used even in the most resource-constrained environments. Now your entire backend can fit into a single Cloudflare worker which has a 1MB limit.

Why not just PostgREST/GoTrue?

While a powerful combination, PostgREST and GoTrue are rarely enough for a complete backend.
Here are the advantages subZero brings to the table.

Customize as Needed

subZero is a library, not a service. This means you can get the benefits of auto-generated APIs while still being able to add custom endpoints and logic as needed.

Autogenerated UI

For internal tools, often a simple, secure UI that respects user permissions for data management is sufficient. Imagine managing 10 tables, which typically requires creating and maintaining around 40 screens. subZero's smart "Guesser" components eliminate this burden by automatically generating the necessary UI screens, significantly reducing development time and effort.

Not Just PostgreSQL

If all your data is in PostgreSQL, PostgREST is a great choice. But if your database is anything else, you are out of luck. subZero works with any SQL database.

Powerful Analytical Queries

subZero enables easy execution of complex queries like groupings, sums, and window functions, crucial for applications needing data aggregation and graph visualizations. This streamlines building data-driven user experiences without the need for custom database views, enhancing developer productivity.

Deploy One Thing

Almost always you'll have to add custom endpoints to your backend and something has to serve the frontend, so what started as a single application ends up being 4+ services. Make your devops team happy with a single deployable.

Business Logic in the API

Creating secure user facing API with PostgREST means setting complex constraints on columns for data validation, creating database roles and permissions, and writing custom stored procedures for business logic. Sometimes that is not possible, or maybe you are just not a fan of keeping your business logic in the database. subZero allows you to do all that in the API layer while still getting the benefits of auto-generated APIs.

Embrace AI-Powered Development

Moving Past Drag-and-Drop: Where AI and Code Editors Meet

The Limitation of Browser-Based UI Builders

While competitors offer browser-based UI builders, they often fall short in AI integration. These platforms may provide drag-and-drop simplicity, but they lack the flexibility and intelligence that AI can offer. You're confined to a set of predefined components, limiting your ability to innovate and adapt.

The subZero Difference: AI-Ready, Editor-Based

subZero takes a different route. We offer an editor/library-based approach that's designed to work seamlessly with AI tools like Copilot and ChatGPT. Instead of being confined to a browser, you can leverage the full power of your code editor, integrating AI-generated code directly into your project.

Why It Matters: Frameworks and REST Flavors

subZero is built on well-understood frameworks like Node, Express, React, and React-Admin, and it uses REST flavors compatible with PostgREST. This means AI tools, trained on vast codebases, can generate highly relevant and optimized code for your subZero project. You're not just building faster—you're building smarter.

Rapid Development, Immediate Results

With subZero, Your App Begins 50% Complete

Developing internal tools usually starts with the daunting tasks of extensive setup and overcoming the “white page” syndrome. These crucial business tools, primarily CRUD applications with added authentication, traditionally demand significant time, a team, and a hefty budget from the outset. subZero efficiently cuts through these initial challenges.

While competitors often resort to marketing jargon, promising quick results that typically amount to a simple "Hello World" application, subZero immediately provides 50% of your application’s robust, customizable functionality. Within the first hour, as you define roles and permissions, this functionality extends to 70%.

You are not just starting; you are halfway there.

Simple pricing, for everyone.

Get a lifetime license for a one-time payment. No subscriptions. No hidden fees.

Personal

For individuals working on their big ideas.

Free

  • One developer
  • Lifetime license
  • Unlimited projects
  • Unlimited free updates
  • Binary releases
  • Languages
    TypeScript
  • Authentication
    Email & Password
  • Supported Databases
    PostgreSQL, MySQL, SQLite
Get started

Team

For product teams

$895

  • Up to 5 developers
  • Lifetime license
  • One project
  • 1 year of free updates
  • Binary releases, Parcial source code
  • Languages
    TypeScript, Rust, Java, C#, C
  • Authentication
    Email & Password, OTP, oAuth2
  • Supported Databases
    PostgreSQL, MySQL, SQLite



Contact us

Enterprise

For large scale businesses and agencies.

Custom

  • Unlimited developers
  • Lifetime license
  • Unlimited projects
  • 3 years of free updates
  • Full source code
  • Languages
    TypeScript, Rust, Java, C#, C
  • Authentication
    Email & Password, OTP, oAuth2, SAML
  • Supported Databases
    PostgreSQL, MySQL, SQLite
    SQL Server, Oracle, ClickHouse
Contact us

Begin crafting your internal tool in less than 10 minutes.

Experience the simplicity, speed, and power of subZero firsthand and redefine your development process.