Skip to main content
José David Baena

Kafka Reliability Field Guide

Reliable publishing, consumption, and recovery—one guarantee boundary at a time.

Reviewed 2026-09-08. Reference profile apache-java-4.3.1: Apache Kafka and Java client 4.3.1, KRaft, record magic 2, ordinary transaction protocol v2, and transaction.two.phase.commit.enable=false. Feature levels, protocol versions, settings, and binary versions remain separate facts.

Responsibility map

Start at the boundary that failed

This strip is not one total order. Progress and effects can happen in the wrong order; every lab makes that mismatch visible.

01

Application intent

Durable ledger or local memory?

02

Producer

Enqueue, retry, acknowledgement, knowledge

03

Kafka log

LEO, ISR, HW, LSO, markers

04

Consumer progress

Fetched, completed, requested, stored

05

Business effect

DB/API identity, retention, authority

Choose the reliability question in front of you

Each path pairs one canonical explanation with one deterministic counterexample and one next decision. The 13-part Kafka Engineering course keeps protocol depth and its existing order.

Default counterexample · D02

An idempotent producer does not protect an external effect

The server-rendered matrix below uses the same contract projection as the interactive explorer. It keeps capability, example result, counterexample, unknown evidence, and outside-profile outcomes distinct.

Application intent
Untracked local send
A process crash can erase the only copy before broker dispatch.
Publication evidence
idempotent-retry
The selected acknowledgement capability still depends on effective settings and failure assumptions.
Same-batch duplicate append
Conditionally protected
PID, epoch, partition, and sequence can recognize the same retained batch. A new send remains new work.
Transactional visibility
read_committed
HW, LSO, control records, and aborted ranges remain distinct exclusive boundaries.
Consumer progress
after-effect
Effect order alone does not make progress atomic or prevent gaps.
Business effect
Repeated effect possible
Kafka commit, abort, and ownership movement cannot retract or deduplicate the external effect.
Protection retention
UNKNOWN
Source retention does not preserve sink identity, authority, or schema meaning.
Recovery authority
1 unresolved obligation(s)
Resolve missing identity, retention, effect, and ownership evidence before effect-capable recovery.
Change the declared pipeline contracts

Kafka is not automatically a job system

Choose the interface from the lifecycle you need. None of these options makes an arbitrary HTTP, email, or database effect atomic with Kafka.

Transport choices by required lifecycle.
InterfaceStrong fitBoundary to keep explicit
Partitioned stream + traditional groupReplayable ordered history, independent subscribers, stream processingPartition ownership, application concurrency, completed-prefix commits, and sink effects
Share groupCooperative record acquisition and acknowledgement with more consumers than partitionsAcquisition expiry, acknowledgement commit, ordering, renewal, and business-effect protection
Dedicated job/workflow systemScheduling, priority, cancellation, leases, orchestration, and operator workflowsActual product-specific durability, retry, effect, and replay contracts

Six surfaces, 72 bounded scenarios

Curated actions feed pure TypeScript reducers. Controls can change policy and bounded inputs; invariant results come from state, not a disconnected expected-answer field.

K1 · Contract Explorer · 6 scenarios
  • D01 · P0

    Local acceptance is not publication evidence

    What can a local enqueue or acks 0 establish?

  • D02 · P0

    Producer idempotence stops before the external effect

    Does an idempotent producer protect an unprotected API call?

  • D03 · P0

    Kafka output and progress share a bounded decision

    What does a same-cluster read-process-write transaction protect?

  • D04 · P0

    Outbox and inbox protect local transaction boundaries

    Which identity can a local DB transaction protect?

  • D05 · P0

    Unknown effect evidence blocks automatic retry

    Can an uncertain response with unknown retention justify replay?

  • D06 · P0

    A topology change invalidates ordinary-profile conclusions

    Which independent review replaces the Apache same-cluster profile?

