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.

This track is ordered for sequential learning. Start from the first part if you want the full mental model, or jump directly into a chapter if you already know the foundations.

START FROM PART 01 JUMP TO LATEST PART

Total Parts

Reading Load

534

MIN TOTAL

Estimated Commitment

8.9 HOUR LEARNING TRACK

32 PARTS534 MIN TOTALamqpapi-catalogapi-contractapi-designapi-governanceapi-versioning

Curriculum Map

Ordered progression from foundations to advanced topics

PART 0132 MIN

Kaufman Skill Map

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

PART 0230 MIN

Contract Taxonomy

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

PART 0324 MIN

Contract Invariants

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

PART 0420 MIN

Contract-First vs Code-First vs Consumer-First

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

PART 0519 MIN

OpenAPI Deep Model

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

PART 0620 MIN

HTTP Contract Semantics

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

PART 0722 MIN

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

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

PART 0817 MIN

Error Contract Engineering: Stable Failure Models for Distributed Consumers

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

PART 0920 MIN

API Versioning Strategy: Compatibility Before Version Numbers

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

PART 1015 MIN

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

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

PART 1115 MIN

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

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

PART 1218 MIN

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

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

PART 1318 MIN

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

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

PART 1418 MIN

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

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

PART 1513 MIN

AsyncAPI Deep Model: Describing Message-Driven APIs Across Protocols

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

PART 1617 MIN

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

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

PART 1717 MIN

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

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.

PART 1818 MIN

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

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

PART 1916 MIN

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

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

PART 2016 MIN

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

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.

PART 2112 MIN

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

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.

PART 2216 MIN

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

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

PART 2315 MIN

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

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

PART 2414 MIN

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

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

PART 2511 MIN

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

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

PART 2612 MIN

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

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.

PART 2712 MIN

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

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.

PART 2811 MIN

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

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

PART 2914 MIN

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

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.

PART 3014 MIN

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

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.

PART 319 MIN

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

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.

PART 329 MIN

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

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.