Tutorials

Tutorials walk you through building a real thing. Every tutorial here:

• starts from cephalon new and ends with a running, observable, deployable app.
• shows the full diff at each step — not just the happy-path snippet.
• explains the why behind each decision, not only the how.
• ends with a checklist of what to do next when the lesson is over.

If you’re new to CephalonEngine, start with Build your first app. Everything else assumes you’ve gone through it.

Tutorial library

Foundations

Build your first app

8-part series: scaffold a modular monolith, add a domain module with REST endpoints, plug in EF Core, wire observability, write tests, deploy.

Start the series Microservices

Build a microservice suite

Split a domain across multiple hosts with eventing, shared identity, and per-service observability. Includes Kubernetes deploy.

Build the suite SaaS

Multi-tenant SaaS

Tenant resolution, ambient context, durable membership/invitation governance, declared domain ownership, approval/remediation workflows.

Build the SaaS Transports

gRPC service

Stand up a gRPC service with unary + streaming, shared types, and observability that links the trace across the wire.

Build the service Transports

GraphQL API

Federate a GraphQL schema across modules, with auth and field-level resolvers driven by capabilities.

Build the API Eventing

Event-driven pipeline

Wolverine adapter, outbox, scheduled delivery, DLQ replay, process managers, and CDC capture.

Build the pipeline Data

CQRS + read-model projections

Split writes (Postgres) from reads (ClickHouse). Wolverine events bridge them via transactional outbox + idempotent inbox. Covers lightweight CQRS + pointers to full event-sourcing.

Build CQRS Observability

Full observability stack

OTLP collector + Grafana + Tempo + Loki, with per-backend dependency-health dashboards and SLO templates.

Build the stack Quality

Testing strategy

Composition smoke tests, behavior specifications, integration tests against real Postgres + Redis containers, contract tests for transports.

Adopt the strategy Ops

CI/CD pipeline

GitHub Actions reference pipeline: build, test, benchmark, container publish, manifest sign, deploy.

Set up CI/CD Edge

Edge-native delivery

Cephalon.Edge with Traefik or Kubernetes Gateway. Hot-path routing, edge-side caching, and signed module delivery.

Deploy at the edge Retrieval

Retrieval-augmented service

Cephalon.Retrieval with Qdrant + Postgres pgvector. Index, query, and trace the retrieval pipeline.

Build the service Agentics

Agentic workload

Cephalon.Agentics runtime services: task graph, tool registry, scheduled agents, agent-to-event handoff.

Build the agent

Tutorial conventions

Convention	Meaning
Step header	Each step is independently runnable. You can stop after any step and have a working app.
Full diff	We show the file before and after the change, not just the new lines.
”Why this works”	Architectural explanation of the change, so you can recreate it without the tutorial in front of you.
”Pitfalls”	Mistakes we made the first time so you don’t repeat them.
”What to do next”	Pointers to the related Guide / Reference page once you finish.

Companion repositories

Every tutorial has a matching tagged commit in github.com/Cephalon-Labs/CephalonEngine-Examples. If you get lost, check out the tag for the step you’re on and diff against your local copy.

Suggested learning path

  first-app ──┬── microservice-suite ──── multi-tenant-saas
              │
              ├── grpc-service ─────┐
              ├── graphql-api ──────┤
              ├── event-driven ─────┼── cqrs ── observability-stack ── ci-cd-pipeline
              │                     │
              ├── retrieval-rag     │
              └── agentic-workload ─┘

Pick the leaf that matches your delivery pressure first — everyone benefits from observability and testing strategy regardless of the shape.