Software After Software: Building a High-Performance, AI-Native Enterprise Core

Why I Built Astra CMS: A Zero-Downtime, Metadata-Driven Core for the AI Era

Building enterprise software for fast-moving sectors like logistics and supply chain usually means living with a frustrating bottleneck. Business operations change daily, yet the underlying software stays stuck in a slow cycle: gather requirements, write boilerplate, run risky database migrations, and wait for a maintenance window.

Every time a regional branch needs a new field on an order form, someone has to run an ALTER TABLE migration. Every time a large client wants custom logic, engineering teams end up forking the codebase and creating long-term maintenance debt. Now, with AI agents entering the workflow, letting LLMs write code or query production databases directly on traditional architectures is a massive operational risk.

I wanted to solve this at the root. If an application is defined entirely as data, can the software change every day without breaking yesterday’s production?

To answer that, I built Astra CMS. It is an open-source, metadata-driven enterprise platform built for continuous schema evolution, zero downtime, high throughput, and safe AI execution.

1. Zero-Downtime Schema Changes Without Table Locks

Astra borrows the core concept of DocType from systems like Frappe and ERPNext, though it shares zero code or schema with them. A single YAML file defines the fields, validations, permissions, forms, REST APIs, webhooks, and workflows of a record.

The key architectural difference lies in the storage layer:

• JSONB by Default with Online Indexes: Instead of creating a physical SQL table per entity and locking tables on every schema change, Astra stores records in PostgreSQL JSONB. If a field requires fast filtering, marking it with projected: true creates an online expression index. Form customization in production never locks a table.
• Tenant Overlays Without Forking: Multi-tenancy should not require maintaining multiple code branches. In Astra, a tenant can add fields, modify permissions, or attach custom scripts using a versioned YAML overlay. For example, a Hanoi branch can add VAT and island-delivery fields in a single file. It applies at runtime with zero restarts, zero changes to the upstream app, and automated compatibility checks before rollout.

2. High Throughput and Financial-Grade Data Integrity

Dynamic schemas often trade off speed or data integrity. Astra avoids both pitfalls through strict separation of concerns:

• Append-Only Ledgers for Accounting: While general documents live in JSONB, financial entries and inventory movements use immutable, append-only double-entry ledger tables. Records are never updated in place. Mistakes are corrected strictly via reversal entries through a formal Submit / Cancel / Amend lifecycle.
• Rust CDC Workers & Distributed Transactions: Change Data Capture (CDC) workers are written in Rust for high throughput and predictable memory usage. Distributed transactions across microservices are coordinated via Apache Seata (AT mode on PostgreSQL, TCC on Redis).
• Database-Level Isolation: Multi-tenancy is enforced via PostgreSQL Row-Level Security (RLS). As a hard safety rule, the Astra kernel refuses to boot if connected with a database superuser account.

3. Safe Execution and Native Access for AI Agents

Adding AI to enterprise software requires more than bolting a chat wrapper onto an API. Astra is designed so AI agents can both build and operate the system within hard boundaries, keeping humans in control of critical approvals.

Sandboxed Code Generation (3-Tier Isolation): Letting an AI write business logic only works if a bad script cannot crash the host. Astra separates extensions into three tiers, using a WebAssembly (Wasm) Sandbox at Tier 2 for tenant scripts and AI-generated code.

• Scripts written in Rust, Go, TypeScript, or Python compile to Wasm and hot-swap at runtime.
• In our logistics demo, a holiday shipping discount written in Rust compiled down to 421 bytes. If an AI-generated script hits an infinite loop, the Wasm sandbox terminates it at 50ms without touching the underlying JVM pod.

Native MCP Tools with RBAC: Every DocType, event, and background job is automatically exposed as a Model Context Protocol (MCP) tool with a strict JSON Schema.

• When an agent like Claude calls Astra via MCP, it uses the caller's exact token, tenant context, and permissions, with automatic PII masking.
• A support agent's AI assistant cannot create unauthorized orders. When an accounting agent asks about Cash-on-Delivery (COD) balances, the query reads directly from the ledger and requires source citations. Any financial answer without a valid ledger citation is rejected.

4. Compliance Built Into the Schema

Instead of treating SOC 2, ISO 27001, and GDPR as an afterthought, Astra embeds compliance directly into the data model. Every DocType field includes attributes for data classification, retention period, legal basis, and residency. Data processing records, retention schedules, and audit trails are generated straight from the schema.

What Works Today

Astra CMS is open-source under the MIT License. The repository clearly separates what is running today from the remaining 10-phase roadmap.

Right now, you can spin up a local Kubernetes (k3d) cluster with two kernel pods and test:

• PostgreSQL RLS multi-tenancy, JSONB storage, and live YAML tenant overlays.
• The Wasm sandbox, Rust CDC workers, Apache Seata transactions, and Keycloak SSO/SCIM.
• The built-in MCP server with field-level PII masking.
• Three reference apps: Astra Express (courier and parcel logistics), HRM/Payroll, and STMS (vehicle routing powered by Timefold).

You can run the full stack locally with JDK 25, Docker, kubectl, and k3d:

git clone https://github.com/ZeroHostCMS/astra-cms.git && cd astra-cms
make k3d-up      # API at http://localhost:8080/api
make demo        # Two tenants, hooks, naming series, RLS
make demo-seed   # Seed data for the courier logistics app
open http://localhost:8080/desk/

Links & Resources

• Source Code: GitHub: ZeroHostCMS/astra-cms

I am actively looking for feedback on the DocType metadata contracts, the 3-tier isolation model, and ERP module boundaries.

Clone the repo, test it out, and let me know what you think.