Enterprise Roadmap

This roadmap outlines planned enterprise features for Cello Framework, based on research of industry-leading frameworks including Spring Boot, FastAPI, Django, NestJS, Actix-web, and Axum.

Timeline Overview

gantt
    title Cello Enterprise Roadmap
    dateFormat  YYYY-Q
    section Observability
    OpenTelemetry & Health Checks    :2026-Q1, 90d
    section Data Layer
    Database & Redis Integration     :2026-Q2, 90d
    section Protocols
    GraphQL & gRPC Support           :2026-Q1, 90d
    section Patterns
    Event Sourcing & CQRS            :2026-Q4, 90d
    section Production
    v1.0 Production Ready            :2026-Q1, 30d

---

v0.7.0 - Observability & Health (Q1 2026)

OpenTelemetry Integration

Full observability with the three pillars: traces, metrics, and logs.

from cello.telemetry import OpenTelemetryConfig

app.configure_telemetry(OpenTelemetryConfig(
    service_name="my-service",
    otlp_endpoint="http://collector:4317",
    sampling_rate=0.1,
    export_metrics=True,
    export_traces=True,
    export_logs=True
))

Features: - Distributed tracing with context propagation - Automatic instrumentation for HTTP, database, external calls - Metrics export via OTLP - Log correlation with trace IDs - Baggage propagation

Health Check Endpoints

Kubernetes-compatible probes.

from cello.health import HealthCheck

@app.health_check("database")
async def check_database():
    await db.ping()
    return HealthStatus.UP

# Auto-exposed:
# GET /health/live
# GET /health/ready
# GET /health

Features: - Liveness, readiness, startup probes - Dependency health checks - Custom health indicators - Health aggregation

---

v0.8.0 - Data Layer (Q1 2026)

Database Connection Pooling

High-performance async database connections.

from cello.database import DatabaseConfig

db = await Database.connect(DatabaseConfig(
    url="postgresql://localhost/mydb",
    pool_size=20,
    max_lifetime=1800
))

Supported Databases: - PostgreSQL - MySQL - SQLite - MongoDB (planned)

Redis Integration

Async Redis client with clustering support.

from cello.cache import Redis

redis = await Redis.connect("redis://localhost:6379")
await redis.set("key", "value", ttl=300)

Features: - Connection pooling - Pub/Sub support - Cluster mode - Sentinel support

---

v0.9.0 - API Protocols (Q1 2026)

GraphQL Support

Schema-first and code-first approaches.

from cello.graphql import Query, Schema, DataLoader

@Query
def users(info) -> list[User]:
    return db.get_users()

schema = Schema().query(users).build()
app.mount("/graphql", schema)

Features: - Subscriptions via WebSocket - DataLoader for N+1 prevention - Federation support - Playground UI

gRPC Support

High-performance RPC with protobuf.

from cello.grpc import GrpcService, grpc_method, GrpcResponse

class UserService(GrpcService):
    @grpc_method
    async def GetUser(self, request):
        return GrpcResponse.ok({"id": request.id, "name": "Alice"})

app.add_grpc_service(UserService())

Features: - Bidirectional streaming - gRPC-Web support - Reflection service - Interceptors

Message Queue Adapters

Event-driven architecture support.

from cello.messaging import kafka_consumer, Message, MessageResult

@kafka_consumer(topic="orders", group="processors")
async def process_order(message: Message):
    data = message.json()
    await process(data)
    return MessageResult.ACK

Supported: - Apache Kafka - RabbitMQ - AWS SQS/SNS - Redis Streams

---

v0.10.0 - Advanced Patterns (Q1 2026)

Event Sourcing

Event-driven persistence with aggregate roots, event replay, and snapshots.

from cello.eventsourcing import Aggregate, Event, event_handler, EventSourcingConfig

app.enable_event_sourcing(EventSourcingConfig(
    storage="postgresql://localhost/events",
    snapshot_interval=100,
    enable_replay=True,
))

class OrderCreated(Event):
    order_id: str
    customer_id: str

class Order(Aggregate):
    @event_handler(OrderCreated)
    def on_created(self, event):
        self.id = event.order_id
        self.status = "created"

Features: - Aggregate root pattern - Event replay to rebuild state - Snapshot support for performance - PostgreSQL, MySQL, and in-memory backends - Event versioning and upcasting

CQRS

Command/query separation with dedicated buses.

from cello.cqrs import Command, Query, command_handler, query_handler, CqrsConfig

app.enable_cqrs(CqrsConfig(enable_event_sync=True))

class CreateOrderCommand(Command):
    customer_id: str
    items: list

@command_handler(CreateOrderCommand)
async def handle_create(command, db):
    order = Order.create(command.customer_id, command.items)
    await db.save(order)
    return order.id

class GetOrderQuery(Query):
    order_id: str

@query_handler(GetOrderQuery)
async def handle_get(query, read_db):
    return await read_db.get_order(query.order_id)

Features: - Separate read/write models - CommandBus and QueryBus - Event-driven synchronization - Middleware support on buses

Saga Pattern

Distributed transaction coordination with compensation logic.

from cello.saga import Saga, SagaStep, SagaConfig

app.enable_sagas(SagaConfig(
    storage="postgresql://localhost/sagas",
    max_retries=3,
    timeout=300,
))

class OrderSaga(Saga):
    steps = [
        SagaStep("reserve_inventory", reserve, compensate=release),
        SagaStep("charge_payment", charge, compensate=refund),
        SagaStep("ship_order", create_shipment, compensate=cancel_shipment),
    ]

Features: - Automatic compensation on failure - Persistent saga state for crash recovery - Configurable retry with exponential backoff - Timeout support

---

v1.0.1 - Production Ready (Q1 2026)

Stable Release

First production-ready release with semantic versioning guarantees and major performance optimizations.

• API stability commitment (no breaking changes until v2.0)
• Handler metadata caching (async detection, DI params)
• Lazy body parsing, zero-copy responses, TCP_NODELAY
• Optimized release build configuration
• All 394 tests passing

---

v1.1.0+ - Future Enhancements (Planned)

OAuth2/OIDC Provider

Full OAuth2 server implementation.

from cello.oauth2 import OAuth2Provider

oauth = OAuth2Provider(config)
app.mount("/oauth", oauth)

Service Mesh Integration

Istio/Envoy support.

from cello.mesh import ServiceMesh

mesh = ServiceMesh(DiscoveryConfig(
    registry="consul://localhost:8500"
))

Admin Dashboard

Real-time monitoring UI.

app.enable_admin(
    path="/admin",
    features=["metrics", "routes", "health"]
)

Multi-tenancy

Tenant isolation and data partitioning.

from cello.multitenancy import tenant_context

@app.middleware
async def tenant_middleware(request, call_next):
    with tenant_context(request.headers["X-Tenant-ID"]):
        return await call_next(request)

---

Feature Requests

Have a feature request? Submit it on GitHub Issues.

We prioritize features based on: - Community demand - Enterprise use cases - Technical feasibility - Alignment with project goals

---

Contributing

Help us build these features! See our Contributing Guide.

Priority areas: - OAuth2/OIDC Provider - Service Mesh Integration - Admin Dashboard - Multi-tenancy

---

Sources & Research

This roadmap is informed by best practices from:

• Spring Boot 4 OpenTelemetry
• FastAPI Best Practices
• Actix-web Production Guide
• Axum Framework
• NestJS Enterprise Patterns