You build the beautiful experience.
ARAD generates, secures and deploys the backend as a live Liferay module — no pipeline, no downtime. Your team writes only what makes the app unique.
Opening a store shouldn't mean building a new mall every time.
Security, roles, workflow, documents, navigation — every enterprise app needs the same foundations. Your AI agent rebuilds them on every project, then debugs them. That repetitive work is where most of the cost goes.
Where your AI tokens go
Most of an enterprise module is backend plumbing and controls. ARAD takes that part off your agent's plate.
- Database layer
- REST APIs
- Validation
- Security & audit
- Approval workflow
- Forms & admin screens
- Deployment
- Your UI & business rules
Illustrative. Proportions vary by project.
ARAD automates the heavy part
Everything that used to burn tokens is now generated for you.
Liferay is the mall. Your app is the store.
New to Liferay? It's the platform ARAD builds on: an open-source enterprise platform, written in Java, that provides the shared foundations every serious application needs. Your team fits out the store, not the whole building.
Building a mall for every store isn't realistic
For an enterprise these are must-haves, not extras. Building them yourself means years of work and a permanent maintenance bill: the cost of running a mall, when all you wanted was a store.
Why we chose Liferay
Of those platforms, one is open and built on a stack enterprise teams already know.
Read, extend and host the platform yourself, instead of being locked into a closed product.
A mature Java stack your developers already know, with full APIs and a module system to extend it.
ARAD generates standard Liferay modules, so everything stays inside the platform's own rules.
From requirement to live module in four steps
Describe what you need in plain English. ARAD handles the rest inside Liferay, with no DevOps and no waiting.
Describe the requirement in plain language to any AI agent: Claude, Codex, Cursor or VS Code Copilot.
The agent turns it into a structured entity model: fields, relations, workflow and UI settings.
ARAD generates production-grade Java, compiles it in-process and packages it as an OSGi bundle.
ARAD backs up and migrates the database, hot-swaps the bundle, and the module is live. The portal never restarts.
Changes are just as quick
Say a price field has to be added to an existing form. Here's the work each way.
One model in. A complete enterprise module out.
Describe the fields your app needs. ARAD turns them into everything below.
Under the hood: six production artifacts
Standard Liferay and OSGi components your team already knows how to run.
Full JAX-RS REST API registered as an OSGi @Component service via the Liferay JAX-RS whiteboard. Versioned, secured, immediately consumable.
Validated input forms generated straight from the entity model as JavaScript (Backbone) forms, so they can be reused in other applications, not just Liferay.
List view, search and detail portlets, fully scaffolded as OSGi portlets and ready to drag onto any Liferay page.
Kaleo workflow process definitions (approval routing, roles, notifications and transitions) generated and registered automatically.
DDL migrations (CREATE TABLE, ALTER TABLE) applied with a full database snapshot before, and automatic restore on failure.
Excel and CSV import and export generated for every module, so data moves from a legacy system into Liferay without writing migration scripts.
Enterprise controls: built in, not prompted
These are the features that bloat AI-written code and fail audits when they're missed. ARAD includes them in every module.
Custom OSGi modules. Without the drawbacks.
The drawbacks people worry about come from hand-coding modules. ARAD generates them to Liferay's standards, so you keep the power without the pain.
Custom OSGi modules remain “a powerful and comprehensive way to extend Liferay’s functionalities.” — Liferay documentation
Download the generated modules into your own Liferay workspace. No lock-in.
One-click regeneration moves every module to a new Liferay version.
Liferay PaaS and self-hosted DXP. Liferay SaaS doesn't allow custom OSGi modules.
Where Liferay Objects fall short
Liferay Objects work well for simple, self-contained data. Enterprise applications that need any of these end up writing OSGi modules anyway.
Based on Liferay DXP documentation and source code, September 2026.
Every deploy is safe and reversible
Each ARAD deployment is wrapped in a safety envelope. Schema and bundle changes are always atomic and always reversible.
The deployment layer vibe coding was missing
AI can write enterprise code. ARAD makes sure it actually runs in production.
Use the AI agent you already have
ARAD exposes MCP tools, so any MCP-compatible AI agent can describe, model and deploy without touching a terminal or pipeline.
A familiar API pattern in every module
Every module ARAD builds gets its own secured API, and each one uses the same standard operations. Developers and AI agents learn the pattern once and apply it in every app.
The complete list
Every benefit, grouped by who it helps most.
- Fewer tokens burned. The backend is generated, not written by AI.
- Less debugging. Proven generated code avoids error loops.
- AI focus stays sharp. The agent's context is spent on your real problem.
- Predictable spend. Effort no longer grows with backend size.
- Requirement to live module in one flow: describe, model, generate, deploy.
- Changes in minutes. Add a field and hot-deploy it.
- Ready-made screens. List, search, form, detail and admin views come with every module.
- Easy legacy migration. Every module comes with Excel/CSV import and export, so legacy data moves into Liferay without custom scripts.
- Role-based access enforced on every service call.
- Complete audit trail. History of every record, plus who created and changed it.
- Data protection. Confidential fields are encrypted before they are saved.
- Approval workflows with submit, approve, reject, recall and task assignment.
- Multilingual content and data out of the box.
- No pipeline. No Git, Jenkins or CI/CD needed for modules.
- Zero downtime. OSGi hot-swap, and the portal never restarts.
- Backup first. The database is snapshotted before every schema change.
- Automatic rollback. Any failure restores the bundle and the data.
- MCP native. Works with Claude, Codex, Cursor and VS Code Copilot.
- MCP tools for every module, so agents can read the schema and data.
- Live testing. Agents check APIs with real data under real user roles.
- Consistent APIs. Every module gets its own API, built on the same standard operations.
- A typed entity model. No free-form, ungoverned AI code.
- No schema drift. Database, code and documents stay in sync.
- One standard stack. Ends framework debates and app silos.
- Easier long-term support. Every app is structured the same way.
Don't believe it? Fair enough.
See it for yourself
Our experts from the product engineering team will show a live demo of how it works and answer all your queries and all follow-up queries down the line.