Designing High‑Performance, Scalable Architecture for Large‑Scale Websites

1. Characteristics of Large‑Scale Websites

Massive, geographically distributed user base

High traffic and concurrency

Huge data volumes requiring high availability

Hostile security environment with frequent attacks

Rich functionality, rapid changes, frequent releases

Gradual growth from small to large

User‑centric design

Free services with paid experiences

2. Architecture Goals

High Performance : Fast response and smooth user experience

High Availability : Continuous service access

Scalability : Ability to add or remove hardware to adjust processing capacity

Security : Data encryption, secure storage, and robust access controls

Extensibility : Easy addition or removal of modules and features

Agility : Rapid response to business needs

3. Architecture Patterns

Layered structure (application, service, data, management, analytics)

Modular division based on business or functional characteristics

Distributed deployment across multiple physical machines

Clustered instances with load balancing

Caching close to the application or user

Asynchronous processing (request‑response‑notification model)

Redundancy for reliability and performance

Security mechanisms for known and unknown threats

Automation of repetitive tasks

Agile acceptance of requirement changes

4. High‑Performance Architecture

Performance is driven by short response times, high concurrency, large throughput, and stable metrics. Optimizations are applied at four layers:

Frontend Optimization : Reduce HTTP requests, enable compression, use CDN, leverage browser caching, async JavaScript, minimize cookies.

Application‑Layer Optimization : Caching, asynchronous calls, clustering.

Code Optimization : Multithreading, object/thread pools, efficient data structures, JVM tuning, singleton patterns, in‑process caches.

Storage Optimization : SSDs, fiber links, read/write tuning, disk redundancy, distributed storage (HDFS), NoSQL.

5. High‑Availability Architecture

Ensuring continuous service requires planning at the architectural level. Industry often measures availability in “nines” (e.g., 99.99% allows ~53 minutes of downtime per year). Strategies differ by layer:

Application Layer : Stateless design, load balancers with session synchronization.

Service Layer : Load balancing, tiered management, fast failure, async calls, service degradation, idempotent design.

Data Layer : Redundant backups (cold, hot, warm), failover, CAP theorem considerations (consistency, availability, partition tolerance).

6. Scalability Architecture

Scalability means adjusting processing capacity without redesigning the system.

Application Layer : Vertical or horizontal partitioning, load balancing via DNS, reverse proxy, IP, or layer‑4 techniques.

Service Layer : Similar partitioning as the application layer.

Data Layer : Sharding, partitioned tables, NoSQL, consistent hashing algorithms.

7. Extensibility Architecture

Facilitates easy addition or removal of functional modules.

Modular and component‑based design (high cohesion, low coupling).

Stable interfaces that allow internal changes without affecting callers.

Application of design patterns and object‑oriented principles.

Message queues to decouple modules.

Distributed services (e.g., Dubbo) for shared business capabilities.

8. Security Architecture

Addresses both known vulnerabilities and unknown threats.

Infrastructure Security : Trusted hardware procurement, OS patching, firewalls, DDoS protection, network segmentation.

Application Security : Prevent XSS, injection, CSRF, secure file handling, use WAF (e.g., ModSecurity).

Data Confidentiality : Secure storage, encryption at rest and in transit, regular backups.

Common algorithms: MD5, SHA, DES/3DES, RSA.

9. Agility

Architecture and operations must adapt quickly to traffic spikes, new features, and business growth, integrating agile management and development practices.

10. Example Seven‑Layer Architecture

Typical logical layers:

Client Layer : PC browsers and mobile apps.

Frontend Optimization Layer : DNS load balancing, CDN, reverse proxy.

Application Layer : Clustered services split by business domain (e.g., product, user).

Service Layer : Shared services such as user, order, payment.

Data Storage Layer : Relational DB clusters (read/write split), NoSQL clusters, distributed file systems, distributed cache.

Big‑Data Storage Layer : Logs and semi‑structured data from application and service layers.

Big‑Data Processing Layer : Offline MapReduce or real‑time Storm/Elasticsearch analytics.

Evolution of Large‑Scale E‑Commerce Architecture

Early stages deployed application, database, and file storage on a single server. As traffic grew, components were separated, caches introduced, clusters formed, and services were extracted.

Key Evolution Steps

Separate application, database, and file servers.

Introduce local and distributed caches (e.g., OSCache, Memcached, Redis).

Deploy application clusters behind load balancers (hardware F5 or software LVS/Nginx/HAProxy).

Implement read‑write splitting and sharding for databases.

Adopt CDN and reverse proxy to reduce latency for distant users.

Use distributed file systems (GFS, HDFS, TFS) for massive file storage.

Integrate NoSQL databases (MongoDB, HBase, Redis) and search engines (Lucene, Solr, Elasticsearch).

Split monolithic applications into business‑specific services.

Build distributed services with frameworks such as Dubbo.

Capacity Estimation Example

Assuming 10 million registered users in 3‑5 years, the article estimates:

Daily UV ≈ 2 million (20% of users)

Average page views per user ≈ 30 → 60 million PV per day

Peak concurrent requests ≈ 8 340 TPS (three‑times normal load)

Web server sizing: ~300 TPS per Tomcat instance → 10 servers for normal load, 30 for peak.

Optimization Recommendations

Business decomposition (vertical/horizontal splitting)

Clustered deployment with load balancing

Multi‑level caching (local + distributed)

Distributed session management / single sign‑on

Database clustering with read‑write separation and sharding

Service‑oriented architecture

Message queues for asynchronous processing

Additional techniques: CDN, reverse proxy, distributed file systems, big‑data processing

The architecture continuously evolves to meet business demands, and the presented patterns provide a solid foundation for designing robust, high‑performance, and scalable large‑scale web systems.