Perlite: For Your Business →

Yes, absolutely. Every application generated by Perlite compiles to standard, production-ready NestJS microservices, Prisma ORM schemas, and React TSX frontends.

There are zero proprietary runtime daemons, sidecars, or execution proxies. You push the emitted code directly to your private Git repository and host it on your own cloud infrastructure (AWS, Azure, GCP, or bare-metal Kubernetes) with 100% intellectual property ownership.

Yes—and far beyond traditional static diagramming tools.

While tools like ArchiMate or Visio produce static drawings that quickly drift from implementation, Perlite provides an executable Business Capability Studio:

• Strategy-to-Code Traceability: Enterprise architects map top-level business capabilities directly to underlying domain entities and operational workflows.
• Dual-Canvas ERD Synchronization: Adjusting an entity, relation, or state machine in the visual ERD canvas automatically updates capability boundaries and compiles down to versioned Prisma schemas and TypeScript microservices.
• Zero Documentation Drift: Your architectural blueprints are mathematically tied to running metal—eliminating out-of-date confluence pages and architecture drift forever.

Perlite adheres strictly to established industry engineering standards:

• Domain-Driven Design (DDD): Models entities, aggregates, traits, and domain events within clearly partitioned bounded contexts.
• SOLID & Clean Architecture: Uses the Split-Function Service Bundle pattern—every entity action (CreateOne, UpdateOne, DeleteOne, FetchMany) is isolated into its own single-responsibility service class under strict line-count bounds.
• 12-Factor App & Cloud-Native: Stateless service execution, environment-driven configurations, and containerized Docker parity across staging and production.
• OWASP Top 10 by Construction: Parameterized queries via Prisma prevent SQL injection, strict typed DTOs with class-validator stop mass-assignment attacks, and automated AES-256-GCM encryption secures sensitive fields.

No. Custom business logic is written in 100% pure, modern TypeScript.

One of the greatest hidden risks of legacy enterprise low-code platforms (e.g. Salesforce Apex, Mendix Microflows, ServiceNow GlideRecord, OutSystems flows) is developer deskilling—engineers are forced to learn dead-end vendor dialects that are useless anywhere else, destroying team morale and making technical recruitment nearly impossible.

• Zero Deskilling: Your team writes standard, strongly typed TypeScript inside familiar NestJS service classes using the tools they already love (VS Code, WebStorm, Git, ESLint, Vitest).
• Standard Enterprise Tooling & Governance: Use your organization's existing code linters, type checkers, and internal CI/CD security scanners without proprietary IDE wrappers or vendor friction.
• Bankable Engineering Skills: Working with Perlite deepens your engineers' mastery of the world's most widely adopted enterprise web stack (TypeScript, NestJS, Prisma, React), keeping developer morale high and recruitment straightforward.

No. Perlite is a deterministic Abstract Syntax Tree (AST) compiler, not a probabilistic AI model.

While generative AI tools guess code from natural language prompts—often introducing hallucinations, phantom dependencies, and subtle security regressions—Perlite operates with mathematical certainty like the TypeScript or Rust compiler:

• 100% Deterministic: Given the same declarative domain model, Perlite compiles the exact same structured, enterprise-grade NestJS and React code every single time.
• Zero Hallucinations: Every relational foreign key, multi-tenant database filter, and encryption envelope is mathematically guaranteed by compiler AST invariants.
• AI-Synergistic: Because Perlite eliminates 80% of repetitive plumbing and isolates custom business logic into clean, protected action points, developer AI assistants (Cursor, Copilot, Claude) actually work 10x better inside Perlite applications because they aren't lost in monolithic spaghetti.

Perlite eliminates the code-regeneration dilemma using a deterministic Abstract Syntax Tree (AST) compiler engine built on ts-morph.

Custom TypeScript logic, specialized algorithms, and external API hooks reside inside protected semantic boundaries. When domain entities or relational mappings are modified in the visual modeler, the compiler parses the AST, extracts custom business logic blocks as pure AST nodes, and mathematically re-weaves them into updated layouts without merge conflicts or code loss.

