SERIES_OVERVIEW // CURRICULUM_MAP

Learn Java API Contract Engineering, Event Contract Engineering & Schema Governance

// Kaufman skill map untuk menguasai contract engineering sebagai disiplin engineering, bukan sekadar dokumentasi API atau schema file.

32 Lessons534 Min Total04 Phases

This overview is designed to help you choose the right entry point quickly. Follow the full track from lesson one, continue from your last checkpoint, or jump straight into a phase that matches what you need right now.

Start From First Lesson Open Curriculum Map

amqpapi-catalogapi-contractapi-designapi-governance+86 more

Phase 01 · Start Here Phase 02 · Build Core Phase 03 · Deepen Practice Phase 04 · Final Stretch

Curriculum Map

Navigate by phase, then choose the lesson that matches your current depth.

Kaufman Skill Map

32 min

Kaufman skill map untuk menguasai contract engineering sebagai disiplin engineering, bukan sekadar dokumentasi API atau schema file.

Contract Taxonomy

30 min

Taxonomy kontrak untuk HTTP API, RPC, event, command, query, webhook, batch, file, stream, schema, SDK, dan platform interface di enterprise Java systems.

Contract Invariants

24 min

Contract invariants yang harus dijaga agar API, event, schema, dan behavior antar sistem tidak berubah secara tidak sengaja.

Contract-First vs Code-First vs Consumer-First

20 min

Perbandingan contract-first, code-first, annotation-first, test-first, dan consumer-first sebagai source of truth contract di Java enterprise system.

OpenAPI Deep Model

19 min

OpenAPI sebagai executable API semantics, bukan sekadar dokumentasi endpoint; bagaimana mendesain HTTP API contract yang stabil, machine-readable, testable, dan governance-ready.

HTTP Contract Semantics

20 min

HTTP contract semantics untuk API engineer: method semantics, status code, headers, caching, conditional requests, optimistic concurrency, retry, dan idempotency sebagai contract surface.

Request and Response Design: DTO Boundaries, Validation Semantics, and Evolution Safety

22 min

Request and response design for stable Java API contracts: DTO boundaries, validation semantics, field lifecycle, data types, and evolution safety.

Error Contract Engineering: Stable Failure Models for Distributed Consumers

17 min

Stable error contract engineering for Java HTTP APIs: Problem Details, error taxonomies, retryability, validation errors, domain failures, compatibility, and governance.

API Versioning Strategy: Compatibility Before Version Numbers

20 min

API versioning strategy for Java platform engineers: compatibility-first evolution, deprecation, sunset, consumer capability negotiation, and migration governance.

OpenAPI in Java: Spring Boot, JAX-RS, Swagger Core, springdoc, and Generator Boundaries

15 min

Practical OpenAPI in Java: Spring Boot, JAX-RS, Swagger Core, springdoc, OpenAPI Generator, project structure, CI, and source-of-truth boundaries.

API Client Contract Engineering: Generated Clients, SDKs, Resilience, and Consumer Ergonomics

15 min

API client contract engineering for Java: generated clients, SDK wrappers, resilience semantics, error mapping, pagination, idempotency, and consumer ergonomics.

API Contract Testing: Provider Verification, Consumer Expectations, and Drift Detection

18 min

API contract testing for Java systems: OpenAPI validation, provider verification, consumer-driven contracts, Pact, Spring Cloud Contract, stubs, CI gates, and drift detection.

Event Contract Mental Model: Facts, Commands, Notifications, and State Transfer

18 min

Event contract mental model for Java engineers: facts, commands, notifications, state transfer, event identity, causality, correlation, ordering, and semantic compatibility.

Event Envelope Design: Metadata, Payload, Routing, Idempotency, and Observability

18 min

Event envelope design for Java event-driven systems: metadata, payload separation, routing, schema identity, idempotency, tracing, tenancy, data classification, and governance.

AsyncAPI Deep Model: Describing Message-Driven APIs Across Protocols

13 min

AsyncAPI deep model for Java event-driven systems: channels, messages, operations, servers, bindings, schemas, examples, governance metadata, and contract-first EDA documentation.

Kafka Event Contracts: Topic, Key, Partitioning, Ordering, Retention, and Replay Semantics

17 min

Kafka event contract engineering for Java systems: topic design, message keys, partitioning, ordering, retention, compaction, replay, consumer groups, poison messages, and DLQ semantics.

Avro Contract Engineering: Schema Resolution, Defaults, Union Types, and Evolution

