HTTP and HTTPS in HLD - System Design Exercise

Design: HTTP and HTTPS Communication System

Design focuses on the communication protocols HTTP and HTTPS between clients and servers, including encryption, authentication, and request handling. It excludes detailed web server internals, application logic, and client UI design.

Functional Requirements

FR1: Allow clients to request web resources from servers using HTTP protocol

FR2: Support secure communication using HTTPS with encryption

FR3: Ensure data integrity and confidentiality during transmission

FR4: Handle multiple concurrent client requests efficiently

FR5: Provide mechanisms for server authentication to clients

FR6: Support redirection from HTTP to HTTPS

FR7: Allow caching of resources to improve performance

Non-Functional Requirements

NFR1: Support at least 10,000 concurrent client connections

NFR2: API response latency p99 under 200ms

NFR3: Availability target of 99.9% uptime

NFR4: Encryption overhead should not degrade performance beyond 10%

NFR5: Support modern web browsers and HTTP/1.1 and HTTP/2 protocols

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

❓ Question 6

Key Components

Web server supporting HTTP and HTTPS

TLS/SSL certificate management

Load balancer for distributing requests

Cache layer (browser and server-side)

Certificate Authority (CA) for authentication

Redirect service from HTTP to HTTPS

Design Patterns

TLS handshake and encryption pattern

Reverse proxy pattern for SSL termination

Caching pattern for static resources

Load balancing pattern for scalability

Redirection pattern for HTTP to HTTPS

Reference Architecture

Load Balancer

↓

Web Server with TLS Termination

↓

Application Server / Static Content

↓

Certificate Authority

Components

Client Browser

Modern Web Browsers (Chrome, Firefox, Safari, Edge)

Initiates HTTP/HTTPS requests and handles responses, including caching and certificate validation

Load Balancer

Nginx, HAProxy, AWS ELB

Distributes incoming HTTP/HTTPS requests across multiple web servers for scalability and availability

Web Server with TLS Termination

Nginx, Apache, Caddy

Handles HTTP and HTTPS requests, performs TLS handshake and encryption/decryption, serves static content or forwards to application servers

Application Server / Static Content Server

Node.js, Java Spring Boot, Static File Server

Processes dynamic requests or serves static files as requested by the web server

TLS/SSL Certificate Management

Let's Encrypt, Certbot, Commercial CAs

Manages issuance, renewal, and revocation of TLS certificates to enable HTTPS

Certificate Authority (CA)

Public or Private CA infrastructure

Issues trusted certificates to servers for authentication during TLS handshake

Cache Layer

Browser cache, CDN, Reverse Proxy Cache

Stores frequently accessed resources to reduce latency and server load

Request Flow

1. Client browser sends HTTP request to server via load balancer.

2. If request is HTTP and HTTPS is required, load balancer or web server redirects client to HTTPS URL.

3. Client initiates TLS handshake with web server for HTTPS connection.

4. Web server and client exchange certificates and establish encrypted session.

5. Client sends encrypted HTTP request over TLS.

6. Web server decrypts request and forwards to application server or serves static content.

7. Application server processes request and returns response to web server.

8. Web server encrypts response and sends back to client.

9. Client browser decrypts response and renders content.

10. Caching mechanisms store resources to optimize future requests.

Database Schema

Not applicable as this design focuses on communication protocols and encryption rather than data storage.

Scaling Discussion

Bottlenecks

Load balancer can become a single point of failure under high traffic.

TLS handshake is CPU intensive and can limit concurrent connections.

Web server may become overwhelmed serving static and dynamic content.

Certificate management complexity increases with many domains.

Cache invalidation and consistency challenges at scale.

Solutions

Use multiple load balancers with health checks and failover.

Offload TLS termination to dedicated hardware or reverse proxies.

Separate static content serving to CDN or dedicated servers.

Automate certificate issuance and renewal with ACME protocol.

Implement cache invalidation strategies and use CDN for global caching.

Interview Tips

Time: Spend 10 minutes clarifying requirements and constraints, 20 minutes designing architecture and data flow, 10 minutes discussing scaling and trade-offs, 5 minutes summarizing.

Explain difference between HTTP and HTTPS and why encryption matters.

Describe TLS handshake and certificate role in authentication.

Discuss how load balancers and reverse proxies help scalability and security.

Highlight caching benefits and challenges in web communication.

Address how to handle certificate lifecycle and redirection.

Mention performance impact of encryption and mitigation strategies.