K2 · Publishing · 14 scenarios
  • P01 · P0

    Crash before dispatch and application wait expiry

    Did a returned send call create durable publication evidence?

  • P02 · P0

    Acks 0 branches look identical to the caller

    Can the caller distinguish broker delivery from a dropped request?

  • P03 · P0

    Leader-local success can leave an uncommitted tail

    What survives when an acks 1 leader fails before replication?

  • P04 · P0

    Acks all waits on the current ISR

    Does replication factor or min-ISR determine the response count?

  • P05 · P0

    Insufficient ISR rejects a fresh acks-all attempt

    Does rejection prove that no earlier ambiguous attempt appended?

  • P06 · P0

    ISR shrinks after append

    Can appended bytes coexist with timeout or post-append error?

  • P07 · P0

    Lost reply and identical idempotent retry

    How can two transmissions produce one append?

  • P08 · P0

    A second application send is new protocol work

    Does the same payload and key reuse the prior sequence?

  • P09 · P0

    A new producer session cannot infer old business intent

    Does a restart deduplicate an application resend?

  • P10 · P1

    Non-idempotent retries can reverse intended order

    What happens when a later batch succeeds before an earlier retry?

  • P11 · P1

    Supported sequences preserve partition/session order

    Which ordering scope does idempotence actually preserve?

  • P12 · P0

    Acks 1 can succeed while visibility remains stalled

    What does strict min-ISR change below the producer response?

  • P13 · P0

    Java resolves or rejects conflicting idempotence settings

    Does the selected configuration actually run idempotently?

  • P14 · P1

    Routing and writer changes break global-order shortcuts

    Can a partition-local guarantee survive a topology change?

K3 · Transactions & Visibility · 12 scenarios
  • T01 · P1

    Ordinary commit advances visibility after stable markers

    Which data appears under each isolation level?

  • T02 · P1

    Abort leaves bytes and offset gaps

    Why does visible count differ from offset span?

  • T03 · P1

    Replacement fencing stops old transactional progress

    What does fencing fail to undo?

  • T04 · P1

    Commit accepted, response lost

    Can the caller switch to abort after a timeout?

  • T05 · P1

    An open transaction blocks later ordinary data

    Why can replicated data remain hidden from read_committed?

  • T06 · P1

    Kafka output and source offsets recover together

    What waits when the prior checkpoint is still unstable?

  • T07 · P1

    Abort does not rewind fetched position

    What must the processing loop restore before retry?

  • T08 · P1

    Kafka abort cannot retract an HTTP effect

    What repeats when the input returns?

  • T09 · P1

    One decision can become visible at different times

    Does atomic commit promise simultaneous partition visibility?

  • T10 · P1

    Ordinary timeout and client wait are different clocks

    Which terminal operation may be repeated?

  • T11 · P1

    Stale group metadata cannot attach progress safely

    May the application commit offsets independently after failure?

  • T12 · P1

    Two-phase extension is outside the ordinary profile

    Which timeout conclusion must be withheld?

K4 · Traditional Consumer Progress · 12 scenarios
  • C01 · P0

    Commit the next offset

    Which checkpoint follows completed offsets 10 and 11?

  • C02 · P0

    The first unfinished record caps the frontier

    Can completed offset 12 justify skipping pending 11?

  • C03 · P0

    Last completed plus one can skip work

    What does normal recovery do after storing offset 13?

  • C04 · P0

    Known source gaps are not handler holes

    How does a delivered 10,12 batch advance?

  • C05 · P0

    Effect success and progress success are separate

    Can a synchronous commit make the effect atomic?

  • C06 · P0

    Assignment movement does not cancel an external request

    Can the old worker finish after a new owner replays?

  • C07 · P0

    Stale callbacks cannot advance the new incarnation

    Which ownership token qualifies a completion?

  • C08 · P0

    Pause bounds admission, not every byte

    Can one slow partition stop poll progress for another?

  • C09 · P0

    Shutdown drains only inside remaining authority

    What may be committed at the grace boundary?

  • C10 · P0

    Fetched auto-progress can outrun async handlers

    What does a crash skip after poll hands work away?

  • C11 · P1

    A newly invoked old snapshot can regress progress

    Is this Java callback reordering or application logic?

  • C12 · P1

    Poison data needs an explicit disposition contract

    May a deserialization failure advance progress automatically?

