Backend interview prep

Start

Spring Kafka Production Best Practices Interview Questions and Answers

Master Spring Kafka production best practices with interview questions covering scalability, partition strategy, consumer lag, retries, DLT, idempotency, transactions, monitoring, security, performance tuning, and enterprise architecture.

Introduction

Running Kafka successfully in production requires much more than sending and consuming messages.

Enterprise systems such as

  • Banking
  • Insurance
  • E-Commerce
  • Healthcare
  • Trading Platforms
  • Logistics

process millions of events per day while ensuring

  • High Availability
  • Fault Tolerance
  • Low Latency
  • Exactly-Once Processing
  • Security
  • Observability
  • Disaster Recovery

Spring Kafka provides powerful features to build enterprise-grade event-driven applications, but correct architectural decisions are essential.

Enterprise Kafka Production Architecture

flowchart LR

Producer --> KafkaCluster

KafkaCluster --> ConsumerGroup

ConsumerGroup --> Database

ConsumerGroup --> Monitoring

Monitoring --> Dashboard

Q1. What are Spring Kafka Production Best Practices?

Answer

Production best practices are proven techniques that improve

  • Reliability
  • Performance
  • Scalability
  • Security
  • Maintainability

They ensure Kafka applications continue operating even under failures and heavy workloads.

Q2. Why is Topic Design important?

Poor topic design leads to

  • Hot partitions
  • Uneven load
  • Poor scalability

Recommendations

  • Use business-oriented topic names
  • Avoid one topic per customer
  • Keep topic purposes clear
  • Plan partition count early

Examples

payment-events

order-events

customer-events

fraud-alerts

Q3. How should partitions be designed?

Partitions determine maximum parallelism.

Guidelines

  • Estimate future traffic.
  • Allow room for scaling.
  • Use stable message keys.
  • Avoid changing partition counts frequently.

Partition Strategy

flowchart TD

PaymentTopic --> Partition0

PaymentTopic --> Partition1

PaymentTopic --> Partition2

PaymentTopic --> Partition3

Partition count directly impacts consumer scalability.

Q4. Why is Idempotency critical?

Failures may cause duplicate delivery.

Without idempotency

Payment

↓

Processed Twice

↓

Double Debit

Solutions

  • Transaction IDs
  • Business keys
  • Deduplication tables
  • Idempotent consumers

Never rely solely on Kafka delivery guarantees.

Q5. How should retries be configured?

Retry only temporary failures.

Examples

Retry

  • Database unavailable
  • Network timeout
  • HTTP 503

Do Not Retry

  • Invalid JSON
  • Validation failures
  • Business rule violations

Use

  • Exponential backoff
  • Retry Topics
  • Dead Letter Topics

Q6. Why use Dead Letter Topics?

Dead Letter Topics prevent message loss.

Flow

flowchart LR

Consumer --> Retry

Retry --> DLT

DLT --> Replay

Benefits

  • Safe failure isolation
  • Manual replay
  • Better observability

Q7. How should Kafka applications be monitored?

Monitor

  • Consumer Lag
  • Producer Latency
  • Broker Health
  • Retry Count
  • DLT Size
  • Transaction Failures
  • Throughput
  • JVM Metrics

Popular tools

  • Micrometer
  • Prometheus
  • Grafana
  • Datadog
  • Splunk

Observability is mandatory in production.

Q8. How do you secure Kafka?

Recommendations

  • SSL/TLS
  • SASL Authentication
  • ACL Authorization
  • OAuth2
  • Secret Management
  • Encryption at Rest

Never expose Kafka brokers publicly.

Security

flowchart LR

Producer --> TLS

TLS --> Kafka

Kafka --> TLS

TLS --> Consumer

Q9. How do you improve Kafka performance?

Producer

  • Enable batching
  • Enable compression
  • Use asynchronous sends
  • Enable idempotence

Consumer

  • Increase concurrency
  • Tune poll size
  • Manual acknowledgements
  • Optimize processing

Broker

  • SSD storage
  • Adequate replication
  • Monitor disk utilization

Q10. Spring Kafka Production Checklist

Producer

  • Enable Idempotence
  • Use acks=all
  • Enable Compression
  • Configure Batching

Consumer

  • Manual Acknowledgements
  • Idempotent Processing
  • Retry Topics
  • Dead Letter Topics

Broker

  • Replication Factor ≥ 3
  • Multiple Brokers
  • Rack Awareness
  • Monitoring

Security

  • TLS
  • SASL
  • ACLs

Observability

  • Metrics
  • Distributed Tracing
  • Alerts
  • Logs

Banking Example

flowchart TD

MobileBanking --> Producer

Producer --> KafkaCluster

KafkaCluster --> PaymentConsumers

PaymentConsumers --> PostgreSQL

PaymentConsumers --> RetryTopics

RetryTopics --> DLT

DLT --> ReplayService

KafkaCluster --> Prometheus

Prometheus --> Grafana

This architecture supports high availability, fault tolerance, and operational visibility.