Yes. Perlite emits semantic, accessible HTML5 and React components designed for WCAG 2.1 AA compliance:

• Semantic HTML5 over “Div Soup”: Emits native structural landmarks (<main>, <nav>, <article>, <details>, <button>) with proper document outlines.
• Full Keyboard & Screen Reader Ergonomics: Data grids, drawers, and form modals feature programmatic focus traps, logical tab indexing, and synchronized aria-expanded / aria-controls attributes.
• Guaranteed Contrast Ratios: Built-in design system tokens adhere to minimum 4.5:1 contrast ratios for body text and interactive controls across both light and dark enterprise themes.

Perlite enforces access governance by construction directly in the compiler pipeline:

• Declarative RBAC Studio Matrix: Visually map granular permissions (create, read, update, delete, custom actions) across user roles and business domains.
• Compiler-Generated NestJS Execution Guards: Emits strongly typed guards (@UseGuards(RolesGuard)) enforcing deny-by-default access policies at every microservice endpoint.
• Database-Level Scoping: Authorization is not just a UI filter; database queries automatically enforce tenant isolation and role permissions at the ORM layer.
• Audit-Ready Compliance: The RBAC specification lives in Git as versioned YAML, allowing security officers to audit access policies alongside code for SOC 2, HIPAA, and ISO 27001 compliance.

Perlite enforces enterprise security by construction directly in the compiler pipeline:

• Compiler-Enforced Multi-Tenancy: When an entity claims the MultiTenant trait, the compiler automatically injects tenant boundary scoping into every generated query and mutation (where: { tenantId }), making accidental cross-tenant data leaks impossible.
• Automated Field-Level Encryption: Sensitive attributes configured with encryption are automatically enveloped using AES-256-GCM. Plaintext is decrypted strictly at authenticated read boundaries and never stored unencrypted.
• Zero Proprietary Data Probes: Perlite does not proxy, ingest, or mirror customer records. Emitted microservices connect directly to your own VPC PostgreSQL databases with your internal secrets and KMS keys.

Perlite integrates natively with standard GitOps workflows—because the compiler outputs a standard, clean Git repository.

• Standard Git Push: Emitted microservices (NestJS backend, Prisma migrations, React TSX frontend) commit directly into your enterprise Git provider (GitHub, GitLab, Bitbucket).
• Zero Proprietary Runners: Your existing CI/CD automation (GitHub Actions, GitLab CI, ArgoCD) builds standard Docker containers and executes standard test suites (npm test).
• Deploy Anywhere: Deploy the resulting images directly into your existing Kubernetes clusters (AWS EKS, GCP GKE, Azure AKS, or bare metal) via standard Helm charts with zero proprietary cloud bridges.

No. Unlike legacy low-code platforms (such as Mendix, OutSystems, or Salesforce) that charge escalating fees of $30 to $350+ per user each month, Perlite enforces $0 runtime seat licensing taxes.

Whether your emitted software serves 50 internal operators or 500,000 consumer users, you pay zero runtime royalties to Perlite. Your operational expenses are limited strictly to your standard cloud compute and database hosting.

Perlite licenses the developer studio and compiler tooling, not your running software or your users.

We believe taxing you per employee, per customer, or per server touching your running production software is an extractive legacy model that penalizes your growth. Instead, we monetize through predictable enterprise developer studio subscriptions (for architects and engineers using the visual canvas, compiler CLI, and custom trait generators) alongside enterprise co-development and support tiers.

Crucially, there is zero hostage pricing: even if you stop subscribing to Perlite, your emitted applications remain 100% yours to build, deploy, and run forever.

You experience zero operational disruption. Your emitted software is standard TypeScript, NestJS, and React stored in your own Git repositories.

Because Perlite does not inject proprietary runtime engines or telemetry kill-switches, your production systems will continue running, scaling, and compiling forever. Your engineering team can maintain, refactor, and extend the generated codebase using standard IDEs and developer tooling with zero vendor hostage risk.