Complete Feature Catalog

Create, read, update, delete, list, count, and aggregate. All generated from your table definitions with proper transaction handling.

Programmatic query construction with type-safe filters, joins, ordering, and pagination. No raw SQL strings scattered through your code.

RDBMS, MongoDB, API backends, filesystem storage. Same interface, swap implementations. Write once, deploy anywhere.

Proper connection management out of the box. No more debugging connection leaks or pool exhaustion under load.

Schema versioning and migration support. Deploy confidently knowing your schema changes are tracked and reversible.

Declarative transaction boundaries with automatic rollback on failure. Nested transactions, savepoints, and isolation levels.

Prevent concurrent update conflicts with version-based locking. No lost updates, no manual lock management.

Mark records as deleted without removing data. Automatic filtering, recovery options, and audit compliance.

Transparent caching layer for expensive queries. TTL-based invalidation, cache warming, and bypass options.

Every table automatically exposes RESTful endpoints. GET, POST, PUT, PATCH, DELETE with proper HTTP semantics.

Swagger/OpenAPI specs generated automatically. Your API is documented the moment you define it.

Optional GraphQL layer with automatic schema generation. Queries, mutations, and subscriptions from your metadata.

Built-in versioning support. Deprecate endpoints gracefully while maintaining backwards compatibility.

Configurable rate limits per endpoint, per user, per API key. Protect your services without custom middleware.

Automatic validation against your field definitions. Type checking, required fields, format validation all enforced.

Field-level response filtering based on permissions. Sensitive data never leaves the server.

Cursor-based and offset pagination out of the box. Consistent patterns across all endpoints.

Flexible cross-origin resource sharing. Per-endpoint or global configuration without middleware wrangling.

A complete admin interface from your metadata. Tables, forms, search, filters, bulk actions. No frontend code required.

Build dashboards with widgets, charts, and KPIs. Real-time data from your tables without custom reporting code.

Dynamic forms with validation, conditional fields, and custom layouts. Define in metadata, render automatically.

Full-text search, faceted filtering, saved searches. The UX your users expect without months of development.

Select multiple records, apply actions in bulk. Mass updates, deletes, and custom operations with progress tracking.

Works on desktop, tablet, and mobile out of the box. No separate mobile app development required.

Power user shortcuts for common actions. Navigate, search, and edit without touching the mouse.

Brand the admin UI with your colors and logo. Dark mode, custom CSS, and white-label options.

Edit records directly in table view. Quick updates without navigating to detail pages.

Username/password, OAuth 2.0, SAML, LDAP. Pluggable auth providers with session management built in.

Define roles, assign permissions, enforce everywhere. Table-level, record-level, and field-level security.

Users only see records they should. Automatic filtering based on ownership, department, or custom rules.

Hide or read-only specific fields per role. Sensitive data protected without duplicating your data model.

Generate, revoke, and rotate API keys. Scoped permissions per key for secure integrations.

Every change logged with who, what, when, and before/after values. Compliance-ready from day one.

Configurable session timeouts, concurrent session limits, and forced logout capabilities.

TOTP-based 2FA with backup codes. Enforce for specific roles or make optional.

Restrict access by IP address or CIDR range. Extra protection for sensitive admin functions.

Configurable complexity requirements, expiration, and history. Meet enterprise security standards.

CSP, HSTS, X-Frame-Options configured correctly. Pass security audits without custom middleware.

Multi-step business processes with state management. Approvals, escalations, and parallel branches.

Cron-based scheduling with retries, timeout handling, and failure notifications. Background tasks that just work.

Pre/post hooks on every operation. Validate, transform, or trigger side effects declaratively.

Define custom operations exposed in UI and API. Business logic that feels native to the framework.

Field-level and record-level validation. Required fields, formats, ranges, and custom business rules.

Derived values computed on read or write. Formulas, aggregations, and lookups without stored procedures.

Define valid state transitions declaratively. Prevent invalid status changes with clear error messages.

Multi-level approval chains with delegation. Timeout escalation and audit trail included.

Define complex business rules without code. Evaluate conditions and trigger actions dynamically.

Upload spreadsheets, map columns, validate data, import records. Error handling and rollback included.

Export any query result to CSV or Excel. Formatted, filtered, with custom column selection.

Generate PDF reports from templates. Invoices, statements, and custom documents from your data.

Mass insert, update, delete with progress tracking. Handle millions of records without timeouts.

Extract, transform, load between systems. Sync data across backends with conflict resolution.

Move old records to cold storage automatically. Keep your active tables fast without losing history.

Generate and email reports on a schedule. Daily summaries, weekly digests, monthly statements.

Pre-import validation with detailed error reports. Fix issues before they enter your database.

Merge data into document templates. Letters, contracts, and custom documents at scale.

Sortable, filterable, paginated tables with column customization. Virtual scrolling for large datasets.

Date pickers, rich text editors, file uploads, autocomplete. All the inputs you need, styled consistently.

Line, bar, pie, and area charts. Real-time updates and drill-down capabilities.

Hierarchical data display with expand/collapse. Drag-and-drop reordering for nested structures.

Drag-and-drop cards between columns. Perfect for status-based workflows.

Day, week, month views with event management. Recurring events and drag-to-reschedule.

Preview PDFs, images, and documents inline. No external viewers required.

WYSIWYG editing with formatting, tables, and images. Clean HTML output.