K5 · Effects / Outbox / Inbox · 10 scenarios
  • E01 · P1

    Outbox relay restart can publish twice

    Which stable identity survives the relay crash?

  • E02 · P1

    A naive dual write can lose notification intent

    What recovery record exists after the DB commit?

  • E03 · P1

    Inbox claim and DB mutation commit together

    Can two concurrent deliveries apply the mutation twice?

  • E04 · P1

    External effect survives local crash

    What can a replay repeat after the receipt is lost?

  • E05 · P1

    Provider identity and lookup can resolve repeated attempts

    Which assumptions produce one provider effect?

  • E06 · P1

    Same key with different intent is a conflict

    Did deduplication suppress a legitimate operation?

  • E07 · P1

    Replay can outlive effect protection

    What happens after the deduplication record expires?

  • E08 · P1

    Log coordinates and business identity are different

    Which identity survives a new publication occurrence?

  • E09 · P1

    Atomic source commit does not establish downstream order

    What changes after routing or topology moves?

  • E10 · P1

    Unavailable lookup keeps the effect unknown

    May recovery dispatch another effect-capable attempt?

K6 · Recovery / Retry / DLQ · 12 scenarios
  • R01 · P1

    Commit-first can lose quarantine

    What durable disposition exists after the crash?

  • R02 · P1

    Publish-first can duplicate quarantine

    Which provenance must a repeated DLQ record preserve?

  • R03 · P1

    One Kafka transaction can join DLQ and source progress

    Which participants share the decision?

  • R04 · P1

    Disposition failure is not permission to skip

    What must abort or stop when encoding or publication fails?

  • R05 · P1

    Retry topics can change processing order

    Which later record can complete first?

  • R06 · P1

    Nested retries consume one absolute deadline

    How many attempts fit before the stop condition?

  • R07 · P1

    Expired sink protection blocks automatic replay

    Can retained source data restore an expired effect contract?

  • R08 · P1

    History completeness and checkpoint existence differ

    Which recovery fact disappeared?

  • R09 · P1

    Original intent and a new operation are different actions

    Which identity should redrive preserve?

  • R10 · P1

    Missing evidence produces an investigation, not permission

    Which obligation blocks effect-capable recovery?

  • R11 · P1

    Canary success is one bounded observation

    Which stop and verification conditions still remain?

  • R12 · P2

    Cross-cluster failover needs an independent authority review

    Which record, checkpoint, identity, or writer authority disagrees?

K4 advanced · Share Acquisition · 6 scenarios
  • SG01 · P2

    One partition can supply records to two share consumers

    Which traditional ownership assumption no longer applies?

  • SG02 · P2

    An expired acquisition can repeat an external effect

    What happens without a committed acknowledgement?

  • SG03 · P2

    Local accept and server acknowledgement are separate

    What does a lost acknowledgement response leave unknown?

  • SG04 · P2

    Release, reject, and archive are not a universal DLQ

    Which record state follows each acknowledgement type?

  • SG05 · P2

    Renewal extends a lock under a bounded group contract

    Does renewal create permanent authority?

  • SG06 · P2

    Share isolation is a group-wide contract

    Which records remain unavailable behind an open transaction?

Advanced profiles stay independently bounded

A Kafka version label never creates cross-client, cross-cluster, vendor, ELR election, or two-phase-extension parity.

primary

Apache Kafka Java client 4.3.1

26b251a451ce941d3d7a55e6487bcb7f16b5ad48

Established scope

  • Producer configuration resolution, acknowledgements, idempotent retry identity, and ordinary transactions.
  • Classic and KIP-848 traditional consumer contracts described by the pinned client and server sources.
  • Share-consumer API/configuration behavior only where the F08 manifest records an observed case.

Not established

  • Managed-service availability, vendor-compatible behavior, correlated power-loss durability, or arbitrary external-effect atomicity.
  • The transaction two-phase-commit extension, which is disabled in the ordinary profile.

bounded extension

franz-go 1.21.6 bounded profile

b8814509d953ce8aa241a05a9c8c8fea4d259118

