TLS handshakes: The Follow-Up Questions Interviewers Ask, With Answers
Interviewers bring up TLS handshakes because they reveal how deeply you understand secure communication. A candidate who can recite the steps may still miss the performance, scaling, and operational concerns that matter in real systems. Probing further lets the interviewer see whether you can think about latency, certificate management, and failure modes in a production environment.
The follow-up questions also let interviewers differentiate between junior, senior, and staff candidates. Junior candidates often stop at "client hello, server hello, key exchange, finish". Senior candidates add details about cipher suite negotiation and session resumption. Staff candidates discuss how TLS choices affect architecture, observability, and incident response.
1. What is the purpose of the ServerHelloDone message?
I would say the ServerHelloDone tells the client that the server has finished sending its part of the handshake. After this message, the client knows it can start sending its certificate (if mutual auth is required) and the key exchange payload. It essentially marks the transition point where the server stops negotiating and the client proceeds to the next phase. It exists in TLS 1.2 and earlier only. TLS 1.3 removed it, because the server's flight now ends with its Finished message.
2. How does TLS session resumption reduce handshake latency?
TLS session resumption lets a client reuse a previously negotiated session key, skipping most of the expensive public-key operations. With a session ticket or a session ID, the client sends a short identifier in the ClientHello. The server then validates it and can immediately derive the master secret. This cuts a TLS 1.2 handshake from two round-trips to one, saving roughly 75 ms on a typical WAN link where each round-trip is about 75 ms.
3. Why might you choose TLS 1.3 over TLS 1.2 in a high-traffic service?
TLS 1.3 removes many legacy ciphers and reduces the handshake to a single round-trip, which improves latency and simplifies the cipher suite negotiation. For a service that opens millions of new connections per day, removing one round trip from each handshake takes tens of milliseconds off every new connection's time to first byte. Additionally, TLS 1.3 encrypts more of the handshake, mitigating passive eavesdropping attacks that are still possible with TLS 1.2.
4. How does the choice of cipher suite affect CPU usage?
The expensive part of a handshake for the server is the private-key operation. An RSA-2048 decryption or signature costs far more CPU than an ECDSA P-256 signature, and the ECDHE key agreement is cheap next to an RSA operation. For example, on a typical x86 server, an RSA-2048 handshake may consume about 1 ms of CPU, while one that signs with an ECDSA P-256 key uses around 0.1 ms. Choosing an ECDSA certificate therefore reduces per-handshake CPU load, which matters when you have tens of thousands of concurrent TLS sessions.
5. What are the security implications of using self-signed certificates in production?
Self-signed certificates lack a chain of trust, so clients cannot automatically verify the server’s identity. This opens the door to man-in-the-middle attacks because an attacker could present a different self-signed cert and the client would have no way to detect the substitution. In production you would need out-of-band verification or pinning, which adds operational complexity and risk. Most large services avoid self-signed certs precisely to keep the trust model simple and auditable.
6. How would you handle certificate rotation without dropping connections?
I would use overlapping certificates and configure the load balancer or TLS terminator to present both the old and the new cert during the transition period. Because TLS handshakes happen per connection, existing connections continue using the old cert until they naturally close, while new connections pick up the new cert. A typical rollout window is 24-48 hours to ensure all long-lived connections have time to finish.
7. What is forward secrecy and why does it matter?
Forward secrecy (FS) ensures that compromise of the server’s long-term private key does not expose past session keys. It is achieved by using an ephemeral key exchange like ECDHE, where each session generates a fresh key pair. If an attacker later steals the server’s RSA private key, they cannot decrypt traffic captured from earlier sessions because those sessions used different, short-lived keys. FS is a core requirement for compliance regimes that mandate protection of historical data.
8. How does TLS termination at a load balancer affect observability?
When TLS is terminated at a load balancer, the encrypted payload is decrypted before it reaches the backend services. This gives the load balancer the ability to inspect HTTP headers, collect detailed latency metrics, and apply WAF rules. However, it also means the backend no longer sees the original client IP unless the balancer forwards it via X-Forwarded-For. Proper logging and metric propagation are therefore essential to maintain end-to-end observability.
9. How would you design a system to support millions of concurrent TLS handshakes?
I would offload TLS termination to a dedicated layer of high-performance proxies, such as NGINX plus or HAProxy, running on instances whose CPUs have built-in cryptographic acceleration (e.g., AES instructions). Using TLS 1.3 reduces round-trips, and enabling session tickets cuts the handshake cost dramatically. Autoscaling groups would add more proxy nodes as traffic spikes, and a shared session ticket key store (e.g., Redis) would allow any node to resume sessions. This architecture spreads CPU load and keeps latency under 100 ms even at peak load.
What separates a senior answer from a staff answer on this topic?
A senior answer nails the technical details: correct handshake steps, cipher trade-offs, and concrete performance numbers. A staff answer goes further, framing TLS choices in the context of the entire system. It discusses how TLS termination impacts observability, incident response, and cross-team processes like certificate lifecycle management. It also anticipates future changes—such as moving to post-quantum algorithms—and proposes architectural flexibility to accommodate them.
How to practice this
- Draw a full TLS 1.3 handshake on a whiteboard canvas, labeling each message and where session tickets are used.
- Write out concise answers to the nine questions, then rehearse delivering them in under two minutes each.
- Use System Design AI’s practice board to sketch the handshake flow and get AI feedback on missing details.
Questions people ask
What is the main benefit of TLS 1.3’s reduced round-trip handshake?
TLS 1.3 cuts the handshake to a single RTT, which lowers latency and reduces the window for active attacks. It also removes legacy cipher suites, simplifying the protocol.
Can a load balancer reuse TLS tickets across different instances?
Yes, if the instances share the same ticket encryption key (often stored in a distributed cache). This lets any node resume a client’s session without forcing a full handshake.
Why is forward secrecy important even if you use strong certificates?
Forward secrecy protects past traffic if a private key is later compromised. Without it, an attacker who obtains the server’s key can decrypt all recorded sessions.
How often should certificates be rotated in a production environment?
Best practice is to rotate certificates at least every 90 days. Shorter lifetimes limit exposure if a key is leaked and work well with automated renewal pipelines.