Docs
Java · Vert.x · Compile-time DI

Focus on business logic, not the plumbing under it.

Build APIs, durable workflows, and background jobs on Vert.x. Contracts are typed, wiring is checked when you compile, and messages leave in the same transaction as your data.

See what it doesSee how it fits together
PricingService.javaJava
@ServiceContract(namespace = "shop", value = "pricing")
public interface PricingService {

    @Resilient(policy = "pricing")
    @Timeout(2_000)
    @Retry(maxRetries = 2, delayMs = 50)
    @CircuitBreaker(maxFailures = 5)
    Future<Quote> quote(QuoteRequest request);
}
The interface is the whole contract. Vertique generates the wiring, dispatches over the event bus with the request context, and enforces the timeout, retries, and breaker. Your implementation is just the pricing.
Built on familiar foundationsJava 21+Vert.xDaggerPostgreSQL
Built for the work behind the API

Keep your business moving.

Everything between the first request and the last step, with less plumbing for your team to own.

Resume where
the work left off.

A workflow can wait days for an approval, a signal, or a timer, and it picks up where it stopped after a restart. Its state lives in PostgreSQL, so there is no orchestration cluster to run.

✓Reserve inventorysaved
✓Authorize paymentsaved
○Await approvalwaiting
Durable workflows

Catch wiring mistakes
during the build.

Dependency injection happens at compile time, and contracts are checked there too. A missing binding or a malformed declaration fails the build instead of the deployment.

@ServiceContract
interface PaymentService { … }
✓ Bindings checked
✓ Contract validated
✓ Client generated
Compile-time guardrails

Keep events in step
with your data.

Outgoing messages are written in the same transaction as the business change. The relay retries delivery, and the inbox drops a message that arrives twice.

One transaction
Update order
Record outgoing event
Commit→Relay delivers
Transactional inbox / outbox

Call a service.
Keep your context.

A service call is a plain Java interface, dispatched asynchronously. The request context travels with the call, and timeouts, retries, and circuit breakers are declared on the contract.

Typed service contracts

Make background
work dependable.

Cron jobs and delayed jobs are coordinated across the cluster. A job that fails is recovered and retried, and one that keeps failing goes to a dead-letter queue.

Cron & delayed jobs

Follow the request.
Find the failure.

The same correlation context follows a request through the API, over the message bus, and into a workflow that resumes later. Logs, metrics, and traces all carry it. The observability modules are optional.

Correlation & observability

The same base for every service.

Pick the parts your application needs.

JAX-RS APIsREST clientRequest validationInput sanitizationResilienceCachingJWT securityTyped configurationSecret providersKafkaWebSocketLocalizationCompile-time AOPMCP server
The framework at a glance

See how it all fits together.

APIs, services, workflows, and messaging all sit on the same runtime. Use the parts you need and leave the rest out.

Vertique's architecture: inbound protocol adapters, a request pipeline of cross-cutting policies, a programming model on the Vert.x event bus, outbound clients and relays, observability and audit alongside, and a compile-time foundation over PostgreSQL, Redis, and Flyway
For coding agents and humans

Less guessing for coding agents.

In a typical framework an agent works from web docs written for some other version, wiring that is resolved at runtime, and mistakes that only show up when the service starts. Vertique puts those answers where an agent can read them, and the compiler checks the rest.

  1. 01
    The docs ship inside the jar.Every module carries its own reference, so the answer matches the version your build actually resolved.
  2. 02
    A companion skill reads them.The vertique-skills package gives Claude Code, Codex CLI, GitHub Copilot, and Cursor a skill that answers module questions from those references and helps pick a starter or archetype.
  3. 03
    Mistakes fail the build.Wiring is generated at compile time and configuration is typed, so a missing binding or a bad declaration is a compiler error the agent sees right away, not a failure at startup.
Commercial Extensions

Make audit evidence consistent.

One capture policy and one redaction policy apply at every supported boundary, and the result is a structured record delivered to your audit sinks.

CaptureRedactDeliver