This article explains how a web system can grow from 100,000 to 100 million daily visits by introducing multi‑level caching, various load‑balancing strategies, MySQL performance tuning, distributed database setups, and geographic deployment to maintain stability and performance under massive traffic.
This article examines website performance by breaking down the user request journey into three paths—client, network, and server—offering practical optimization techniques such as DNS prefetch, caching strategies, CDN deployment, and outlining essential metrics like response time, concurrency, and throughput.
While browsing JD.com with Chrome’s console, the author uncovers the site’s front‑end architecture, revealing the use of Seajs, a custom jQuery build, lazy‑loading modules, localStorage caching, and a modular project structure that together deliver fast page loads and efficient updates.
This article explores how various caching techniques—from DNS and CDN to browser and hardware caches—exhibit self‑similar fractal patterns, illustrating the universal space‑for‑time trade‑off that improves system efficiency across front‑end, back‑end, and real‑world scenarios.
The article explains how a web system can evolve from handling 100,000 daily visits to over 100 million by implementing multi‑level load‑balancing, various caching strategies, MySQL optimization, distributed database architectures, and geographic deployment to ensure performance, reliability, and scalability.
The article argues that while performance is important, maintainability is more critical for sustainable software development, illustrating this with anecdotes, common misconceptions about optimization, and practical advice on balancing code readability, caching, and hardware considerations.
This guide explains how configuring the Nginx expires directive for CSS files can prevent redundant network requests by letting browsers rely on local cache for a specified period, improving page load performance.
This article outlines nine practical PHP caching methods—including full-page static caching, partial page fragments, data and query caching, time‑based invalidation, Memcached, Apache modules, and opcode caches—to dramatically improve website speed and scalability.
This article compiles Yahoo's 35 golden rules for frontend performance, covering content, server, cookie, CSS, JavaScript, image optimization and mobile considerations, and explains how to test and apply each technique to dramatically improve page load speed.
Although sites like Taobao appear simple to users, they rely on massive distributed search, caching, storage, load‑balancing, CDN, logging, and data‑analysis systems that demand sophisticated backend engineering, massive infrastructure, and specialized algorithms, explaining why countless top engineers are required to keep them running.
This guide explains the core concepts of Nginx caching, how to enable and configure cache paths, manage cache processes, control which requests are cached, set expiration policies, bypass caching when needed, and provides a comprehensive configuration example.
This article details JD.com's transition from static to dynamic, high‑performance product detail page architecture, describing the multi‑layer system design, data heterogeneity, caching strategies, scaling techniques, operational challenges, and the solutions implemented to meet rapid business demands during massive traffic events.
This article details the evolution and redesign of JD.com’s product detail page architecture, describing the transition from static HTML generation to a dynamic, high‑performance, multi‑datacenter system built on key‑value storage, Nginx + Lua, asynchronous processing, multi‑level caching, and robust scaling and reliability strategies.
This article describes how JD.com redesigned its product detail page system from a static, cache‑heavy architecture to a fully dynamic, multi‑level cached service using Nginx+Lua, JIMDB, and asynchronous workers, addressing scalability, performance, and high‑availability challenges for billions of daily page views.
Bolt is a high‑performance real‑time image cropping and compression server that processes each image only once, uses an LRU cache to limit memory, and offers flexible command‑line options for installation, usage, and scaling on CPU‑rich servers.
Drawing on Will Larson’s insights, this article outlines essential principles for building horizontally scalable systems—including linear capacity growth, redundancy, load‑balancing techniques, caching strategies, CDN usage, offline processing with message queues, and the benefits of a dedicated platform layer for robust, maintainable backend architectures.
This guide presents eight practical front‑end optimization methods—including browser choice, static page serving, request reduction, CDN usage, client‑side caching, and server configuration—that can significantly improve user experience and page load speed.
This article distills Will Larson’s insights on designing scalable systems, covering linear capacity growth, redundancy, load‑balancing strategies, multi‑layer caching, cache invalidation, offline processing with message queues, Map‑Reduce integration, and the benefits of a dedicated platform layer.
Varnish and Squid are open‑source reverse proxy cache servers, but Varnish generally outperforms Squid with higher stability, faster memory‑based caching, greater concurrent connections, and regex‑based cache invalidation, while its higher CPU, I/O, and memory usage and loss of cache on failure can be drawbacks.
The article distills Will Larson’s insights on designing horizontally scalable systems, covering linear capacity growth, redundancy, load‑balancing strategies, caching layers, CDN usage, offline processing with message queues, Map‑Reduce for big data, and the benefits of introducing a platform layer to improve robustness and reusability.
The article outlines a comprehensive approach to performance tuning by first optimizing algorithms, then enhancing hardware and software environments, and finally improving the interaction between code and resources through load balancing, caching, and I/O reduction, while acknowledging trade‑offs such as consistency and operational complexity.
This article explains how to start Memcached with specific parameters, describes the resulting slab class configuration, illustrates memory allocation with pages, chunks, and slabs, and discusses item placement, waste, and the per‑slab LRU eviction policy in detail.
This article explains practical techniques for designing high‑availability and scalable systems—covering entry, business, cache, and database layers—so developers can handle rapid user growth without service interruptions or degraded performance.
The article details Weibo's evolution toward multi‑active cross‑datacenter deployment, describing initial motivations, early synchronization attempts, the eventual MCQ‑based messaging solution, operational challenges such as latency and data consistency, and best‑practice recommendations for large‑scale distributed systems.
This article compares static file serving and Redis‑based page caching for heavily visited sites, outlining their advantages and drawbacks such as speed, update frequency, database load, implementation complexity, and the need for dynamic processing.
This article breaks down the three main paths of a user’s request to a large website—browser, network, and server—explains where bottlenecks occur, and offers practical optimization techniques such as DNS prefetching, caching, asynchronous processing, and bandwidth planning, while also defining performance metrics and testing methods.
This article distills the key takeaways from the book “50 Principles of High‑Scalability Websites,” presenting concise guidelines on avoiding over‑design, planning capacity, simplifying architecture, optimizing DNS and assets, leveraging horizontal scaling, proper database usage, caching, fault isolation, asynchronous messaging, and continuous learning to build robust, easily extensible web systems.
The Poppen.de social site demonstrates a highly scalable backend architecture that combines Nginx, PHP‑FPM, MySQL, Memcached, RabbitMQ, CouchDB, Graphite, Red5 and Tsung to handle millions of users, high concurrency, and extensive media traffic while maintaining performance and reliability.
This article examines the objectives, challenges, evolutionary technologies, design principles, and practical strategies such as resource separation, caching, load balancing, database read/write splitting, CDN, distributed storage, and consistency models that are essential for building and scaling large‑scale website architectures.
The article describes how Renren builds a high‑performance middle‑layer using open‑source components such as MySQL, Tokyo Cabinet/Tyrant, Nginx, Resin, Squid, LVS, Struts, Lucene, Netty, Ganglia, Memcached, and ICE to reduce database load, achieve sub‑20 ms response times, and support massive read/write traffic.
This article explains what reverse proxy is, compares it with forward proxy, outlines its security, load‑balancing, caching, and concurrency‑control benefits, and discusses various deployment approaches including one‑to‑one setups, separate servers, and clustered architectures for large‑scale web applications.
The article examines how to build and scale large web sites by combining technical and business considerations, covering static site deployment, multi‑server availability, session synchronization methods, load‑balancing techniques, database read/write separation, caching, and search indexing to handle high concurrency and data growth.
The article explains how to achieve horizontal scalability by making applications stateless, using client‑side cookies for session data, applying various caching layers, splitting services and databases with sharding, adopting asynchronous messaging, storing unstructured data, and integrating monitoring with alerting.
This article outlines eBay's practical scalability best practices—including functional partitioning, horizontal sharding, avoiding distributed transactions, asynchronous design, virtualization, and judicious caching—to help large‑scale web systems achieve reliable, cost‑effective growth.
The article analyzes the challenges of high‑traffic ticketing platforms, compares business models, identifies concurrency bottlenecks, and presents comprehensive front‑end and back‑end optimization techniques—including load balancing, caching, data partitioning, and queue‑based flow control—to achieve horizontal scalability and reliable performance.
This guide explains how to use Linux's memory‑based tmpfs and the /dev/shm mount point to avoid slow disk I/O, showing how to resize, bind, and apply tmpfs for caching, PHP sessions, and service sockets to dramatically improve server performance.
The article explains that database read/write separation offers limited performance gains and mainly serves data safety, while true scalability for read operations comes from caching and server clusters, and that write operations require a single dedicated server and actor‑model programming for safe concurrency.
This article compiles 50 practical PHP performance tips—from using single quotes and static methods to leveraging opcode caching and memcached—detailing how each adjustment can noticeably improve execution speed, memory usage, and overall efficiency of web applications.
This article reviews the five core Redis data structures—String, Hash, List, Set, and Sorted Set—detailing practical use‑cases such as caching, user profile storage, timelines, message queues, social graphs, and weighted rankings, plus a look at Pub/Sub and transaction features.
This article outlines six practical techniques—background execution, pre‑loading content, caching, UI‑first networking, predictive task start, and input minimization—to make mobile apps feel faster and more responsive, illustrated with real‑world examples from Instagram, Weibo, App Store, WeChat, and more.
The article traces web architecture’s evolution from simple single‑server Java/JSP sites through memory caching, load‑balanced multi‑machine logic, read/write separation, master‑slave replication or message‑queue syncing, horizontal/vertical sharding, and finally multi‑server web‑server deployments behind load balancers to achieve scalability and reliability.
The article explores the often‑overlooked aspects of interaction design—information architecture, interface and flow—focusing on invisible elements such as loading, refresh, and caching mechanisms in mobile applications, and offers practical design patterns to improve user experience across varying network conditions and usage scenarios.
