Skip to content
ExponaBLOG
Series · Day 100 of 100

Kafka & WebSockets

  1. 01
    Why every senior engineer should know events and real-time
    Ride tracking, trading screens, CRM alerts — I've needed both Kafka and WebSockets everywhere.
  2. 02
    Kafka in one picture: a practical Kafka & WebSockets guide
    The five concepts behind everything else.
  3. 03
    Topics are not queues for Kafka & WebSockets developers
    The mental shift that makes Kafka click.
  4. 04
    Partitions and ordering: real-world lessons and examples
    Kafka guarantees order — within a partition.
  5. 05
    Choosing a partition key: a hands-on guide for engineers
    The most important Kafka design decision.
  6. 06
    Consumer groups and rebalancing: lessons from production
    How Kafka spreads work across consumers.
  7. 07
    How many partitions do you need: lessons from production
    Too few limits scale. Too many adds overhead.
  8. 08
    Offsets and commits: a practical Kafka & WebSockets guide
    Where your consumer is — and what happens when it crashes.
  9. 09
    Auto-commit can lose events: what developers should know
    The default setting that surprises everyone.
  10. 10
    Delivery semantics explained: what developers should know
    At-most-once, at-least-once, exactly-once.
  11. 11
    Enable the idempotent producer: best practices explained
    Producer retries shouldn't create duplicates.
  12. 12
    Producer settings that matter: best practices explained
    The configuration behind reliable, fast producers.
  13. 13
    Pick a compression codec: a hands-on guide for engineers
    Compression is free throughput in most Kafka setups.
  14. 14
    Replication and in-sync replicas: lessons from production
    How Kafka survives broker failures.
  15. 15
    Why replication factor 3: a hands-on guide for engineers
    The standard for production topics.
  16. 16
    KRaft: Kafka without ZooKeeper — lessons from production
    Kafka now manages its own metadata.
  17. 17
    One less system to run for Kafka & WebSockets developers
    Kafka 4.0 dropped ZooKeeper entirely.
  18. 18
    JSON vs Avro vs Protobuf: a hands-on guide for engineers
    Choosing a serialization format for events.
  19. 19
    What migrating Kafka from JSON to Avro taught me explained
    Smaller payloads were the bonus. Contracts were the real value.
  20. 20
    Schema Registry and compatibility in Kafka & WebSockets
    Evolve event schemas without breaking consumers.
  21. 21
    Backward-compatible schema changes in Kafka & WebSockets
    Changes you can make safely.
  22. 22
    Retry topics and dead-letter queues in Kafka & WebSockets
    Failure handling that doesn't block partitions.
  23. 23
    Poison pills: Kafka & WebSockets lessons from production
    One malformed event can stop a consumer forever.
  24. 24
    Monitoring consumer lag: real-world lessons and examples
    The single most important Kafka metric.
  25. 25
    Alert on lag, not just errors: best practices explained
    Silent consumers are the worst kind of outage.
  26. 26
    Kafka with Node.js: a practical Kafka & WebSockets guide
    Producing and consuming from TypeScript services.
  27. 27
    Choosing a Kafka client for Node: lessons from production
    Your client library is a long-term dependency.
  28. 28
    Designing good events for Kafka & WebSockets developers
    Events are contracts. Design them like APIs.
  29. 29
    Events vs commands: a practical Kafka & WebSockets guide
    Name them right and the architecture follows.
  30. 30
    Notification events vs state transfer: a practical guide
    Thin events or fat events?
  31. 31
    How much data belongs in an event in Kafka & WebSockets
    Enough to be useful, not enough to leak.
  32. 32
    Outbox and change data capture: best practices explained
    Reliable events straight from your database.
  33. 33
    Where change data capture shines: lessons from production
    Turn database changes into streams.
  34. 34
    Log compaction: a Kafka & WebSockets guide for developers
    Topics that behave like tables.
  35. 35
    Compacted topics as a source of truth: a practical guide
    Latest state per key, replayable anytime.
  36. 36
    Stream processing basics: a hands-on guide for engineers
    Computing over events as they arrive.
  37. 37
    Stateless vs stateful processing: lessons from production
    State is where stream processing gets hard.
  38. 38
    Kafka Connect: a Kafka & WebSockets guide for developers
    Move data in and out of Kafka without writing code.
  39. 39
    Sink connectors save weeks: patterns, pitfalls and fixes
    Don't write custom consumers for standard destinations.
  40. 40
    Running Kafka in production: what developers should know
    Sizing, retention and operations.
  41. 41
    Retention policies: a practical Kafka & WebSockets guide
    How long should Kafka keep your events?
  42. 42
    Kafka security: a Kafka & WebSockets guide for developers
    Encrypt, authenticate, authorize.
  43. 43
    Managed Kafka options for Kafka & WebSockets developers
    Run Kafka without running Kafka.
  44. 44
    Testing Kafka applications: patterns, pitfalls and fixes
    Confidence without a shared cluster.
  45. 45
    Run Kafka locally with Docker: best practices explained
    A single-node KRaft broker for development.
  46. 46
    Kafka, RabbitMQ, SQS or Redis Streams: a practical guide
    Choosing the right messaging tool.
  47. 47
    When not to use Kafka for Kafka & WebSockets developers
    Kafka is powerful — and often overkill.
  48. 48
    Case study: live ride tracking — lessons from production
    How we built real-time ride tracking with Kafka, Redis and Socket.IO.
  49. 49
    Lessons from dispatch notifications in Kafka & WebSockets
    Real-time alerts that drivers can't miss.
  50. 50
    WebSockets fundamentals: real-world lessons and examples
    What happens under the hood.