Skip to content
ExponaBLOG
Series · Day 100 of 100

Kafka & WebSockets

  1. 51
    WebSockets vs SSE vs polling: what developers should know
    Pick the simplest option that works.
  2. 52
    Server-Sent Events are underrated in Kafka & WebSockets
    Real-time updates without WebSocket complexity.
  3. 53
    When SSE is enough: a practical Kafka & WebSockets guide
    Most 'real-time' features are one-way.
  4. 54
    Socket.IO in depth: a practical Kafka & WebSockets guide
    Rooms, namespaces and acknowledgements.
  5. 55
    Socket.IO is not plain WebSocket: lessons from production
    A raw WebSocket client can't talk to a Socket.IO server.
  6. 56
    Authenticating WebSocket connections: a practical guide
    Secure the handshake and every message.
  7. 57
    Token expiry on long-lived sockets in Kafka & WebSockets
    Your JWT expires after 15 minutes. The socket doesn't.
  8. 58
    Reconnection and resilience: what developers should know
    Networks drop. Design for it.
  9. 59
    Heartbeats keep connections honest in Kafka & WebSockets
    Dead connections look alive until you ping them.
  10. 60
    Scaling WebSockets horizontally: lessons from production
    Many servers, one experience.
  11. 61
    Load balancers and WebSockets: best practices explained
    Most WebSocket outages are proxy configuration.
  12. 62
    Nginx for WebSockets: a practical Kafka & WebSockets guide
    The config that keeps real-time traffic flowing.
  13. 63
    Connection limits and file descriptors, explained simply
    Every socket is an open file.
  14. 64
    Ordering and delivery over WebSockets: a practical guide
    TCP is ordered. Your system might not be.
  15. 65
    Acknowledgement-based delivery: best practices explained
    When a message must arrive.
  16. 66
    Building a presence system: patterns, pitfalls and fixes
    Who's online — accurately.
  17. 67
    Typing indicators without flooding in Kafka & WebSockets
    Tiny feature, surprising traffic.
  18. 68
    Live location tracking architecture in Kafka & WebSockets
    Showing a moving vehicle on a map in real time.
  19. 69
    Throttle GPS updates: a practical Kafka & WebSockets guide
    More updates isn't better tracking.
  20. 70
    Real-time market data fan-out: best practices explained
    Lessons from building a trading platform UI.
  21. 71
    The snapshot-plus-delta pattern: lessons from production
    How to keep clients in sync efficiently.
  22. 72
    Backpressure in real-time systems in Kafka & WebSockets
    When producers are faster than consumers.
  23. 73
    Handling slow consumers: real-world lessons and examples
    One slow client shouldn't slow everyone.
  24. 74
    Binary protocols over WebSockets: lessons from production
    When JSON becomes the bottleneck.
  25. 75
    Payload size matters: a practical Kafka & WebSockets guide
    Every byte goes to every subscriber.
  26. 76
    Real-time in .NET with SignalR: best practices explained
    Hubs, groups and scale-out.
  27. 77
    SignalR vs Socket.IO: a practical Kafka & WebSockets guide
    Pick the one that matches your backend.
  28. 78
    Bridging Kafka to WebSockets: what developers should know
    Turning backend events into live UI updates.
  29. 79
    One consumer group or one per instance, explained simply
    A key decision for Kafka-to-WebSocket gateways.
  30. 80
    Designing a notification system: lessons from production
    In-app, push, email — one pipeline.
  31. 81
    Respect notification preferences: lessons from production
    Too many notifications train users to ignore you.
  32. 82
    Chat system design basics: practical tips and trade-offs
    The classic real-time interview question, grounded in reality.
  33. 83
    Message IDs and deduplication: best practices explained
    Client retries shouldn't create double messages.
  34. 84
    Collaborative editing basics: what developers should know
    How multiple people edit the same thing at once.
  35. 85
    CRDTs in one minute: a practical Kafka & WebSockets guide
    Conflict-free replicated data types, simply.
  36. 86
    Securing real-time systems: patterns, pitfalls and fixes
    Sockets are an attack surface too.
  37. 87
    Cross-site WebSocket hijacking: best practices explained
    Cookies + WebSockets + no origin check = trouble.
  38. 88
    Observability for WebSockets: what developers should know
    What to measure for real-time systems.
  39. 89
    Real-time metrics to track: patterns, pitfalls and fixes
    Five numbers on every real-time dashboard.
  40. 90
    Load testing WebSockets: real-world lessons and examples
    Know your limits before your users find them.
  41. 91
    Test reconnect storms for Kafka & WebSockets developers
    What happens when 50,000 clients reconnect at once?
  42. 92
    Real-time on mobile: a practical Kafka & WebSockets guide
    Sockets on phones behave differently.
  43. 93
    Push notifications vs sockets on mobile, explained simply
    Use each for what it's good at.
  44. 94
    Serverless and managed real-time: lessons from production
    When you don't want to run socket servers.
  45. 95
    Managed real-time services: patterns, pitfalls and fixes
    Buy the boring part.
  46. 96
    Event-driven architecture pitfalls in Kafka & WebSockets
    Mistakes that make event systems painful.
  47. 97
    Debugging distributed events: what developers should know
    Follow one event across five services.
  48. 98
    My real-time systems checklist: best practices explained
    What I verify before shipping any live feature.
  49. 99
    Advice for engineers new to real-time: a practical guide
    Things I wish I knew before my first live feature.
  50. 100
    100 days of Kafka and WebSockets: lessons for production
    Wrapping up the series.