What happens when a @KafkaListener throws an exception?
When a @KafkaListener method throws, the exception propagates to the listener container, not to your code. The container hands it to the configured error handler. If you configure nothing, that handler is DefaultErrorHandler, and its behavior is a policy decision you inherit without choosing it.
By default it does three things:
- Seeks back. It repositions the consumer to the failed record and to the unprocessed records from the same poll, so the next poll redelivers them in order.
- Retries a few times. The default back-off is a fixed back-off with zero delay and nine retries, which gives ten delivery attempts in quick succession.
- Logs and skips. When retries are exhausted, the default recoverer logs the failure at error level. The offset is then committed past the record and the consumer moves on.
Some exception types, such as deserialization and message conversion failures, are classified as not retryable. These skip the retry loop and go straight to the recoverer.
The consequence is that a poison message, one that will never succeed, disappears after a single log line. Nothing stores the payload, nothing alerts, and the committed offset means Kafka will not redeliver it. Unless you configure a recoverer that publishes to a dead letter topic or another durable store, you have silently dropped the record.
The rest of this guide rests on one distinction:
- Transient failures, such as a timeout or an unavailable dependency, may succeed if you retry.
- Permanent failures, such as invalid data or a violated business rule, will never succeed, so retrying them only delays the outcome.
Any team whose consumers carry orders, payments, or state changes needs an explicit policy for both cases.
How does Spring Kafka error handling work?
Error handling sits between the Kafka consumer and your listener method. The pieces are worth knowing by name, because every configuration option in this guide maps onto one of them.
The container loop
Each listener container runs a loop on its own consumer thread:
- It calls
poll()on the Kafka consumer and receives a batch of records. - It passes each record, or the whole batch for a batch listener, to a message listener adapter. The adapter converts the payload and invokes your
@KafkaListenermethod. - If the method returns normally, the container records the offset for commit according to the configured ack mode.
- If the method throws, the adapter wraps the exception in a
ListenerExecutionFailedExceptionand the container passes it to itsCommonErrorHandler, together with the failed record, the records remaining from the poll, and the consumer.
The error handler runs on the same thread as the listener. Whatever it does, whether it waits, seeks or publishes, happens before the next poll.
Inside DefaultErrorHandler
DefaultErrorHandler is one implementation of CommonErrorHandler. For a record listener, it does the following on each failure:
- Classifies the exception. It walks the cause chain and checks the exception type against its not-retryable set. A not-retryable exception goes straight to recovery.
- Tracks attempts. It keeps a per-record failure count keyed by topic, partition and offset. This count survives redelivery because the same record comes back at the same offset.
- Applies the back-off. It asks the
BackOfffor the next interval. If the back-off returns a value, the handler waits that long and then seeks every partition with unprocessed records back to the earliest unprocessed offset, so the next poll redelivers the failed record and everything after it. - Recovers. When the back-off is exhausted, the handler calls its
ConsumerRecordRecoverer. That may be the default logging recoverer, aDeadLetterPublishingRecoverer, or your own implementation. If recovery succeeds, the handler seeks past the failed record and, by default, the container commits the recovered offset. If the recoverer throws, the record is treated as unrecovered and the seek-back repeats.
For batch listeners the flow is similar, but the handler needs a BatchListenerFailedException to know which record in the batch failed, as covered in the section on blocking retries.
Retry topics are a different path
@RetryableTopic does not retry on the consumer thread. On failure, the framework publishes the record to the next retry topic, adds headers with the attempt count and the earliest time the record may be processed, and commits the original offset. The consumer of the retry topic checks that due time. If the record arrives early, the consumer pauses the partition and seeks back, then resumes once the time has passed. The final hop publishes to a dead letter topic. The details are in the section on non-blocking retry topics.
How do you configure DefaultErrorHandler with back-off and a dead letter topic?
The fix for silent drops is an explicit policy for which failures get retried, how many times, and where a record goes when retries run out. In Spring Kafka, that policy is a DefaultErrorHandler bean, and Spring Boot's auto-configured listener container factory picks it up.
Back-off: how many attempts, how far apart
The handler takes a BackOff. FixedBackOff takes an interval and a maximum number of attempts. That count covers retries only, so a value of 2 means three deliveries in total. ExponentialBackOff grows the interval by a multiplier up to a maximum interval. Bound it explicitly, either with a maximum elapsed time or with the ExponentialBackOffWithMaxRetries variant. Otherwise a poison record can be retried for a very long time. Between attempts, the handler seeks the partition back to the failed offset and the container redelivers the record.
The recoverer and where records land
When retries are exhausted, the handler calls its recoverer. A DeadLetterPublishingRecoverer wraps a KafkaTemplate and, by default, sends the record to the original topic name with a .DLT suffix. It also uses the same partition number as the source record. Keeping the partition preserves locality for replay, but it means the DLT needs at least as many partitions as the source. If it has fewer, supply a destination resolver. The resolver can map to a different topic, or return a negative partition so the producer chooses one.
When the DLT publish fails
A missing topic, a nonexistent partition, an authorization error or a serializer that can't handle the payload all make the recoverer throw. The handler treats an exception from the recoverer as an unrecovered record. It seeks back again, so the record is not lost, but the partition stays blocked until the publish succeeds. Deserialization failures arrive as raw bytes, so give the recoverer a template with a byte-array serializer for them.
import org.apache.kafka.common.TopicPartition;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.listener.DeadLetterPublishingRecoverer;
import org.springframework.kafka.listener.DefaultErrorHandler;
import org.springframework.kafka.support.ExponentialBackOffWithMaxRetries;
@Configuration
public class KafkaErrorHandlingConfig {
// Spring Boot wires this bean into its auto-configured listener container factory.
@Bean
public DefaultErrorHandler errorHandler(KafkaTemplate<Object, Object> template) {
// Default resolver would send to <topic>.DLT on the SAME partition number.
// The DLT here has fewer partitions than the source, so keep the topic
// naming convention but let the producer choose the partition (-1).
DeadLetterPublishingRecoverer recoverer = new DeadLetterPublishingRecoverer(template,
(record, ex) -> new TopicPartition(record.topic() + ".DLT", -1));
// Bounded exponential back-off: 4 retries after the first failure,
// 1s, 2s, 4s, then capped at 5s. Five deliveries in total.
ExponentialBackOffWithMaxRetries backOff = new ExponentialBackOffWithMaxRetries(4);
backOff.setInitialInterval(1_000L);
backOff.setMultiplier(2.0);
backOff.setMaxInterval(5_000L);
DefaultErrorHandler handler = new DefaultErrorHandler(recoverer, backOff);
// Retrying cannot fix bad input; send these straight to the recoverer.
handler.addNotRetryableExceptions(IllegalArgumentException.class);
// If the DLT publish itself throws (missing topic, authorization, serialization),
// the record is treated as unrecovered: the handler seeks back and the partition
// stays blocked until the publish succeeds. Nothing is silently dropped.
return handler;
}
}
A DefaultErrorHandler bean that uses a bounded exponential back-off and a DeadLetterPublishingRecoverer whose destination resolver keeps the default .DLT topic name but returns partition -1, so the producer chooses the partition when the DLT has fewer partitions than the source topic.
Which exceptions should be retried and which should go straight to the DLT?
By default, DefaultErrorHandler retries every exception except a built-in list of failures that can never succeed on redelivery. That list includes deserialization and message-conversion errors. Extend it with addNotRetryableExceptions for your own permanent faults, such as a validation exception or a constraint violation that will fail the same way every time. addRetryableExceptions works in the other direction: it removes a type from the not-retryable set when you know it is transient in your system. The classifier inspects the cause chain, so an exception wrapped by the listener adapter is still matched.
Malformed payloads need separate handling. If the configured value deserializer throws, the failure happens inside poll(), before any listener or error handler runs. The consumer cannot advance past the record, so the partition is effectively stuck. To avoid this, configure ErrorHandlingDeserializer as the consumer's deserializer and set your real one as its delegate. It catches the failure, passes a null value along with the exception in a header, and the error handler then classifies it as not-retryable and sends it to the DLT.
| Misclassification | Effect | Cost |
|---|---|---|
| Permanent error marked retryable | Every attempt fails identically | Back-off delay per record, a blocked partition, lag growth |
| Transient error marked not-retryable | Records skip retries during a brief outage | A DLT flood that someone must replay |
Retries handle one record at a time. If a shared dependency is down, every record fails, and retrying each one only spreads the outage across the backlog. Use a circuit breaker, or pause the listener container until the dependency recovers.
@Configuration
class KafkaErrorConfig {
@Bean
ConsumerFactory<String, Object> consumerFactory() {
Map<String, Object> props = new HashMap<>();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-1.internal.example:9092");
props.put(ConsumerConfig.GROUP_ID_CONFIG, "orders-service");
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
// Wrap the real deserializer so a malformed payload becomes a null value plus an
// exception header, and the record reaches the error handler instead of failing in poll()
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, ErrorHandlingDeserializer.class);
props.put(ErrorHandlingDeserializer.VALUE_DESERIALIZER_CLASS, JsonDeserializer.class);
props.put(JsonDeserializer.TRUSTED_PACKAGES, "com.example.orders");
return new DefaultKafkaConsumerFactory<>(props);
}
@Bean
DefaultErrorHandler errorHandler(KafkaTemplate<Object, Object> template) {
// Exhausted or not-retryable records go to <topic>.DLT, same partition
DeadLetterPublishingRecoverer recoverer = new DeadLetterPublishingRecoverer(template);
// Transient failures: 3 retries, 1 second apart
DefaultErrorHandler handler = new DefaultErrorHandler(recoverer, new FixedBackOff(1000L, 3L));
// Permanent faults fail identically on every attempt, so skip retries.
// Deserialization errors are already in the default not-retryable set.
handler.addNotRetryableExceptions(
OrderValidationException.class, // your domain validation error
ConstraintViolationException.class // jakarta.validation
);
// Do NOT list exceptions from a shared downstream (timeouts, 503s) here:
// during an outage that would flood the DLT. Pause the container or use
// a circuit breaker for that case instead.
return handler;
}
}
A consumer factory that wraps a JsonDeserializer in ErrorHandlingDeserializer, plus a DefaultErrorHandler that sends validation and constraint failures straight to the dead-letter topic and gives other exceptions three spaced retries.
How do blocking retries affect the consumer, polling and rebalances?
With DefaultErrorHandler, retries happen on the consumer thread. When a record listener throws, the handler seeks the partitions back so the failed record and everything after it are fetched again. It then waits out the back-off before the next poll. While it waits, the thread is not polling, and Kafka cannot tell this apart from a stuck consumer. If the gap between polls exceeds max.poll.interval.ms (default five minutes), the consumer leaves the group. Its partitions are reassigned, uncommitted work is redelivered elsewhere, and the "retry" turns into a rebalance storm across the group.
Budget the worst case
Size the back-off against the poll interval, and leave room for the time spent processing the rest of the polled batch.
Illustrative estimate, with these assumed settings:
- Exponential back-off: initial interval 1 s, multiplier 2, max interval 10 s, five retries.
- Waits: 1 + 2 + 4 + 8 + 10 = 25 s.
- Each attempt calls an API with a 5 s timeout, over six attempts: 30 s.
- Worst case for one record: about 55 s.
That fits within five minutes. Raise the max interval to 60 s, or the retry count to 20, and it no longer fits. Keep any single wait short. Keep the total retry time well below the poll interval.
Head-of-line blocking
While one record retries, every record behind it on that partition waits. Ordering is preserved, but latency for the whole partition grows with the slowest failure. That is acceptable for brief, transient faults. It is the wrong trade-off when failures are slow or frequent.
Batch listeners
Batch listeners need their own design. If the listener throws without identifying which record failed (BatchListenerFailedException carries that index), the handler cannot commit the records that succeeded. It retries the entire batch, and when retries are exhausted it can dead-letter all of it, including records that were fine.
How do non-blocking retry topics work with @RetryableTopic?
Retry topics take the failing record off the main partition entirely. Instead of retrying in place, the framework republishes the record to a separate retry topic and commits the original offset, so the main consumer moves on to the next record. One limitation applies here: non-blocking retries do not support batch listeners. The batch problem described above has no shortcut through this mechanism.
orders ──fail──▶ orders-retry-0 ──fail──▶ orders-retry-1 ──fail──▶ orders-dlt
│ │ (wait ~1s) │ (wait ~2s) │
▼ ▼ ▼ ▼
ok ok → done ok → done @DltHandler
You enable this by annotating the listener with @RetryableTopic, setting the number of attempts and a @Backoff delay and multiplier. A method in the same class annotated with @DltHandler receives records that exhaust their retries. If you want one policy for many listeners, declare a RetryTopicConfiguration bean instead of repeating annotations.
The framework creates the retry and DLT topics with suffixes based on attempt index or delay value, depending on the suffixing strategy. Republished records carry headers that track the attempt count and the earliest time the record may be processed. Records sent to the DLT also get headers with the original topic, partition, offset, exception class and message.
Delays are approximate. A retry-topic consumer that reads a record before its due time pauses that partition, seeks back, and resumes later. The real delay therefore depends on poll timing and lag, not on a precise scheduler. Ordering across attempts is also lost, because a retried record can be processed after newer records for the same key.
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.common.header.Header;
import org.springframework.kafka.annotation.*;
import org.springframework.kafka.retrytopic.TopicSuffixingStrategy;
import org.springframework.kafka.support.KafkaHeaders;
import org.springframework.retry.annotation.Backoff;
import org.springframework.stereotype.Component;
import java.nio.charset.StandardCharsets;
@Component
public class OrderListener {
// attempts = 3 means 1 main delivery + 2 retries, giving orders-retry-0 and orders-retry-1.
// Backoff is 1s, then 2s. These are minimum waits, not exact schedules.
// Index suffixes are set explicitly so topic names do not depend on the version default.
@RetryableTopic(
attempts = "3",
backoff = @Backoff(delay = 1000, multiplier = 2.0),
topicSuffixingStrategy = TopicSuffixingStrategy.SUFFIX_WITH_INDEX_VALUE)
@KafkaListener(topics = "orders", groupId = "order-service")
public void onOrder(String payload) {
// Throwing here republishes the record to the next retry topic.
// The original offset is committed, so the orders partition keeps flowing.
process(payload);
}
// Receives records from orders-dlt after all attempts are exhausted.
@DltHandler
public void onDlt(ConsumerRecord<String, String> record) {
// The DLT publisher adds the original topic, partition, offset and exception details as headers.
Header msg = record.headers().lastHeader(KafkaHeaders.DLT_EXCEPTION_MESSAGE);
String reason = msg == null ? "unknown" : new String(msg.value(), StandardCharsets.UTF_8);
// Park the record for inspection or replay. Do not throw again here.
System.err.printf("DLT %s@%d: %s%n", record.topic(), record.offset(), reason);
}
private void process(String payload) { /* business logic that may throw */ }
}
This record listener uses @RetryableTopic with 3 attempts and exponential backoff to route failures through orders-retry-0 and orders-retry-1 to orders-dlt, where a @DltHandler reads the exception header added by the framework.
When should you use blocking retries, retry topics, or neither?
The choice depends on one question: may a failed record be overtaken by later records with the same key?
| Concern | Blocking retries (DefaultErrorHandler) |
Retry topics (@RetryableTopic) |
Neither (pause or handle in listener) |
|---|---|---|---|
| Per-partition ordering | Preserved | Lost for failed records | Preserved |
| Throughput while failing | Partition stalls | Main topic keeps flowing | Stalls by design (pause) or unaffected |
| Topic provisioning | DLT only | Retry topics plus DLT per source topic | None extra |
| Operational overhead | Low | More topics, lag and ACLs to watch | Health checks and resume logic |
| Development cost | Low | Moderate | Highest, all custom |
Avoid retry topics when downstream consumers depend on key order. Account balances and state machines are examples. If version 2 of an entity is retried after version 3 is applied, the stale write wins.
Avoid both during a dependency-wide outage. When the database is down, every record fails. Blocking retries exhaust their attempts and fill the DLT. Retry topics do the same, and they also multiply the write traffic. It is better to detect the outage, for example with a circuit breaker around the dependency, and pause the listener container until a health check passes. At very high volume, retry topics add extra produce and consume work for each failure, which can overload the cluster at the worst moment.
Some failures are expected business outcomes, such as validation rejections. Handle those inside the listener and route them explicitly instead of throwing.
Every approach is at-least-once. A retry reruns the whole listener, so side effects that completed before the exception will run again. Examples are a committed insert or an outbound HTTP call. Make handlers idempotent with upserts, idempotency keys, or a deduplication table keyed by business ID.
What are the alternatives to DefaultErrorHandler and retry topics?
The two built-in mechanisms cover most consumers, but they are not the only options. Each alternative below trades framework support for control.
- Retry inside the listener. Wrap the call that may fail in a loop or a Spring Retry
RetryTemplateand catch the exception yourself. The container never sees the failure. This is fine for a short, local retry around one downstream call, but the same polling budget applies: a long in-listener retry still blocks the consumer thread and can exceedmax.poll.interval.ms. You also lose the framework's attempt tracking and DLT headers unless you rebuild them. - Catch, route and continue. Catch the exception in the listener and publish the record yourself with a
KafkaTemplate, to a DLT, a review topic or a "parked" topic. This suits expected business rejections, where throwing would be misleading. You become responsible for adding the context headers thatDeadLetterPublishingRecovererwould otherwise add. - A custom recoverer. Keep
DefaultErrorHandlerfor the retry loop but give it your ownConsumerRecordRecoverer, for example one that writes failed records to a database table that an operations tool can query and replay. The handler semantics stay the same: if your recoverer throws, the record is not considered recovered and the partition stays blocked. - Stop or pause the container.
CommonContainerStoppingErrorHandlerstops the container on an error instead of skipping the record. That is a deliberate choice for consumers where processing out of order or skipping a record is worse than stopping. Pausing and resuming the container through theKafkaListenerEndpointRegistry, driven by a health check or circuit breaker, is the softer version for dependency outages. - Plain Kafka consumer. Use the Apache Kafka client directly with manual offset management. You get full control over seek, commit and pause behavior, and you write all of the retry, back-off, dead-lettering and rebalance handling yourself. This is rarely worth it in an application that already uses Spring.
- Kafka Streams. If the workload is a stream-processing topology rather than a listener, Kafka Streams has its own handlers for deserialization and production errors. They are configured separately and do not use the Spring Kafka listener error handlers described here.
A practical default: use DefaultErrorHandler with a DeadLetterPublishingRecoverer for every listener, add @RetryableTopic only where throughput matters more than per-key ordering, and use the alternatives above for specific cases rather than as a starting point.
How do you operate, replay and test the dead letter topic?
A dead letter record keeps the original key and value byte-for-byte. Spring Kafka's dead letter publishing adds headers for the source topic, partition, offset and timestamp, plus the exception class, message and stack trace. Use these headers for triage. Group DLT records by exception class to tell one bad producer from a broken downstream dependency. Use the original partition and offset to find the record in logs and traces.
Operating the DLT
- Alert on growth. Alert on the rate of new DLT records, not only the total, so a sudden spike gets attention within minutes.
- Set retention deliberately. Choose a value longer than your worst-case triage time, or evidence expires before anyone reads it.
- Name an owner. Assign one team that drains the topic. Without an owner, a DLT becomes a silent data-loss queue.
- Make replay a documented procedure. Fix the cause first. Then republish selected records to the original topic, or to a dedicated replay topic, with the same key. Replayed records land behind newer events for that key, so per-key ordering is lost. Handlers must tolerate stale updates, for example by comparing versions. Replay can also produce duplicates, so it relies on the idempotency described above.
Testing error paths
Run listener tests against @EmbeddedKafka or a containerized broker. Force a transient failure that succeeds on the third attempt and assert the attempt count. Force a permanent failure and assert that the DLT record's payload and headers match the input. Then check that the committed offset has advanced past the failed record. These tests catch misclassified exceptions, a back-off that exceeds the poll interval, and a missing recoverer in CI, which is far cheaper than finding them during an incident.
@SpringBootTest
@EmbeddedKafka(partitions = 1, topics = {"orders", "orders.DLT"})
class OrderListenerErrorPathTest {
@Autowired KafkaTemplate<String, String> template;
@Autowired EmbeddedKafkaBroker broker;
@Autowired OrderListener listener; // test fixture: counts attempts, fails on demand
@Test
void transientFailureSucceedsOnThirdAttempt() {
listener.failTimes("order-1", 2); // throw a retryable exception twice, then succeed
template.send("orders", "order-1", "{\"qty\":1}");
await().atMost(Duration.ofSeconds(10))
.untilAsserted(() -> assertThat(listener.attempts("order-1")).isEqualTo(3));
}
@Test
void permanentFailureLandsInDltAndOffsetAdvances() throws Exception {
template.send("orders", "order-2", "not-json"); // deserialization-style poison pill
Map<String, Object> props = KafkaTestUtils.consumerProps("dlt-test", "false", broker);
try (Consumer<String, String> dlt = new DefaultKafkaConsumerFactory<>(props,
new StringDeserializer(), new StringDeserializer()).createConsumer()) {
broker.consumeFromAnEmbeddedTopic(dlt, "orders.DLT");
ConsumerRecord<String, String> rec = KafkaTestUtils.getSingleRecord(dlt, "orders.DLT");
// Payload is unchanged; headers point back to the source record for triage
assertThat(rec.key()).isEqualTo("order-2");
assertThat(rec.value()).isEqualTo("not-json");
assertThat(new String(rec.headers().lastHeader(KafkaHeaders.DLT_ORIGINAL_TOPIC).value()))
.isEqualTo("orders");
assertThat(rec.headers().lastHeader(KafkaHeaders.DLT_EXCEPTION_FQCN)).isNotNull();
}
// Non-retryable: exactly one attempt, then the consumer must move past the record
assertThat(listener.attempts("order-2")).isEqualTo(1);
await().atMost(Duration.ofSeconds(10)).untilAsserted(() -> assertThat(
KafkaTestUtils.getCurrentOffset(broker.getBrokersAsString(), "orders-group", "orders", 0)
.offset()).isGreaterThanOrEqualTo(1L));
}
}
An @EmbeddedKafka test that forces a transient and a permanent failure, then asserts the retry count, the DLT record's payload and headers, and that the committed offset moved past the failed record.
How can an explicit error-handling policy save engineering time?
Most of the time spent on consumer failures goes into finding out what happened, not into fixing the code. An explicit policy reduces that time in a few concrete ways:
- Less custom plumbing.
DefaultErrorHandler,DeadLetterPublishingRecovererand@RetryableTopicalready implement attempt tracking, seeking, back-off, dead-letter publishing and context headers. Writing and maintaining the same logic by hand in each service is work that a few bean definitions replace. - Faster triage. A DLT record carries the original payload, source topic, partition, offset and exception details. An engineer can see the failing input and the cause directly instead of reconstructing it from logs, or discovering that the default logging recoverer has already dropped the record.
- Fewer incidents caused by configuration. Bounded back-offs sized against
max.poll.interval.msavoid rebalance storms.ErrorHandlingDeserializeravoids partitions stuck on a malformed payload. Correct exception classification avoids both blocked partitions and DLT floods. Each of these is a class of incident that otherwise has to be diagnosed under pressure. - Repeatable recovery. A documented replay procedure and idempotent handlers turn "fix the data" into a routine task rather than a one-off script written during an incident.
- Problems found in CI. The error-path tests above fail when someone changes a back-off, removes a recoverer or misclassifies an exception, before the change reaches production.
Illustrative estimate, with these assumed inputs: a team sees four poison-message incidents per quarter; without a DLT, each one takes an assumed six engineer-hours to detect, reconstruct the lost payload from logs and upstream systems, and repair the data; with a DLT and a replay procedure, each takes an assumed one and a half engineer-hours to inspect the record, fix the cause and replay. Under those assumptions the team spends 24 hours per quarter without the policy and 6 hours with it, before counting the one-time cost of configuring the handler and writing the tests. Your numbers will differ; the useful exercise is to plug in your own incident count and handling time.
How OneEnv can help
Disclosure: OneEnv is the product behind this blog.
OneEnv (oneenv.io) is a workspace-based governance platform for the things services share — environment variables, database structure, API routes and validation rules. A change to a shared value is staged on a branch, reviewed once, and then every affected service explicitly approves or rejects it before it goes live, so you can see who a change touches before it ships instead of finding out in production.
Applied to spring kafka error handling, this is where it helps:
Saves time
- Every service that inherits a shared value is listed in one place, so nobody searches repos and chats to find out who is affected.
- One review per branch replaces coordinating each team separately; each service still keeps its own approve/reject.
- Changing a shared variable is one edit and one review instead of editing every service's
.envby hand.
Saves cost
- Fewer production incidents and rollbacks caused by a shared value, route or column changing under a consumer unannounced.
- Less duplicated configuration to maintain: one shared definition inherited by many services.
- A wrong or stale value is caught at review time by the services it affects, not by a failed deploy.
- OneEnv has a free plan (1 workspace, unlimited services and members, full governance), so trying it costs nothing.
These are qualitative benefits, not measured results — how much you save depends on how many services share the value.
Want to try it? Start at oneenv.io.