WebSockets Interview Questions

1. What are WebSockets and what problems do they solve?

2. What is the difference between WebSockets and HTTP?

3. How does the WebSocket handshake and protocol upgrade work?

4. What is the difference between WebSockets and HTTP long polling?

5. What is the difference between WebSockets and Server-Sent Events (SSE)?

6. What is full-duplex communication and how do WebSockets provide it?

7. What are WebSocket frames and how does message framing work?

8. How do you handle authentication in a WebSocket connection?

9. How do you scale WebSocket connections across multiple servers?

10. What is the role of a message broker (like Redis pub/sub) in scaling WebSockets?

11. How do you handle reconnection and connection drops in WebSockets?

12. What are heartbeats (ping/pong) in WebSockets and why are they needed?

13. How does backpressure and flow control work in WebSockets?

14. What is Socket.IO and how does it differ from raw WebSockets?

15. How do you secure WebSockets with WSS and TLS?

16. What are common WebSocket security vulnerabilities and how do you mitigate them?

17. How do you handle CORS and origin validation for WebSockets?

18. What is the difference between WebSockets and WebRTC?

19. How do you broadcast messages to multiple WebSocket clients?

20. What are rooms and namespaces in WebSocket libraries?

21. How do load balancers handle sticky sessions for WebSockets?

22. How do you test a WebSocket application?

23. What are the trade-offs of using WebSockets versus polling for real-time updates?

24. How does the WebSocket close handshake and status codes work?

25. How do you handle binary data over WebSockets?

26. What is connection state management in WebSockets and why does it matter?

27. How do WebSockets work behind proxies and firewalls?

28. How do you implement rate limiting for WebSocket messages?

29. When should you use WebSockets versus gRPC streaming or SSE?

30. What are common WebSocket best practices and performance considerations?

31. How does permessage-deflate compression work in WebSockets, and when should you disable it?

32. A WebSocket upgrade works locally but fails in production. How do you debug it?

33. What delivery and ordering guarantees do WebSockets give you, and how do you get exactly-once semantics?

34. How do you deploy a new version of a WebSocket server without disrupting connected clients?

35. A long-running WebSocket server's memory grows steadily. How do you find and fix the leak?

36. What operating-system limits do you tune before a server can hold very large numbers of WebSocket connections?

37. How do you version a WebSocket message contract, and what is Sec-WebSocket-Protocol for?

38. How do you model presence correctly when one user has several tabs and devices connected?

39. How do WebSockets work over HTTP/2 and HTTP/3, and where does WebTransport fit in?

40. When would you use a managed WebSocket service instead of running your own WebSocket servers?

41. What would you instrument to make a WebSocket system observable in production?

42. How do you build a WebSocket client that keeps working offline and resynchronises correctly?

43. What reverse-proxy settings break a WebSocket upgrade, and how do you configure nginx or a cloud load balancer correctly?

44. How does WebSocket message fragmentation work, and why can a control frame appear in the middle of a message?

45. How do you choose ping intervals and timeouts so infrastructure idle limits never kill a healthy WebSocket?

46. What does bufferedAmount tell you in a browser WebSocket client, and how do you use it to avoid unbounded memory growth?

47. How do you implement WebSocket reconnection with exponential backoff and jitter without creating a thundering herd?

48. How do you design a resume token so a reconnecting WebSocket client does not miss messages sent while it was disconnected?

49. How do you get at-least-once delivery over WebSockets, and what does that force on the consumer?

50. Should a WebSocket be authenticated during the HTTP handshake or with a first application message, and what are the trade-offs?

51. Why should a web app multiplex over a single WebSocket rather than opening one per feature, and how do you build that?

52. How do you evolve WebSocket message schemas when old clients stay connected and cannot be forced to upgrade?

53. A production WebSocket keeps closing with code 1006 and no reason. How do you diagnose a silent disconnect?

54. When should you batch or coalesce WebSocket messages instead of sending each update immediately?

55. How do you design a fallback for users whose networks block WebSockets, without writing the feature twice?

56. How do you load-test a WebSocket fan-out service, and which numbers actually determine capacity?

57. How do you apply distributed tracing to WebSocket traffic when one connection carries thousands of messages?

58. Your WebSocket fleet cannot recover after an outage because every client reconnects at once. What do you do on the server?

59. How does TLS termination and ALPN affect wss connections behind a load balancer?

60. Why do WebSockets break when a phone switches networks or the app is backgrounded, and how do you handle it?

61. One slow WebSocket client is degrading everyone else. What eviction or shedding policy do you apply on the server?