17 min

Avro contract engineering for Java event-driven systems: schema resolution, writer/reader schemas, defaults, union types, logical types, aliases, namespaces, code generation, and schema evolution.

Protobuf and gRPC Contract Engineering: Tags, Presence, Editions, and Compatibility

18 min

Protobuf and gRPC contract engineering for Java: field numbers, presence, proto3, editions, reserved fields, enum evolution, oneof compatibility, service contracts, and generated code behavior.

JSON Schema for Contract Engineers: Constraints, Composition, Dialects, and Validation Boundaries

16 min

JSON Schema contract engineering for Java systems: constraints, composition, dialects, $id, $ref, $defs, validation boundaries, OpenAPI alignment, and schema governance.

Event Versioning and Compatibility: Additive Evolution, Semantic Breaks, and Migration Patterns

16 min

Event versioning and compatibility for Java event-driven systems: additive evolution, semantic breaks, consumer lag, replay compatibility, dual publish, upcasting, translation topics, and deprecation strategy.

Event Contract Testing: Producer Tests, Consumer Tests, Schema Registry Gates, and Replay Tests

12 min

Event contract testing for Java event-driven systems: producer tests, consumer tests, schema registry gates, golden event samples, replay tests, DLQ tests, Testcontainers, and false-confidence traps.

Schema Registry Architecture: Subject Naming, Artifact Identity, Compatibility Rules, and Access Control

16 min

Schema registry architecture for Java event platforms: subject naming, artifact identity, compatibility rules, references, access control, environment promotion, metadata, and registry governance.

Compatibility Governance: Backward, Forward, Full, Transitive, and Semantic Compatibility

15 min

Compatibility governance for Java API and event platforms: backward, forward, full, transitive, structural vs semantic compatibility, exception handling, risk scoring, and compatibility decision records.

Schema Lifecycle Management: Draft, Review, Approve, Publish, Deprecate, Retire

14 min

Schema lifecycle management for Java enterprise platforms: draft, review, approve, publish, deprecate, retire, ownership, stewardship, changelog, migration notes, auditability, and workflow automation.

Contract Review Playbook: How Senior Engineers Review API, Event, and Schema Changes

11 min

Contract review playbook for senior Java engineers: API contract review, event contract review, schema review, compatibility review, security review, consumer ergonomics, and decision quality.

Contract Governance Automation: Linting, Diffing, Policy-as-Code, CI Gates, and Registry Hooks

12 min

Contract governance automation for Java platforms: lint rules, diff engines, policy-as-code, CI/CD gates, schema registry hooks, catalog sync, generated code checks, and automated risk classification.

Contract Diff Engineering: Detecting, Classifying, and Explaining Contract Changes

12 min

Contract diff engineering for Java platforms: AST-based diff, semantic classification, OpenAPI/AsyncAPI/Avro/Protobuf/JSON Schema/Kafka diffs, risk scoring, policy integration, and reviewer-friendly reports.

Enterprise API and Event Catalog: Discovery, Lineage, Ownership, Lifecycle, and Runtime Telemetry

11 min

Enterprise API and event catalog design: discovery, ownership, lifecycle, schema links, consumer inventory, lineage, governance dashboards, runtime telemetry, and integration with Java platform engineering.

Multi-Team Contract Operating Model: Ownership, Producer/Consumer Responsibilities, and Governance Rhythm

14 min

Multi-team contract operating model for Java enterprise platforms: producer and consumer responsibilities, ownership, governance roles, paved roads, review workflows, escalation, scorecards, and operating rhythm.

Runtime Contract Enforcement: Gateway, Service, Producer, Consumer, Registry, and Quarantine Controls

14 min

Runtime contract enforcement for Java APIs and event-driven systems: gateway validation, service validation, producer enforcement, consumer enforcement, schema registry, DLQ/quarantine, fail-open/fail-closed, and observability.

Contract Observability and Incident Response: Detect, Diagnose, Recover, and Improve

9 min

Contract observability and incident response for Java API and event platforms: metrics, logs, traces, violation dashboards, schema incidents, compatibility incidents, DLQ analysis, consumer lag, and governance feedback loops.

Capstone: Build a Java Contract Governance Platform for APIs and Events

9 min

Capstone project for top-tier Java contract engineers: build a contract governance platform for OpenAPI, AsyncAPI, Avro, Protobuf, JSON Schema, Kafka topics, schema registry, catalog, diff, CI gates, runtime enforcement, and observability.