What is Vertique?

Vertique is an opinionated Java 21+ framework built on Vert.x. It provides the full stack required to build bank-grade microservices:

• REST APIs. JAX-RS-annotated resources with request validation and error mapping.
• Typed service contracts. Contract-based service execution with generated injectable clients.
• Durable workflows. Resumable multi-step processes that survive restarts and can wait on signals, timers, or human decisions.
• Jobs. Cron-scheduled and delayed execution, in-memory or PostgreSQL-backed.
• Inbox/outbox messaging. Inbound and outbound messages recorded atomically with your business transaction.
• Compile-time DI. Dagger resolves the whole application object graph at build time.
• Security, typed configuration, and observability. Composed around the same foundation.

The framework grows out of years of building production microservices, carried forward into an explicit, non-blocking design.

Vertique core is open source under the EUPL-1.2 license.

Why Vertique

• Built for coding agents and humans. Both work from the same versioned contracts, generated application model, and compile-time guardrails. An agent’s miswiring is a build failure, the same as yours. See Working with coding agents below.
• Durable workflows, included natively. Light, Temporal-style durable execution is a framework module. Workflow instances are resumable, versioned, and persisted in PostgreSQL, and there is no separate orchestration cluster to operate.
• Failures move earlier. Dagger resolves your application’s object graph at compile time, and the framework’s own annotation processors emit diagnostics attributed to your source elements. A missing binding or a malformed contract fails the build before the application runs. A restrictive security annotation with no matching mechanism module fails application startup, so the request is never allowed through.
• Non-blocking by default. Your resources and services run on Vert.x event loops. Blocking work needs an explicit worker opt-in, which keeps it from landing on the event loop by accident.
• Fully composable. Include only what you need. Starters compose the foundation, and every other capability is a framework module your application component names explicitly. Your application wires only what it uses.

The supported path

Start from a generated application, grow it through starters, and wire anything else directly:

1. Generate an application from an archetype. An archetype produces a working, tested application skeleton: a pom.xml parented on the application parent, a Dagger application component and module, an example resource or service, a JSON configuration file, and an integration test.
2. Compose framework capability through starters. A starter is a single dependency that publishes exactly one public Dagger aggregate, composing a fixed set of framework capabilities behind one class name. Your application names the starter it needs, and you do not assemble that capability’s module list by hand.
3. Or do your own wiring with Dagger modules. Capabilities without a starter (security mechanisms, durable workflows, jobs, inbox/outbox messaging, observability) are composed by naming the framework’s Dagger modules directly in your own application component. Any capability can be wired this way when you want finer control than a starter’s fixed set.

See Application model for how starters and direct modules fit together, and Workflows for a worked example of composing capability without a starter.

Working with coding agents

Vertique is designed so humans and coding agents work from the same versioned contracts, generated application model, compile-time guardrails, and executable verification paths. The companion vertique-skills repository packages that design for agent harnesses (Claude Code, Codex CLI, GitHub Copilot, and Cursor). It answers module questions from the canonical reference inside the exact artifact versions your application resolves, alongside starter and archetype selection guidance. Generated wiring, typed configuration, compiler failures, and executable tests remain the authority on what the code does. See Agent skills for setup and example questions.

Next steps

Start here:

• Quickstart: generate a REST application, run its tests, start it, and call its hello endpoint.
• Agent skills: give your coding agent framework knowledge matched to your dependencies.
• Application model: how the launcher, your application’s Dagger component/module, generated modules, and starters fit together.
• Dependency injection: basic Dagger concepts and Vertique’s generated registration bindings.

Build features:

• Configuration: JSON configuration sources, typed configuration, and secret providers.
• JSON and profiles: reuse named mapping policies across APIs, clients, and messaging.
• REST APIs: add a JAX-RS resource with request validation and error mapping.
• REST clients: call HTTP services through typed asynchronous interfaces.
• Services: define a typed contract and call it through generated execution wiring.
• AOP and events: compile-time aspects and typed in-process events.
• Persistence: add PostgreSQL, own your migrations, and manage transactions.
• Workflows: choose between durable workflows, jobs, and inbox/outbox.
• Kafka: consume topics into service operations and produce through typed interfaces.
• Security: baseline authentication, authorization, and safe defaults.
• MCP: publish generated Java methods as governed tools over Streamable HTTP.
• Observability: health probes, metrics, tracing, and correlation.

Ship and verify:

• Testing: generated-project tests, test utilities, and focused/full Maven commands.
• Deployment: package, configure, and run a Vertique application.
• Code generation: what every annotation processor generates, and where.
• Artifacts: the parent, BOM, starters, archetypes, and how to discover them.

Continue reading

• Next: Quickstart