The Pipeline FrameworkFast Typed Function Chains on Quarkus

Key Features ​

The Pipeline Framework helps you build fast, forward-only flows of Java functions. A step is one function in the flow: it receives a typed input, produces a typed output, and lets TPF generate the REST, gRPC, local, or function-style code around it.

Runtime and Processing Model ​

• Reactive by default: Built on Mutiny so many items can move through the flow without blocking one thread per item.
• Why it matters: Better CPU utilization and higher compute density typically mean lower runtime cost for the same workload.
• Quarkus foundation: Uses Quarkus build-time generation and runtime patterns for production-grade services.
• Traceable flow: Preserve enough context to understand what produced each item and where it came from.
• Clear step shapes: Supports one-to-one, one-to-many, many-to-one, many-to-many, and side-effect steps.

Extensibility with Plugins ​

• Plugin-friendly model: Pipeline plugins add cross-cutting work without coupling business logic to infrastructure code.
• Why it matters: You can add cache, telemetry, persistence, and logging with less code churn in core services.
• Clear extension points: Use Using Plugins and the Aspect guide as primary references.

Integration and Deployment Flexibility ​

• Transport coverage: Automatic generation for gRPC, REST, and local in-process calls.
• Quarkus Dev Services workflow: Smooth local development with managed service dependencies (for example, PostgreSQL) in dev/test flows.
• Why it matters: Teams can adapt interfaces to consumers and platform constraints without rewriting core processing logic.
• Deployment layouts: Works across modular, grouped pipeline-runtime, and monolith layouts.
• Evolution path: Start with a monolith for speed, then break into services as scale and ownership boundaries grow.

Operations ​

• Built-in observability: Metrics, tracing, and structured logging are generated into the runtime shape.
• Resilience features: Health checks, retries, crash-surviving background execution, and dead-letter handling.
• Container-first packaging: Current delivery flow supports image builds with Jib for predictable CI/CD integration.
• Native compilation path: Quarkus native builds support low cold-start and efficient resource usage where needed.
• Why it matters: Teams get faster incident diagnosis, more predictable deployments, and lower operational overhead at scale.

Developer Experience ​

• Shared common module: Central place for entity and DTO definitions used across pipeline components.
• Type safety across the pipeline: Compile-time checks catch mismatched step input/output types early.
• Why it matters: Teams get safer refactors, fewer mapping mistakes, and faster confidence when changing domain models.
• Testability gains: Functional boundaries and generated transport layers make behaviour easier to isolate and test.
• Fast onboarding and testing: Design visually with Canvas and validate behaviour via Testing with Testcontainers.