Copilots generate hundreds of files you have to review one by one. Weezzi works one layer up: AI shapes structures — tables, components, forms, columns — and the platform deterministically emits the entire codebase around them. Error-free. Every build.
A copilot answers one question at a time and writes one file at a time. Weezzi works at a different layer: AI describes the structure, the platform emits the entire codebase around it — and the same canvas lets you change scope across the whole project in one prompt.
AI never burns context generating boilerplate. The platform does that — instantly, deterministically, every time. AI focuses on what it's actually good at: shaping intent.
Most "build" time is the same plumbing repeated across every project. We've measured it. So we built a platform that generates it.
AI is great at exploring. Platforms are great at being right every time. Weezzi separates the two: AI shapes intent, the platform emits the deterministic structure — thousands of lines, error-free, every build.
Tables, indexes, FKs, migrations, connection pools, multi-DB cache, invalidation.
Entities, modules, queries, special queries, updaters, commands, lists, trees.
REST, GraphQL, OpenAPI, RBAC, multi-tenant isolation, audit, secrets vault.
Differentiating algorithms, custom integrations, domain rules — Java, Python, or JS.
L4–L2 are deterministic. Same input, same output. Every build. Forever.
Real applications repeat the same patterns. Weezzi ships them as first-class platform capabilities — you don't code an audit trail, a soft-delete, an admin table, a media field, or a live-editable hero. You declare what you need; the columns, services, queues, pages and admin UI come with it.
Structural fields every business app needs — declared once, generates columns, validation, indexes and admin UI together.
Timers, queues, AI calls, workflows — generated, registered, ready. You write business rules, never the plumbing.
You don't code admin pages. Tables, dashboards, settings screens, list/detail views, file managers — the patterns ship as first-class page types. Drop them in, configure, done.
Mark fields editable. Marketing edits the live site. No CMS to integrate, no editor to build, no developer time spent on copy changes — ever again.
Plus the foundation: PrimaryKey, ForeignKey, SiteId, Constants, Country / Region / City references — the small bricks the bigger patterns are built from.
SIMEL (Simple Expression Language) is the connective tissue. The same syntax for variable substitution, conditionals, loops, multi-language lookups, dynamic ORDER BY, dialect-aware LIMIT/OFFSET, and AI prompt templating. Learn it once. Use it everywhere.
Variable substitution, dictionaries, conditionals, loops — right inside the HTML. The same ${…} for everything you'd otherwise reach for a templating engine to do.
<div class="card ${IF#highlighted}is-featured${EndIF#highlighted}"> <h3>${title}</h3> <p class="tag">${?most_popular}</p> <img src="${|badge.webp}"> <ul> ${FOR#features} <li>${feature}</li> ${EndFOR#features} </ul> </div>
Same syntax, more guarantees. SQL-safe conditions auto-escape. Multilang joins are generated. Pagination adapts to the dialect — MySQL, Postgres, SQL Server, Oracle, ClickHouse.
${~…} escapes safelySELECT p.id, ${Multilang#p.name} FROM products p WHERE p.site_id = ${currentSite} ${~p.category_id = ${categoryId}} ${IF#onlyPromo} AND p.has_promo = 1 ${EndIF#onlyPromo} ${Orderby#default=p.order_field} ${limit#${pageSize}} -- MySQL, Postgres, SQL Server, Oracle, ClickHouse -- — the same SQL, generated for each.
Same expressions inside AI prompt templates and email templates. No separate templating engine, no string concatenation in code, no escaping bugs at the boundary.
${IF#}# Generate a confirmation message for ${customer.name}. Order ${order.id} placed on ${order.date}. Total: ${=format(order.total, currency)} ${IF#customer.is_vip} Greet them by first name and mention their VIP status. ${ELSE#customer.is_vip} Use a polite, formal tone. ${EndIF#customer.is_vip} Respond in ${customer.language}.
Variables, dictionary keys, computed expressions. Case-insensitive lookups with sub-attribute paths.
Conditionals with comparison operators. Iteration with built-in currentIndex and totalSize.
Auto-escaped fragments, multi-language joins, dynamic ordering, dialect-aware pagination — only valid in SQL.
Java and Scala are native on the JVM. Python runs on GraalPy. JavaScript & TypeScript run on GraalJS. The choice is per-element — one component in Java, the next in Python, a servlet in JavaScript, a service in Scala — all sharing the same context, security, transactions and cache. AI-assisted one-click conversion between them, when you want to switch.
// Same hook. Different language. Identical context. @Override public Order onBeforeCreate(Order o) { if (o.customer.isVip()) o.applyDiscount("VIP_15"); o.setRiskScore(fraud.score(o)); return o; } // Full breakpoints & stepping. Native JVM speed.
// Same hook. Different language. Identical context. function onBeforeCreate(order: Order): Order { if (order.customer.isVip()) order.applyDiscount("VIP_15"); order.setRiskScore(fraud.score(order)); return order; } // Transpiled to JS at build. Type-checked in canvas.
// Same hook. Different language. Identical context. function onBeforeCreate(order) { if (order.customer.isVip()) order.applyDiscount("VIP_15"); order.setRiskScore(fraud.score(order)); return order; } // Runs on GraalJS. Console & log debugging.
# Same hook. Different language. Identical context. def on_before_create(order): if order.customer.is_vip(): order.apply_discount("VIP_15") order.set_risk_score(fraud.score(order)) return order # Runs on GraalPy. Same Order entity. Same fraud service. # Same cache. Same RBAC. Same transaction.
// Same hook. Different language. Identical context. override def onBeforeCreate(order: Order): Order = { if (order.customer.isVip) order.applyDiscount("VIP_15") order.setRiskScore(fraud.score(order)) order } // Native JVM speed. Functional flair when you want it.
One component in Java for the JIT-hot path. The next in Python for an ML library. A servlet in JS for a quick integration. They all see the same entities.
Whichever language you pick, the element inherits the platform's session, security, transaction, cache and multi-tenancy — automatically.
Your Python data engineer can ship a backoffice dashboard. Your TS frontend can write a servlet. The platform doesn't care — and neither should you.
Other tools dump generated code into folders and ask you to read it. Weezzi exposes the application model on a visual canvas — drag a table, wire a timer to a queue, click a page to edit its columns, hover an entity to see every query that touches it. The code is there when you need it. The map is there always.
The Weezzi AI lives inside the canvas itself. A founder prompts “add a referral program.” A manager prompts “split orders by region.” A developer prompts “add a fraud-score column to Order, show it in the table, gate it on RBAC.” The canvas updates structurally. The platform regenerates the files. The whole project moves forward.
risk_team
Whether the prompt comes from a founder, a manager or a developer, the AI updates the same structural model on the same canvas. No translation between roles. No PRD passed over the wall. No "developer reads the spec and re-implements it."
Every Weezzi project is a Site (public-facing) and a Backoffice (administrative) sharing the same entities. The boring part of every business app — admin tables, forms, dashboards, menus, RBAC profiles — comes generated. You build the differentiating screens, not yet another “manage users” page.
First-class items in both sections: components, forms, tables, servlets, pages, dictionaries, menus, timers.
Dashboards live in backoffice only — for good reason.
No CMS to integrate. No editable-content schema to mirror. No documentation to write. Declare fields and properties on a component and the Site Editor renders the controls automatically — on the live application, in production, with multi-language and variations baked in.
fields: title: MultiLanguage badge: MultiLanguage amount: Price features: MultiLanguageList cta: MultiLanguage properties: highlighted: Boolean alignment: Alignment background: Background variations: - vip-visitors - first-time
That's the entire developer side. No CMS plugin. No editable-content adapter. No “please update the schema doc.”
Hover any field above. Marketing sees the same outline, in production. Translations switch with the language pill. Variations swap automatically based on visitor profile. You wrote no editor code.
Most stacks dump every string into /locales/en.json and ask you to keep it in sync forever. Weezzi inverts the model: dictionaries are nested by scope — project-wide globals, module-shared, element-local — and the same hierarchy applies independently to the Site and Backoffice sections. Local edits stay local. Shared things stay shared.
The outermost ring. Defines languages, default locale, and fallback chain for the whole app.
Strings shared across the whole project — brand name, country list, weekdays, error messages. null
Strings shared by the elements in one feature module — the Checkout module, the Blog module. Visible only there.
Each component, form, table, page or servlet carries its own dictionary, edited next to the element.
Public-facing copy: hero, CTAs, product descriptions, legal footer, transactional emails.
Internal labels: column titles, validation messages, admin menus, error toasts.
No build pipelines for routine changes. No server restarts. No cold starts. Edit a component, save it, and the change propagates to the running application instantly — preserving sessions and connections. The fastest feedback loop you've had in years.
<h3></h3> <p class="tag">Most popular ★</p> <div class="price"></div>
Sessions, websockets, and connection pools survive the deploy. Users notice nothing.
Dev, staging, UAT, QA, prod — each with its own hot-deploy flag. Discipline where you need it.
One server hosts many isolated apps. Hot-deploy one, the others continue serving.
Java-native, server-side rendered, multi-DB cache with parameter-keyed invalidation, dialect-aware queries, dynamic page loading, and multi-tenant isolation. The platform was built for production-grade business systems — the same engine that has powered Weezzi.com for years.
Server-side rendered with cache. Cold paths warmed by the JVM after seconds.
Edit to visible. Sessions and connection pools survive untouched.
Multi-tenant by default. Isolated configs, shared runtime, shared cache.
Standard Docker / K8s. No per-workload tax. No proprietary runtime fee.
Queries declare cache key parameters. Updaters declare the cache keys they affect. Partial updates don't blow the whole layer.
SPA-like navigation on a multi-page architecture. Subsequent pages fetch only the HTML they need; scripts and styles merge.
MySQL, PostgreSQL, MariaDB, MongoDB, ClickHouse. Pagination and ordering generated for the dialect. No portability tax.
HotSpot warms hot paths within seconds of traffic. After warm-up, render budget stays flat under load.
The platform was built for production from day one. Every generated query, servlet, page, queue handler and AI call is instrumented automatically. Tiered retention, runtime-editable dashboards, and Email/Slack alerts — configured visually, scoped per environment.
Observability isn't a vendor lock-in. Run it on Weezzi Cloud, or export the whole telemetry stack into your own Docker / Kubernetes. Same dashboards, same alerts, same trace UI — in your infrastructure, on your S3 buckets, behind your VPN.
Hosted by Weezzi. Zero setup. Logs, traces, metrics, alerts — all in the canvas. Pay per retention tier.
Self-host the whole telemetry stack. OpenTelemetry-compatible. Your S3, your retention, your VPN. You own the whole scope.
The Site Editor lives inside the deployed application. At build time you mark which fields, properties, and variations are editable. From there, marketing operates copy, images, layouts, multi-language fields, A/B tests and personalization — on production. Your inbox stops filling up with one-line copy changes.
Click the text. Type. Hit save. Live in milliseconds.
Same screen. Per-locale fields. No new deploy.
Drop a component, schedule a window, publish.
Two variants, traffic split, results in dashboards.
A Weezzi project is not a frontend with a Supabase tacked on. It's a full backend with the subsystems serious products always need — configured visually, generated deterministically, deployed together.
Every table optionally exposed as REST and GraphQL with auto-generated OpenAPI docs. Per-operation RBAC built in.
Query cache with key parameters and fine-grained invalidation. Updaters declare their cache keys; partial updates don't blow the whole layer.
RabbitMQ, Kafka, Redpanda, Pulsar, NATS, Redis, ActiveMQ, IBM-MQ, AWS SQS, Azure ServiceBus, GCP PubSub. Auto-registered, with generated send methods.
AI Container abstracting OpenAI, Anthropic, Grok, Gemini, Ollama, Azure OpenAI. Vector RAG (Milvus) and Graph RAG (Neo4J) per use-case. BYOK at €0.
Pick Java, Scala, Python (GraalPy), JavaScript or TypeScript (GraalJS) per component, form, table, or servlet. One-click conversion between them.
Reusable test sequences with click, set-value, assertion, and custom-code instructions. Test cases compose sequences; runs are tracked.
Logs, traces, metrics with per-environment tiers. Email/Slack alerts wired in. Runtime-editable dashboards.
Encrypted credentials store. API keys, DB passwords, third-party tokens — referenced symbolically, never hardcoded.
Add Maven dependencies (groupId/artifactId/version) directly. Available across all elements. Custom JAR upload for the rest.
You don't have to start from a prompt. Import a Lovable / Bolt / v0 export, a no-code stack, or a traditional codebase. The platform extracts the structure — entities, routes, components, auth model — and regenerates the application inside the Weezzi model. The boring 80% becomes generated. The differentiating logic stays yours.
An AI-generated app, a no-code build, an old internal tool, or a hand-written codebase that needs to scale.
Extracts schema, routes, components, auth, content. Normalizes into the Weezzi application model.
Generated CRUD, REST + GraphQL, RBAC, multi-language, cache, dual-section. Extensible in Java/Python/JS. Yours to self-host.
Migration is optional — not required to adopt Weezzi. But it's the on-ramp for teams who already shipped something with a generation-first tool and now need a system.
Get early access to Weezzi Builder. Bring an existing project, start from a prompt, or import a Lovable / Bolt / v0 export — we'll regenerate it as a real production system you own.