Established scope

  • The recorded fixture compiled against Go 1.26.5 and franz-go v1.21.6.
  • Basic idempotent production and committed group consumption passed against the isolated Apache Kafka 4.3.1 fixture on 2026-09-08.
  • Client-specific defaults remain labelled: idempotent production is enabled by default, linger is zero by default, and the default group balancer is cooperative-sticky.

Not established

  • Parity with Apache Java timeout, callback, rebalance, or transaction exception semantics.
  • Share-group support, vendor parity, every transaction schedule, or a production deployment recommendation.

Share groups

A different record-acquisition and acknowledgement model. SG01–SG06 and N6 are included; the UI gate follows F08.

ELR deeper election paths

The guide includes strict min-ISR and ELR limits, then links the replication owner. It does not implement the complete election algorithm.

Two-phase extension

The ordinary profile disables it. D06/T12 prevent ordinary timeout conclusions from leaking into extension mode.

Cross-cluster and compatible brokers

F09 records one pinned, one-way Apache MirrorMaker read-cutover profile. D06/R12 still require independent record, checkpoint, identity, sink, writer-authority, and failback evidence for another topology. No vendor parity badge is emitted.

Runtime evidence is recorded fixture by fixture

Broker observations can corroborate one pinned schedule. They do not establish correlated-failure durability, every interleaving, a managed service, or an arbitrary provider.

F01

passed

Observed acks=0 without a broker offset, controlled Produce-response loss after append, one retained-batch retry append, and application/new-session duplicates.

F02

passed

Observed current-ISR acks=all, leader-only acks=1, frozen visibility below min-ISR, and fresh acks=all failure.

F03

passed

Observed open/commit/abort isolation, offset gaps, and controlled staggered participant visibility with one commit decision.

F04

passed

Observed fencing, pending stable-progress handling, proven commit with lost EndTxn responses, same-terminal retry, transactional offsets, and abort/seek recovery.

F05

passed

Observed pause, async snapshot regression, classic/cooperative/consumer profiles, bounded drain, ownership movement, stale effect, and stale metadata rejection.

F06

passed

Observed atomic business+outbox commit/rollback, duplicate relay publication after restart, scoped inbox concurrency, and a retained-operation provider stub.

F07

passed

Observed transactional DLQ+offset commit, nontransactional gaps, delete-retention readability loss, and compacted sparse offsets.

F08

passed

Pinned share acquisition, ack, release/reject, delivery limit, expiry, renewal, isolation, and correlated ACCEPT/RENEW response-loss fixtures passed.

F09

passed

Observed one-way Kafka 4.3.1 MirrorMaker replication, checkpoint synchronization, source loss, and manual target read cutover; writes and failback remain outside the profile.

The source ledger pins every high-consequence claim

Current method-level APIs and pinned definitions outrank simplified overviews. Source observation narrows a teaching profile; it does not become a universal client promise.