Display location data on maps. Clustering, custom markers, and geocoding.

Template-based emails triggered by events. SMTP, SendGrid, SES, and more.

Real-time notifications in the admin UI. Read/unread tracking and notification center.

Send text messages via Twilio or other providers. Perfect for urgent notifications.

Post to Slack channels on events. Custom formatting and interactive messages.

POST to any URL when events occur. Retry logic and delivery confirmation.

Let users choose how and when they receive notifications. Per-event and per-channel settings.

Complete data separation between tenants. Schema-based or row-based isolation options.

Users can belong to multiple tenants. Easy switching without re-authentication.

Per-tenant configuration, branding, and feature flags. One codebase, many customers.

Automate tenant creation with templates. Self-service signup or admin-controlled.

Aggregate data across tenants for super-admin views. Platform-level analytics.

Track usage per tenant for billing. Integrate with Stripe or custom billing systems.

Change metadata, see results immediately. No compile-deploy-restart cycle for configuration changes.

Full Java type safety from database to API. Catch errors at compile time, not in production.

IntelliJ and VS Code support. Autocomplete, refactoring, and navigation that understands your metadata.

Built-in query logging, performance profiling, and request tracing. Find bottlenecks fast.

In-memory backends, test data generators, and assertion helpers. Write tests without mocking everything.

Command-line utilities for common tasks. Generate metadata, run migrations, seed data from the terminal.

Generate entity classes, API clients, and TypeScript types from your metadata.

Run everything locally with SQLite. No Docker, no cloud services required to get started.

Auto-generate API docs, entity diagrams, and permission matrices from your metadata.

Write Java or Groovy scripts for complex logic. Full access to the qqq runtime.

Extend qqq with custom backends, auth providers, and UI components. Clean extension points.

Define your own field types with custom validation, rendering, and storage.

Add buttons and operations to the UI. Trigger any business logic from the admin interface.

Create reusable process steps. Compose complex workflows from simple building blocks.

Add custom endpoints alongside generated ones. Full control when you need it.

Outbound webhooks on any event. Notify external systems when data changes without polling.

Publish events to RabbitMQ, Kafka, or SQS. Async processing without custom queue management.

Send emails via SMTP, SendGrid, or SES. Templates, attachments, and delivery tracking included.

S3, GCS, Azure Blob, or local filesystem. Upload, download, and manage files attached to records.

Call external services from your processes. HTTP clients with retry logic and circuit breakers.

Connect to Okta, Auth0, Azure AD, or any SAML/OIDC provider. Enterprise auth without the enterprise pain.

Stripe integration for subscriptions and payments. Webhook handling and invoice management.

Sync with Salesforce, HubSpot, or Pipedrive. Bi-directional data flow.

Connect to SAP, NetSuite, or custom ERPs. Standard patterns for enterprise integration.

Admin interface in any language. Built-in translation management.

Dates, numbers, and currencies formatted per user locale. Automatic detection.

Right-to-left language support. Arabic, Hebrew, and other RTL languages work correctly.

Export/import translations. Integrate with Crowdin, Lokalise, or manage in-house.

Store and serve content in multiple languages. Fallback chains for missing translations.

Store in UTC, display in user timezone. No more timezone bugs.

Native Redis support for caching, sessions, and pub/sub. Connection pooling and cluster support included.

AWS ElastiCache integration for managed Redis or Memcached. Auto-discovery and failover handling.

Transparent caching of expensive database queries. TTL-based invalidation with manual cache busting.

Store user sessions in Redis for horizontal scaling. Sticky sessions not required.

Redis-based distributed locks for coordinating across instances. Prevent duplicate processing.

Pre-populate caches on startup or schedule. Avoid cold cache performance hits.

Automatic cache invalidation on data changes. Pattern-based and tag-based clearing.

Cache hit/miss ratios, latency percentiles, and memory usage. Tune your caching strategy with data.

L1 in-memory cache with L2 Redis backing. Fast local reads with distributed consistency.

Native support for RabbitMQ, ActiveMQ, and Amazon SQS. Produce and consume messages declaratively.

Publish events to topics, subscribe multiple consumers. Fan-out patterns without custom code.

Automatic routing of failed messages for investigation. Retry policies and manual reprocessing.

JSON, Avro, and Protobuf serialization. Schema registry integration for evolving message formats.

Trigger qqq processes from queue messages. Decouple request handling from processing.

Publish domain events to message buses. Build event-driven architectures with qqq.

Content-based routing and filtering. Send messages to the right queue based on payload.

At-least-once and exactly-once delivery semantics. Transaction outbox pattern built in.

Message counts, consumer lag, and throughput metrics. Alert on queue depth thresholds.

Kubernetes-ready liveness and readiness probes. Monitor database connections, memory, and custom checks.

Prometheus metrics out of the box. Request latency, error rates, and custom business metrics.

JSON logs with correlation IDs. Debug distributed requests across services and time.

12-factor config via environment variables. Same artifact, different configuration per environment.

Docker images that start fast and stay small. Ready for Kubernetes, ECS, or any container platform.

Graceful shutdown, connection draining, and rolling updates. Deploy without dropping requests.

Point-in-time recovery and automated backups. Never lose data.

Identify slow queries and bottlenecks. Built-in profiling for production debugging.

Configure alerts for errors, slow responses, or business metrics. PagerDuty, Slack, or email.