Common Interview Questions

  • What are Kafka production best practices?
  • Why is topic design important?
  • How should partitions be designed?
  • Why is idempotency important?
  • How should retries be configured?
  • Why use Dead Letter Topics?
  • What should be monitored?
  • How do you secure Kafka?
  • How do you improve performance?
  • Production deployment checklist?

Quick Revision

Topic Summary
Topic Design Business-oriented topics
Partitions Parallelism
Idempotency Duplicate protection
Retry Temporary failure recovery
Dead Letter Topic Failed message storage
Monitoring Observe system health
Security TLS, SASL, ACL
Producer Optimization Batching & Compression
Consumer Optimization Concurrency & Manual Ack
Observability Metrics, Logs, Traces

Kafka Production Lifecycle

sequenceDiagram
Producer->>Kafka: Publish Event
Kafka->>Consumer: Deliver
Consumer->>BusinessService: Process
BusinessService->>Database: Save
Database-->>BusinessService: Success
BusinessService->>Kafka: Commit Offset
Kafka->>Monitoring: Metrics
Monitoring->>Dashboard: Visualize

Production Example – Enterprise Banking Payment Platform

A multinational bank processes 50 million payment events every day using Spring Kafka.

Requirements

  • Zero message loss.
  • Exactly-once payment processing.
  • Horizontal scalability.
  • Automatic recovery from transient failures.
  • Secure communication.
  • Real-time monitoring.
  • Disaster recovery.

Architecture

  • Producer

    • Uses KafkaTemplate.
    • Enables acks=all.
    • Enables batching, compression, and idempotence.
    • Uses customer ID as the message key.

  • Kafka Cluster

    • 5 Brokers.
    • Replication Factor = 3.
    • 24 partitions for payment-events.
    • Rack-aware deployment.

  • Consumer Group

    • 12 consumer instances.
    • Manual acknowledgements.
    • Idempotent processing.
    • read_committed isolation.

  • Error Handling

    • Retry Topics with exponential backoff.
    • Dead Letter Topics for permanent failures.
    • Replay service for DLT messages.

  • Monitoring

    • Micrometer exports metrics.

    • Prometheus collects metrics.

    • Grafana dashboards visualize:

      • Consumer lag
      • Throughput
      • Retry count
      • DLT size
      • Broker health

  • Security

    • TLS encryption.
    • SASL authentication.
    • ACL authorization.
    • Secrets managed externally.
flowchart LR

MobileApp --> PaymentService

PaymentService --> KafkaProducer

KafkaProducer --> KafkaCluster

KafkaCluster --> PaymentConsumerGroup

PaymentConsumerGroup --> PaymentServiceDB

PaymentConsumerGroup --> RetryTopics

RetryTopics --> PaymentDLT

PaymentDLT --> ReplayService

KafkaCluster --> Micrometer

Micrometer --> Prometheus

Prometheus --> Grafana

KafkaCluster --> OpenTelemetry

OpenTelemetry --> Jaeger

spring.kafka.producer.acks=all
spring.kafka.producer.properties.enable.idempotence=true
spring.kafka.producer.compression-type=zstd
spring.kafka.producer.batch-size=32768
spring.kafka.producer.linger-ms=10
spring.kafka.producer.transaction-id-prefix=payment-tx-

spring.kafka.listener.ack-mode=manual
spring.kafka.listener.concurrency=12
spring.kafka.consumer.enable-auto-commit=false
spring.kafka.consumer.isolation-level=read_committed
spring.kafka.consumer.max-poll-records=500

Spring Kafka Production Checklist

Area Recommendation
Topic Naming Business-focused, version when needed (payment-events-v1)
Partitions Size for future growth, not just current traffic
Replication Factor At least 3 for production
Producer Enable idempotence, batching, compression, acks=all
Consumer Manual acknowledgements, idempotent processing
Error Handling Retry Topics + Dead Letter Topics
Transactions Use for financial consistency
Serialization Avro + Schema Registry for enterprise deployments
Monitoring Micrometer + Prometheus + Grafana
Tracing OpenTelemetry + Jaeger/Zipkin
Security TLS, SASL, ACLs, secret management
Disaster Recovery Cross-region replication (MirrorMaker 2 or Cluster Linking where appropriate)
Capacity Planning Monitor partition growth, disk usage, consumer lag, and broker utilization

Key Takeaways

  • Production-ready Spring Kafka systems require careful planning across architecture, performance, security, monitoring, and recovery.
  • Design topics and partitions based on business domains and expected future scalability.
  • Enable idempotent producers, manual acknowledgements, and Exactly-Once Semantics (EOS) where consistency is critical.
  • Implement Retry Topics and Dead Letter Topics to handle transient and permanent failures without losing events.
  • Use Avro with Schema Registry for large enterprise environments that require schema evolution and cross-language compatibility.
  • Continuously monitor consumer lag, throughput, broker health, retry rates, and transaction failures using observability tools.
  • Secure Kafka clusters using TLS, SASL, ACLs, and external secret management solutions.
  • Combining these practices results in resilient, scalable, and enterprise-grade event-driven systems capable of processing millions of events reliably every day.