Review all 26 primary-source groups
  1. S01: Apache Kafka 4.3 release and source

    Release existence, upgrade notes, and share-group release status.

    Limit: Does not establish a deployment's feature levels or managed-service support.

    Kafka 4.3.1 / source commit 26b251a451ce941d3d7a55e6487bcb7f16b5ad48

  2. S02: Apache Kafka 4.3 producer configuration

    Acks, idempotence constraints, retries, batching, and timeout defaults.

    Limit: Java-specific defaults are not fleet recommendations.

    4.3 documentation and ProducerConfig.java at tag 4.3.1

  3. S03: KafkaProducer 4.3.1 API and source

    Transactional offsets, completion uncertainty, fencing, and asynchronous send.

    Limit: Timing-sensitive exception paths still require controlled fixtures.

    Apache Kafka tag 4.3.1

  4. S04: ProducerStateEntry 4.3.1

    Five retained recent batch metadata entries per producer-partition.

    Limit: This is not a business-ID ledger or complete recovery proof.

    Apache Kafka tag 4.3.1

  5. S05: Topic, broker, and Partition 4.3.1 definitions

    Min-ISR, HW advancement, pre/post-append paths, and retention settings.

    Limit: The teaching model intentionally bounds pending/maximal ISR and election behavior.

    Apache Kafka tag 4.3.1

  6. S06: Kafka 4.3 design: delivery and persistence

    Publishing/consumption guarantees, page cache, and external-store boundaries.

    Limit: Historical exposition is not a current performance measurement.

    Kafka 4.3 documentation

  7. S07: Eligible Leader Replicas

    ELR availability, defaults, and strict min-ISR rationale.

    Limit: Does not replace the complete election algorithm or failure-domain testing.

    Kafka 4.3 documentation

  8. S08: UnifiedLog last stable offset

    Exclusive LSO bounded by HW and the first unstable offset.

    Limit: A simple open-transaction description must still account for marker stability.

    Apache Kafka tag 4.3.1

  9. S09: KafkaConsumer and commit managers 4.3.1

    Position, next offsets, commits, callbacks, ownership, and stable offset fetch.

    Limit: Application completion and external effects remain application responsibilities.

    Apache Kafka tag 4.3.1

  10. S10: Apache Kafka 4.3 consumer configuration

    Auto commit, reset, static membership, poll limits, and group protocols.

    Limit: Use S08/S09 for the exclusive LSO boundary.

    Kafka 4.3 documentation

  11. S11: KIP-98: idempotence and transactions

    Producer identity, transactions, and control records.

    Limit: Current APIs and defaults come from the 4.3.1 sources.

    Accepted historical design

  12. S12: KIP-447: transactional consumer progress

    Consumer group metadata and stable transactional progress.

    Limit: Does not establish arbitrary older-client support.

    Accepted design corroborated by 4.3.1 source

  13. S13: Transaction protocol v2

    Feature-level activation, participant registration, and marker behavior.

    Limit: The two-phase extension is excluded from the ordinary profile.

    Kafka 4.3 documentation and KIP-890 source path

  14. S14: Consumer Rebalance Protocol

    KIP-848 GA status, switches, and policy ownership.

    Limit: Future migration plans are not shipped-release evidence.

    Kafka 4.3 documentation

  15. S15: KIP-932: Queues for Kafka

    Share acquisition, acknowledgements, and delivery attempts.

    Limit: Follow-on KIPs and current source override stale original details.

    Accepted design, corroborated by Kafka 4.2/4.3 releases

  16. S16: KafkaShareConsumer and share configuration 4.3.1

    Explicit/implicit ack state, current config names, and group isolation.

    Limit: Runtime schedules and errors require F08.

    Apache Kafka tag 4.3.1

  17. S17: KIP-1222 and KIP-1240 share follow-ons

    Renewal and per-group share controls.

    Limit: Acceptance alone does not prove provider availability or every wire version.

    Accepted follow-ons listed in Kafka 4.3 notes

  18. S18: Kafka Streams concepts and configuration

    Kafka-managed processing scope and exactly_once_v2.

    Limit: External side effects and physical invocation counts remain outside that scope.

    Kafka 4.3 documentation

  19. S19: Kafka Connect 4.3 and KIP-618

    Source/sink capability limits, task fencing, and error reporting.

    Limit: No unspecified connector or sink is certified.

    Kafka 4.3 documentation

  20. S20: Debezium outbox event router

    Outbox event ID, aggregate key, and routing shape.

    Limit: Does not establish universal connector EOS or failover behavior.

    Debezium 3.3.0.Final

  21. S21: PostgreSQL 18 transaction and INSERT semantics

    Local transaction boundaries and unique-conflict behavior.

    Limit: Identity and effect contracts still require explicit design and fixtures.

    PostgreSQL 18 documentation

  22. S22: AWS Builders' Library: idempotent APIs

    Caller intent identity, semantic equivalence, and atomic token/effect.

    Limit: Not a universal provider contract.

    Reviewed 2026-09-08

  23. S23: AWS transactional outbox pattern

    Dual-write gaps, duplicate publication, and downstream obligations.

    Limit: AWS guidance is not Kafka runtime evidence.

    Reviewed 2026-09-08

  24. S24: Apache Kafka 4.3 monitoring

    Profile-specific producer, broker, and consumer observations.

    Limit: Metrics do not count completed business operations by themselves.

    Kafka 4.3 documentation

  25. S25: Kafka 4.3 cross-cluster mirroring

    MirrorMaker replication and its bounded EOS mode.

    Limit: A replication leg is not one cross-cluster application transaction.

    Kafka 4.3 documentation

  26. S26: Kafka 4.3 message format and Java support

    Batch/control records, offset gaps, and supported Java runtimes.

    Limit: The browser model is not a binary codec or storage benchmark.

    Kafka 4.3 documentation

