Schema governance without vendor lock-in

Schema registries store schemas. They don't govern them. event7 adds a provider-agnostic governance layer above Confluent, Apicurio, Karapace, and Redpanda, with a Docker-first deployment that works out of the box.

Any event-driven system of sufficient age accumulates schemas. Confluent Schema Registry, Apicurio, Karapace, Redpanda: the registry stores Avro, JSON Schema, or Protobuf definitions, enforces compatibility on version changes, and serves them over HTTP.

Then someone asks: who owns this schema? Which topics carry it? Does it follow naming conventions? When did it last change, and what broke downstream?

The registry has no answer. It was built to store, not to govern.

The governance gap

A schema registry is a storage engine. Ownership, classification, business context, validation rules, documentation, cross-reference tracking: none of this belongs to it. In practice, that metadata lives in a Confluence page last updated eight months ago, or in someone's head.

Confluent addressed this with Stream Governance: tags, business metadata, data contracts, validation rules, audit logs. For teams fully committed to Confluent Cloud, the problem is solved.

For teams running Apicurio behind self-managed Kafka, Karapace on Aiven, Redpanda's built-in registry, or multiple registries across environments... the governance metadata remains locked inside Confluent's proprietary layer.

What event7 does

event7 operates as a governance layer above the registry. It connects to Confluent, Apicurio, Karapace, or Redpanda, reads schemas, versions, and compatibility modes, then provides everything the registry does not.

Schemas remain in the registry. event7 stores governance data in its own database: enrichments, channels, rules, AsyncAPI specs. Disconnect event7 and the registry is untouched.

The feature set:

Schema Explorer : browse subjects, versions, and formats across registries. Visual diff with field-level breaking change detection.
References Graph : interactive dependency graph. See which schemas reference which, spot orphans and hotspots, trace transitive chains (Order → Customer → Address).
Governance Rules : define naming conventions, required fields, documentation rules, compliance checks. Four types: conditions, transforms, validations, policies. Built-in templates, or import your Confluent Data Contract rules.
Schema Validator : validate before publishing. One report, three checks: registry compatibility, governance rules, visual diff. PASS, WARN, or FAIL.
Channel Model : map schemas to channels across 22 broker types. Kafka topics, RabbitMQ exchanges, Redis streams, Pulsar, NATS, Google Pub/Sub, AWS SNS/SQS. N:N bindings with strategy, role, and data layer tagging.
AsyncAPI : bidirectional. Import an existing spec into event7 (creates channels, bindings, enrichments in one click). Or generate AsyncAPI 3.0 specs from your event7 data. Drift detection included: event7 tracks when a schema changed but the spec wasn't regenerated.
Governance Scoring : three-axis score (enrichments + rules + schema quality) with a confidence indicator. The catalog shows a governance funnel: how many schemas are fully governed vs. partially vs. not at all.
EventCatalog Generator : export governance data to EventCatalog. Scores, rules, channels, teams, AsyncAPI specs. The first governance-aware generator for EventCatalog.

The Docker-first approach

event7 ships as a Docker Compose stack. One command, five containers:

git clone https://github.com/KTCrisis/event7.git
cd event7
docker compose -f docker-compose.local.yml up -d --build

You get:

Service	Port	What it does
Frontend (Next.js)	3000	UI : Explorer, Catalog, Validator, Graph
Backend (FastAPI)	8000	API : 56+ endpoints, Swagger at /docs
Apicurio Registry	8081	Schema Registry (empty, ready to use)
PostgreSQL	5432	Governance data (auto-migrated)
Redis	6379	Cache (5-min TTL on registry calls)

The bundled Apicurio instance deserves attention. Teams running RabbitMQ, self-managed Kafka without a registry, or simply evaluating the tool get a working schema registry out of the box. Connect it in Settings, register schemas, governance is active.

Teams already running Confluent Cloud or an existing Apicurio skip the bundled registry and point event7 at their production instance. Same governance, same UI, no migration.

Two starting points

Starting from zero. Events flow through the broker, but no schema registry exists. The Docker stack provides Apicurio as a free, open-source registry (Apache 2.0). Schemas can be registered manually or by importing an AsyncAPI spec. Governance is immediate, no separate setup, no additional infrastructure.

Starting from Confluent. Hundreds of schemas already live in Confluent Schema Registry. Connect event7, and within seconds the subjects appear with visual diffs, dependency graphs, and governance scoring. Schemas stay in Confluent. event7 reads them through the Confluent API and stores governance data separately. Existing Data Contract rules (ruleSet + metadata) can be imported into event7's rule engine.

Both paths converge: a governed registry with enrichments, rules, channels, and AsyncAPI specs. The difference is whether the registry existed before or event7 brought one along.

Where it sits

event7 occupies a specific layer in the event-driven stack:

1  Infra / Broker         Kafka, RabbitMQ, Pulsar, NATS
2  Schema Registry        Confluent, Apicurio, Karapace, Redpanda
3  Governance             event7
4  Spec / Contract        AsyncAPI, CloudEvents
5  Documentation          EventCatalog, Backstage

Layer 3 is absent in most organizations. Teams jump from registry to documentation, when they document at all. Governance and contract specs are manual, vendor-locked, or missing.

event7 fills layer 3 and bridges to layers 4 and 5. It generates AsyncAPI specs and exports to EventCatalog. Governance data flows downstream automatically.

Provider-agnostic by design

Adding a registry provider means implementing one Python interface. No changes to services, routes, or frontend. The Apicurio provider was added this way: one file, one factory entry.

Supported registries: Confluent Schema Registry (Cloud and Platform), Apicurio Registry v3, and any Confluent-compatible registry (Karapace, Redpanda, Red Hat Service Registry). AWS Glue and Azure Schema Registry are on the roadmap.

Governance data is entirely decoupled from the registry. Enrichments, channels, rules, and AsyncAPI specs live in event7's PostgreSQL database. Switch from Confluent to Apicurio, and the governance layer survives intact.

What it looks like in practice

A typical workflow:

Open the Schema Explorer. Browse your subjects, check recent version changes.
Click a subject. See the schema, its evolution timeline, which channels use it, its governance score.
Before pushing a new version, paste it in the Validator. Get a report: registry compatibility check + governance rules + visual diff. One screen, three signals.
Check the Catalog for coverage gaps. Filter by "no enrichments" or "low governance score" to find schemas that need attention.
Open the References Graph to understand impact before a breaking change. If Address is referenced by Customer which is referenced by Order, you see the full chain.
Generate or refresh AsyncAPI specs. event7 detects drift: if a schema changed but the spec is stale, you see it immediately.

The entire workflow runs in event7, regardless of the underlying registry.

Open source

event7 is Apache 2.0. The core platform (Explorer, Catalog, Validator, Rules, Channels, AsyncAPI, EventCatalog Generator) is open source. Commercial tiers add managed deployment, provider sync, and enterprise controls.

The Docker stack with seed data provides a realistic evaluation environment in under five minutes. Connect a production registry to govern actual schemas.

event7 is open-source, built with FastAPI and Next.js. Docker Compose stack included. Works with Confluent, Apicurio, Karapace, and Redpanda.

← back to log_