Every public guarantee statement has a bounded owner

Review all 28 claim mappings
  1. G01 · documented-contract

    Local producer enqueue is neither broker acknowledgement nor a durable application-intent ledger.

    Limit: A separately durable outbox can establish a different application boundary.

    Sources S02, S03, S23 · scenarios D01, P01

  2. G02 · documented-contract

    Acks 0 supplies no broker receipt proof, acks 1 supplies leader-local evidence, and stable-profile acks all waits on the current ISR.

    Limit: This does not establish per-record media flush or every election outcome.

    Sources S02, S05 · scenarios P02, P03, P04

  3. G03 · source-observation

    Min-ISR is not an acknowledgement count chosen from replication factor; under the pinned source it also constrains new HW progress.

    Limit: The model bounds pending/maximal ISR and does not implement the full election algorithm.

    Sources S05, S07 · scenarios P04, P05, P12

  4. G04 · documented-contract

    A negative, timed-out, or unobserved producer result can coexist with appended bytes.

    Limit: The exact branch depends on action order and observed evidence.

    Sources S03, S05 · scenarios P06, P07

  5. G05 · documented-contract

    Replication acknowledgement is not per-record fsync on every disk or proof against correlated failure.

    Limit: A single-machine fixture cannot establish failure-domain durability.

    Sources S06, S07 · scenarios P03, P04

  6. G06 · source-observation

    Producer retry identity is PID, epoch, partition, and record sequence—not payload or business identity.

    Limit: The recent batch window is bounded and session-scoped.

    Sources S02, S03, S04, S11 · scenarios P07, P08, P09, P13

  7. G07 · documented-contract

    Supported idempotent settings preserve their partition/session ordering scope; application resends, multiple writers, and routing changes need another contract.

    Limit: No global business order is inferred.

    Sources S02, S03, S26 · scenarios P10, P11, P14

  8. G08 · documented-contract

    Transactional initialization and fencing identify a writer incarnation, not a business operation.

    Limit: Already-dispatched external effects remain outside the fence.

    Sources S03, S11, S13 · scenarios T03, E08

  9. G09 · source-observation

    LSO is an exclusive unstable-transaction boundary bounded by HW, not an inclusive record count.

    Limit: Marker stability and aborted ranges remain explicit.

    Sources S08, S09 · scenarios T01, T02, T05

  10. G10 · documented-contract

    Control records, aborted ranges, compaction, and topology history can create valid offset gaps.

    Limit: Visible record count cannot be reconstructed from an offset span alone.

    Sources S09, S26 · scenarios T02, C04, P14

  11. G11 · documented-contract

    A commit-response timeout does not establish abort; terminal retry must preserve the chosen operation.

    Limit: No universal KafkaException classifier is implied.

    Sources S03 · scenarios T04, T10, R03

  12. G12 · documented-contract

    Kafka output and input progress can share one same-cluster transaction decision while participant visibility remains staggered.

    Limit: This is not a cross-partition snapshot or wall-clock visibility barrier.

    Sources S03, S11, S12, S13 · scenarios T06, T09, R03

  13. G13 · documented-contract

    Consumer fetched position does not rewind automatically after abort, and pending transactional progress is not a stable recovery checkpoint.

    Limit: Recovery must use the selected client and group protocol correctly.

    Sources S06, S09, S12 · scenarios T06, T07

  14. G14 · documented-contract

    Processing attempts may repeat even when committed Kafka output and progress meet the stated EOS contract.

    Limit: External effects and physical invocation counts remain separate.

    Sources S06, S18 · scenarios T06, T07

  15. G15 · operator-judgment

    Traditional consumers commit next-offset boundaries from completed owned work—not record count, fetched position, or the last out-of-order completion.

    Limit: The contiguous frontier is application logic over a complete delivery ledger.

    Sources S03, S09 · scenarios C01, C02, C03, C04, C10

  16. G16 · source-observation

    Java async commit callbacks follow invocation order; a newly invoked old snapshot is an application regression hazard.

    Limit: Do not invent callback reordering that the Java API excludes.

    Sources S09 · scenarios C11

  17. G17 · documented-contract

    Revocation, loss, and group fencing do not fence an external resource or cancel a dispatched effect.

    Limit: The external system needs its own identity, authority, or fencing contract.

    Sources S09, S14, S22 · scenarios C06, C07, C09, E04

  18. G18 · documented-contract

    Poll progress, heartbeats, static membership, and KIP-848 policy ownership are distinct versioned concerns.

    Limit: The browser does not implement a complete coordinator or scheduler.

    Sources S09, S10, S14 · scenarios C08, C09

  19. G19 · documented-contract

    An outbox closes a local DB intent gap but permits duplicate publication; event identity and routing remain explicit.

    Limit: The CDC option is a declared contract, not a connector certification.

    Sources S19, S20, S23 · scenarios E01, E02, E09

  20. G20 · documented-contract

    An atomic scoped inbox and DB mutation can protect one declared identity; an HTTP effect needs another contract.

    Limit: Fingerprint mismatch and retention expiry remain explicit failures.

    Sources S21, S22, S23 · scenarios E03, E04, E05, E06

  21. G21 · operator-judgment

    A retained source record can outlive deduplication protection, authority, or current schema meaning.

    Limit: Retention clocks and restore points are independent.

    Sources S05, S10, S22 · scenarios E07, E10, R07, R08, R09, R10

  22. G22 · documented-contract

    Nontransactional DLQ publication and source progress have loss/duplication windows; one same-Kafka transaction can join those Kafka participants.

    Limit: Redrive effects still need their own identity and authority contract.

    Sources S03, S19 · scenarios R01, R02, R03, R04

  23. G23 · operator-judgment

    Retry topics can change processing order, and a larger retry budget cannot resolve an unknown effect.

    Limit: The attempt arithmetic is a bounded upper bound, not a probability model.

    Sources S02, S09 · scenarios R05, R06

  24. G24 · documented-contract

    Offset lag, fetch lag, transaction visibility, and application completion deadlines answer different questions.

    Limit: No universal lag-to-time or lag-to-record-count conversion is valid.

    Sources S08, S09, S24 · scenarios C02, T05, R11

  25. G25 · documented-contract

    Streams, Connect, and MirrorMaker EOS modes each have narrower prerequisites than an end-to-end everything-once claim.

    Limit: Connector, sink, topology, and failover contracts remain profile-specific.

    Sources S18, S19, S25 · scenarios D03, D06, T08, R12

  26. G26 · documented-contract

    Share groups use record acquisition and acknowledgement state—not a traditional committed-prefix frontier.

    Limit: Interactive claims require the pinned F08 runtime evidence gate.

    Sources S01, S15, S16, S17 · scenarios SG01, SG02, SG03, SG04, SG05, SG06

  27. G27 · documented-contract

    Ordinary transaction timeout conclusions do not apply when the documented two-phase extension is enabled.

    Limit: The extension remains a bounded reference, not an executed engine.

    Sources S02, S13 · scenarios D06, T12

  28. G28 · operator-judgment

    Kafka-compatible and cross-cluster systems require independent behavior, identity, and authority evidence.

    Limit: No parity badge or universal failover conclusion is produced.

    Sources S25 · scenarios D06, R12

Keep the two field guides distinct

The Background Jobs Field Guide owns generic queue, lease, retry, outbox, payload, and SLO models. This guide adds Kafka-specific log, transaction, group progress, acquisition, and recovery boundaries.

Found a source conflict or a boundary that needs a tighter limit? Send a correction.