BestHub
Sign in
Tagged articles
756 articles
Page 5 of 8
IT Architects Alliance
IT Architects Alliance
Oct 7, 2021 · Backend Development

Designing a High‑Concurrency Ticket Spike System with Load Balancing, Redis, and Go

This article explains how to build a high‑concurrency ticket‑seckill system that can handle millions of simultaneous requests by using multi‑layer load balancing, Nginx weighted round‑robin, local stock deduction, Redis atomic scripts, and Go’s native concurrency, and it demonstrates the implementation with complete code and performance testing.

Godistributed architecturehigh concurrency
0 likes · 18 min read
Designing a High‑Concurrency Ticket Spike System with Load Balancing, Redis, and Go
IT Architects Alliance
IT Architects Alliance
Oct 6, 2021 · Operations

Strategic & Tactical Design Principles for Scalable Technical Architecture

This article outlines essential strategic and tactical principles for technical architecture, addressing uncertainty in technology choices, and detailing the suitability, simplicity, and evolution principles, as well as high‑concurrency, high‑availability, and business design guidelines to build stable, scalable systems.

ScalabilityTechnical architecturedesign principles
0 likes · 15 min read
Strategic & Tactical Design Principles for Scalable Technical Architecture
Architect
Architect
Sep 30, 2021 · Backend Development

Design and Technical Challenges of High‑Concurrency Flash‑Sale (Seckill) Systems

This article analyses the business flow, unique characteristics, technical challenges, architectural principles, layer‑wise design, database strategies, high‑concurrency issues, cheating defenses, and data‑safety mechanisms required to build a reliable flash‑sale system capable of handling tens of thousands of simultaneous requests.

Backend ArchitectureDatabase designflash sale
0 likes · 35 min read
Design and Technical Challenges of High‑Concurrency Flash‑Sale (Seckill) Systems
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 29, 2021 · Fundamentals

Mastering Software Architecture: Strategic & Tactical Design Principles

This article explores how to transform product requirements into robust technical architectures by addressing uncertainty, outlining strategic principles—appropriateness, simplicity, evolution—and tactical guidelines for high concurrency, high availability, and business design, while illustrating logical and physical architecture diagrams and offering practical design recommendations.

Software Architecturedesign principleshigh concurrency
0 likes · 14 min read
Mastering Software Architecture: Strategic & Tactical Design Principles
IT Architects Alliance
IT Architects Alliance
Sep 28, 2021 · Backend Development

Designing a High‑Concurrency Ticket Spike System: Architecture, Load Balancing, and Go Implementation

This article explores the design of a high‑concurrency train‑ticket flash‑sale system, covering distributed load‑balancing strategies, Nginx weighted round‑robin configuration, local and remote stock deduction using Go and Redis, performance testing with ApacheBench, and key architectural lessons for preventing overselling and ensuring high availability.

GoNginxdistributed architecture
0 likes · 18 min read
Designing a High‑Concurrency Ticket Spike System: Architecture, Load Balancing, and Go Implementation
Code Ape Tech Column
Code Ape Tech Column
Sep 15, 2021 · Backend Development

Designing a High‑Concurrency Flash‑Sale (Seckill) System: Key Techniques and Best Practices

This article explains how to design a high‑concurrency flash‑sale system by addressing instant traffic spikes, page static‑generation, CDN acceleration, button activation, read‑heavy/write‑light patterns, cache breakdown and penetration, inventory pre‑deduction, distributed locking, message‑queue handling, and multi‑level rate limiting.

cachingdistributed-lockflash sale
0 likes · 23 min read
Designing a High‑Concurrency Flash‑Sale (Seckill) System: Key Techniques and Best Practices
Shopee Tech Team
Shopee Tech Team
Sep 9, 2021 · Backend Development

Technical Architecture and High‑Concurrency Solutions for Shopee Shake During Major Promotions

Shopee Shake’s architecture separates admin and user sides into three layers—access, application, and resource—and uses horizontal scaling, bucketed Redis coin pools, multi‑level caching, asynchronous message queues, precise capacity formulas, and comprehensive monitoring and chaos‑engineered runbooks to reliably handle over 300,000 QPS during major promotional events.

Distributed SystemsShopee Shakeasynchronous processing
0 likes · 19 min read
Technical Architecture and High‑Concurrency Solutions for Shopee Shake During Major Promotions
Java Architect Essentials
Java Architect Essentials
Sep 6, 2021 · Fundamentals

Strategic and Tactical Design Principles for Technical Architecture

This article explains how to design a stable and high‑performing software architecture by addressing strategic principles—suitability, simplicity, evolution—and tactical guidelines for high concurrency, high availability, and business‑oriented design, while illustrating logical and physical architecture diagrams.

Software ArchitectureStrategic DesignTactical Design
0 likes · 15 min read
Strategic and Tactical Design Principles for Technical Architecture
Architect's Journey
Architect's Journey
Sep 3, 2021 · Backend Development

Five Critical Questions to Test Your System Design’s Reasonableness

The article outlines five essential dimensions—data consistency, isolation, extensibility, business sequencing, and high‑concurrency handling—explaining why each matters, illustrating them with concrete examples, and showing how to evaluate and improve a technical design accordingly.

CAP theoremData Consistencyarchitecture design
0 likes · 10 min read
Five Critical Questions to Test Your System Design’s Reasonableness
iQIYI Technical Product Team
iQIYI Technical Product Team
Sep 3, 2021 · Backend Development

Distributed Real-Time Local Cache Practice in iQIYI TV Backend

iQIYI TV’s backend implements a distributed real‑time local cache that combines hotspot local storage with a unified messaging bus, management console, and business‑filtering to deliver instant updates, improve hit rates, reduce read‑bottleneck risk, and alleviate load on centralized caches under extreme concurrency.

CacheDistributed SystemsReal-Time
0 likes · 6 min read
Distributed Real-Time Local Cache Practice in iQIYI TV Backend
Open Source Linux
Open Source Linux
Aug 30, 2021 · Big Data

Why Kafka’s Message System Is Essential for High‑Throughput Applications

This article explains why a message system like Kafka is crucial for decoupling services, handling asynchronous workflows such as e‑commerce flash sales, controlling traffic, and achieving high concurrency, high availability, and high performance through sequential disk writes, zero‑copy reads, replication, and careful resource planning.

Distributed SystemsKafkaMessage Queue
0 likes · 35 min read
Why Kafka’s Message System Is Essential for High‑Throughput Applications
Qunar Tech Salon
Qunar Tech Salon
Aug 30, 2021 · Backend Development

Design of a High‑Concurrency Inventory Search System with Caching and Asynchronous Processing

The article describes the architecture and optimization techniques of Qunar's inventory search service, covering background business flow, challenges of high‑traffic multi‑channel integration, and detailed solutions such as product cataloging, channel cache utilization, request replay, cache isolation, unified cache management, cold‑hot segregation, and full‑process asynchronous handling to improve cache hit rate, update efficiency, and overall throughput.

AsynchronousSearchSystem Design
0 likes · 14 min read
Design of a High‑Concurrency Inventory Search System with Caching and Asynchronous Processing
Wukong Talks Architecture
Wukong Talks Architecture
Aug 25, 2021 · Backend Development

Designing a High-Concurrency Flash Sale (秒杀) System: Key Techniques and Best Practices

This article explains how to design a flash‑sale (秒杀) system that can handle sudden spikes of traffic by using static pages, CDN acceleration, caching strategies, distributed locks, message‑queue asynchronous processing, rate limiting and other backend techniques to ensure reliability and prevent overselling.

cachingflash salehigh concurrency
0 likes · 27 min read
Designing a High-Concurrency Flash Sale (秒杀) System: Key Techniques and Best Practices
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 17, 2021 · Backend Development

How Meituan Scaled Instant Logistics with Distributed Systems and AI

This article details Meituan's five‑year journey building a high‑availability, low‑latency instant logistics platform, describing the distributed architecture evolution, AI‑driven optimizations, fault‑tolerance techniques, and future challenges in scaling micro‑services for massive order and rider volumes.

AI logisticsDistributed SystemsMicroservices
0 likes · 12 min read
How Meituan Scaled Instant Logistics with Distributed Systems and AI
IT Architects Alliance
IT Architects Alliance
Aug 11, 2021 · Backend Development

Understanding High Concurrency and Strategies to Boost System Throughput

The article explains what high concurrency means, outlines key performance metrics such as response time, throughput, QPS, TPS and concurrent users, and presents vertical and horizontal scaling techniques—including hardware upgrades, caching, load balancing, sharding, micro‑services, multithreading and CDN—to improve a system's ability to handle massive parallel requests.

CDNMicroservicesScalability
0 likes · 5 min read
Understanding High Concurrency and Strategies to Boost System Throughput
IT Architects Alliance
IT Architects Alliance
Aug 10, 2021 · Backend Development

How to Build a Robust High‑Concurrency Flash Sale System

This article examines the challenges of implementing a flash‑sale (秒杀) system—such as overselling, massive concurrency, request flooding, URL exposure, and database strain—and presents a comprehensive backend design that includes dedicated databases, dynamic URLs, static page rendering, Redis clustering, Nginx load balancing, optimized SQL, token‑bucket rate limiting, asynchronous order processing, and service degradation strategies.

Backend ArchitectureNginxasynchronous processing
0 likes · 14 min read
How to Build a Robust High‑Concurrency Flash Sale System
Java Tech Enthusiast
Java Tech Enthusiast
Aug 7, 2021 · Backend Development

Cache Optimization and Distributed Locking in High-Concurrency Systems

By illustrating how to replace simple HashMap caching with Redis‑based distributed caches and locks—using SETNX, Lua scripts, and Redisson—the article shows Spring Boot developers how to prevent cache breakdown, ensure data consistency, and dramatically improve throughput in high‑concurrency web applications.

Cache ConsistencyDistributed SystemsLoad Testing
0 likes · 16 min read
Cache Optimization and Distributed Locking in High-Concurrency Systems
Su San Talks Tech
Su San Talks Tech
Jul 29, 2021 · Backend Development

How to Build a High‑Performance Flash Sale System: 9 Essential Design Tips

Designing a flash‑sale (秒杀) system for massive concurrent users requires careful handling of instant traffic spikes, page staticization, CDN acceleration, caching strategies, distributed locks, rate limiting, asynchronous processing, and reliable stock management, with nine detailed techniques to ensure stability and prevent overselling.

backend-developmentcachingdistributed-lock
0 likes · 26 min read
How to Build a High‑Performance Flash Sale System: 9 Essential Design Tips
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 20, 2021 · Backend Development

Design and Architecture of High‑Concurrency Flash‑Sale (秒杀) Systems

This article explains how to design a high‑performance flash‑sale system by analyzing its characteristics, challenges, architectural principles, and detailed solutions across product, front‑end, back‑end, database, inventory control, stability, risk mitigation, asynchronous ordering, and high‑availability strategies.

System Architectureflash salehigh concurrency
0 likes · 16 min read
Design and Architecture of High‑Concurrency Flash‑Sale (秒杀) Systems
Liangxu Linux
Liangxu Linux
Jul 17, 2021 · Operations

Mastering Linux epoll: How IO Multiplexing Powers High‑Performance Servers

This article explains the fundamentals of IO multiplexing in Linux, compares naive loop‑based approaches with kernel‑provided mechanisms, dives deep into epoll's three system calls, its internal red‑black‑tree and ready‑list design, and shows which file descriptors can be efficiently managed with epoll.

Event-drivenIO Multiplexingepoll
0 likes · 17 min read
Mastering Linux epoll: How IO Multiplexing Powers High‑Performance Servers
NetEase Smart Enterprise Tech+
NetEase Smart Enterprise Tech+
Jul 16, 2021 · Backend Development

How NetEase Cloud Scales to 10,000 Simultaneous Mic Connections: Backend Architecture Revealed

This article details NetEase Cloud's backend engineering solutions for supporting ten‑thousand‑user concurrent mic connections, covering distributed signaling architecture, QUIC‑based weak‑network handling, server‑side audio routing, video QoS strategies, and a global transmission network (WE‑CAN) to achieve high availability and scalability.

Distributed SystemsQoSWE-CAN
0 likes · 12 min read
How NetEase Cloud Scales to 10,000 Simultaneous Mic Connections: Backend Architecture Revealed
Alimama Tech
Alimama Tech
Jul 14, 2021 · Backend Development

Real-Time Image Rendering Service for Personalized Advertising Using Rust

To eliminate wasteful pre‑generated ad creatives, a Taobao team built a high‑concurrency, Rust‑based real‑time image rendering service that safely composes personalized templates on the fly, delivering thousands of requests per second with millisecond latency, powering diverse advertising scenarios and achieving roughly a 36 % business lift.

Rusthigh concurrencyimage service
0 likes · 9 min read
Real-Time Image Rendering Service for Personalized Advertising Using Rust
Architect
Architect
Jul 13, 2021 · Backend Development

Optimizing Distributed Lock Concurrency for High‑Throughput Order Scenarios

This article explains how high‑throughput e‑commerce order processing can suffer from inventory oversell when using a single distributed lock, analyzes the lock’s concurrency bottleneck, and proposes a segment‑locking optimization—splitting stock into multiple lock keys—to dramatically increase parallelism while addressing edge‑case pitfalls.

backend optimizatione‑commercehigh concurrency
0 likes · 10 min read
Optimizing Distributed Lock Concurrency for High‑Throughput Order Scenarios
Architect
Architect
Jul 9, 2021 · Backend Development

Designing a High‑Concurrency Flash Sale System: Architecture, Caching, Rate Limiting, and Isolation Strategies

This article explains how to design a flash‑sale (秒杀) system that can handle massive traffic spikes by using static page CDN caching, gateway request interception, Redis inventory control, asynchronous order processing, and thorough business, deployment, and data isolation to ensure high performance and stability without affecting regular services.

CDNSystem Architecturebackend design
0 likes · 10 min read
Designing a High‑Concurrency Flash Sale System: Architecture, Caching, Rate Limiting, and Isolation Strategies
dbaplus Community
dbaplus Community
Jul 7, 2021 · Backend Development

How Vivo Built a Scalable, Decoupled Promotion System for Its E‑Commerce Platform

This article reviews the evolution of Vivo's e‑commerce promotion system, detailing why the original monolithic architecture failed, how a separate, highly extensible promotion service was designed, the technical challenges of scalability, high concurrency, and stability, and the practical lessons learned from Redis and hotspot key issues.

Backende‑commercehigh concurrency
0 likes · 11 min read
How Vivo Built a Scalable, Decoupled Promotion System for Its E‑Commerce Platform
IT Architects Alliance
IT Architects Alliance
Jul 1, 2021 · Backend Development

How to Build a High‑Performance Flash‑Sale System with Redis Caching and CDN

This article explains the challenges of flash‑sale traffic spikes and presents a multi‑layered backend architecture—using CDN‑cached static pages, read‑write split Redis, Lua scripts for atomic stock deduction, and Redis‑based message queues—to achieve high concurrency, stability, and fairness.

Backend ArchitectureCDNLua scripting
0 likes · 9 min read
How to Build a High‑Performance Flash‑Sale System with Redis Caching and CDN
Beike Product & Technology
Beike Product & Technology
Jul 1, 2021 · Backend Development

Understanding Node.js Asynchronous I/O Model and Its Impact on High‑Concurrency Performance

The article analyses a real‑world Node.js service outage caused by sudden 504 timeouts, explains how the asynchronous I/O model creates time‑slice contention under high QPS, presents load‑testing code and results for both I/O‑ and CPU‑bound requests, and offers practical mitigation strategies such as clustering, caching and resource scaling.

BackendCPU BottleneckLoad Testing
0 likes · 20 min read
Understanding Node.js Asynchronous I/O Model and Its Impact on High‑Concurrency Performance
Top Architect
Top Architect
Jun 21, 2021 · Backend Development

Implementing High‑Performance Long‑Connection Services with Netty: Challenges and Optimizations

This article explains how to build a scalable long‑connection service using Netty, covering the underlying concepts, Linux kernel tuning, code examples for Java NIO and Netty, performance bottlenecks such as QPS, data‑structure and GC issues, and practical optimization techniques to achieve hundreds of thousands of concurrent connections.

Java NIOLinux TuningNetty
0 likes · 13 min read
Implementing High‑Performance Long‑Connection Services with Netty: Challenges and Optimizations
ITPUB
ITPUB
Jun 15, 2021 · Backend Development

How to Build a High‑Performance Flash‑Sale System: Architecture, CDN, and Rate‑Limiting Strategies

This article explains how to design a flash‑sale (秒杀) system that handles massive concurrent traffic by staticizing product pages, using CDN pre‑heat, applying gateway rate‑limiting and segmented request release, leveraging Redis and asynchronous queues for inventory and order processing, and isolating services to protect normal business.

e‑commerceflash salehigh concurrency
0 likes · 11 min read
How to Build a High‑Performance Flash‑Sale System: Architecture, CDN, and Rate‑Limiting Strategies
21CTO
21CTO
Jun 15, 2021 · Backend Development

Master High‑Performance Linux Servers with OpenResty, Epoll, and Lua

Learn how Linux’s non‑blocking I/O mechanisms such as select, poll, and epoll enable high‑concurrency servers, explore OpenResty’s Lua‑based architecture, and follow step‑by‑step instructions for installing, configuring, and troubleshooting a performant OpenResty/Nginx environment on Linux.

LinuxLuaNginx
0 likes · 11 min read
Master High‑Performance Linux Servers with OpenResty, Epoll, and Lua
Code Ape Tech Column
Code Ape Tech Column
Jun 15, 2021 · Backend Development

How to Build Robust, High‑Concurrency APIs: Design, Security, and Scaling Tips

This article outlines practical guidelines for designing and implementing enterprise‑grade APIs, covering request/response definitions, unified error handling, interceptor chains, token‑based authentication, rate limiting, load balancing, clustering, caching, and strategies for achieving high concurrency and high availability.

Exception Handlingapi-designhigh concurrency
0 likes · 18 min read
How to Build Robust, High‑Concurrency APIs: Design, Security, and Scaling Tips
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 7, 2021 · Backend Development

Achieving High Concurrency, High Performance, and High Availability in Backend Systems

This article explains how to design backend architectures that meet the "three high" goals—high concurrency, high performance, and high availability—by using load balancing, connection pooling, traffic filtering, multi‑level caching, log optimization, and failover strategies.

Backend ArchitectureConnection Poolinghigh concurrency
0 likes · 12 min read
Achieving High Concurrency, High Performance, and High Availability in Backend Systems
dbaplus Community
dbaplus Community
May 23, 2021 · Backend Development

Designing Scalable Advertising Systems: Architecture, Challenges, and Solutions

This article explains the fundamentals of online advertising business, outlines its technical challenges such as high concurrency, complex logic, and massive data handling, and then details a practical architecture—including data storage, indexing, retrieval, billing, and reporting—offering actionable insights for building robust ad platforms.

AdvertisingBackendSystem Architecture
0 likes · 16 min read
Designing Scalable Advertising Systems: Architecture, Challenges, and Solutions
58 Tech
58 Tech
May 21, 2021 · Backend Development

Designing High‑Concurrency Systems with PHP Object Pooling and Swoole IPC

The article explains the core idea of pooling to trade space for time, analyzes the shortcomings of in‑process connection pools in PHP‑FPM, proposes long‑connection and cross‑process pooling solutions using Swoole’s IPC mechanisms, and demonstrates significant CPU and latency improvements in a real‑world high‑concurrency backend.

Connection PoolingIPCPHP
0 likes · 9 min read
Designing High‑Concurrency Systems with PHP Object Pooling and Swoole IPC
Volcano Engine Developer Services
Volcano Engine Developer Services
May 15, 2021 · Cloud Native

Douyin’s Spring Festival Red Packet: Service Mesh, Distributed DBs & IaaS Secrets

The Volcano Engine Developer Community’s May 15 online Meetup showcased four technical sessions—Service Mesh traffic management, distributed databases, mobile file distribution, and IaaS virtualization—detailing how Douyin’s Spring Festival red‑packet event handled massive traffic and ensured high performance.

Cloud NativeIaaS virtualizationService Mesh
0 likes · 4 min read
Douyin’s Spring Festival Red Packet: Service Mesh, Distributed DBs & IaaS Secrets
IT Architects Alliance
IT Architects Alliance
May 5, 2021 · Backend Development

Design and Technical Solutions for a High‑Concurrency Flash Sale (秒杀) System

This article analyzes the challenges of building a flash‑sale system—such as overselling, massive concurrent requests, URL exposure, and database pressure—and presents a comprehensive backend architecture that combines Redis clustering, Nginx load balancing, token‑bucket rate limiting, asynchronous order processing, and service degradation techniques.

Backend Architectureflash salehigh concurrency
0 likes · 13 min read
Design and Technical Solutions for a High‑Concurrency Flash Sale (秒杀) System
Top Architect
Top Architect
Apr 26, 2021 · Backend Development

Zookeeper Overview: Installation, Features, and Theory for High‑Concurrency Distributed Systems

This article introduces Zookeeper as a high‑performance coordination service for distributed systems, covering its role in concurrent environments, installation steps on Linux, core characteristics, data model, session and watch mechanisms, and practical usage examples to help readers understand and apply it in backend development.

Coordination ServiceZooKeeperbackend-development
0 likes · 14 min read
Zookeeper Overview: Installation, Features, and Theory for High‑Concurrency Distributed Systems
Programmer DD
Programmer DD
Apr 19, 2021 · Backend Development

Inside 12306’s High‑Concurrency Ticket System: Architecture, Load Balancing & Go Demo

This article dissects how China’s 12306 ticket platform handles millions of simultaneous requests by using layered load balancing, distributed clustering, Nginx weighted round‑robin, Redis‑based pre‑deduction, and a Go implementation that demonstrates local and remote stock deduction, performance testing, and fault‑tolerant design.

Godistributed architecturehigh concurrency
0 likes · 21 min read
Inside 12306’s High‑Concurrency Ticket System: Architecture, Load Balancing & Go Demo
Open Source Linux
Open Source Linux
Apr 9, 2021 · Backend Development

Why Nginx Beats Apache in High‑Concurrency Environments

This article explains why Nginx outperforms Apache under heavy load by comparing their architectures, work modes, memory usage, event‑driven design, and scalability techniques, and shows how Nginx can handle tens of thousands of concurrent connections with far less resources.

ApacheEvent-drivenNginx
0 likes · 11 min read
Why Nginx Beats Apache in High‑Concurrency Environments
High Availability Architecture
High Availability Architecture
Apr 6, 2021 · Backend Development

Ensuring Distributed Transaction Consistency in High‑Concurrency Flash‑Sale Systems with Transactional Messages and RocketMQ

This article explains how to achieve strong consistency for high‑traffic flash‑sale (seckill) scenarios by using distributed transaction principles, flexible transaction models, and Alibaba Cloud RocketMQ transactional messages, providing detailed architectural guidance, implementation steps, code examples, and operational best practices.

Distributed TransactionsMicroservicesRocketMQ
0 likes · 33 min read
Ensuring Distributed Transaction Consistency in High‑Concurrency Flash‑Sale Systems with Transactional Messages and RocketMQ
Baidu App Technology
Baidu App Technology
Mar 26, 2021 · Backend Development

Design and Evolution of Baidu Live Streaming Message Service

Baidu’s live‑streaming message service evolved from a basic group‑chat model to a scalable multicast architecture that delivers up to a million concurrent users per room with sub‑second latency, using message aggregation, compression, and priority channels to manage QPS, bandwidth, and reliable gift delivery.

architecturehigh concurrencylive streaming
0 likes · 28 min read
Design and Evolution of Baidu Live Streaming Message Service
Efficient Ops
Efficient Ops
Mar 25, 2021 · Backend Development

How to Build a Robust Flash‑Sale System that Handles Millions of Requests

This article explores the challenges of designing a flash‑sale (秒杀) system—such as overselling, high concurrency, request flooding, URL protection, and database bottlenecks—and presents a complete backend architecture using Redis, Nginx, rate‑limiting, asynchronous order processing, and service degradation to achieve a stable, high‑throughput solution.

Backend Architectureflash salehigh concurrency
0 likes · 14 min read
How to Build a Robust Flash‑Sale System that Handles Millions of Requests
Volcano Engine Developer Services
Volcano Engine Developer Services
Mar 23, 2021 · Cloud Native

How Douyin Handled 70B Red Packet Interactions in 27 Days with Cloud‑Native Magic

In just 27 days, Douyin and Volcano Engine's cloud‑native team built a Kubernetes‑based, elastically scalable infrastructure that supported 703 billion red‑packet interactions and over a trillion live‑stream views during the 2021 Spring Festival Gala, ensuring zero downtime and seamless user experience.

Cloud NativeEdge Computingdistributed storage
0 likes · 12 min read
How Douyin Handled 70B Red Packet Interactions in 27 Days with Cloud‑Native Magic
IT Architects Alliance
IT Architects Alliance
Mar 15, 2021 · Backend Development

Evolution of Meituan Instant Logistics Distributed System Architecture and Practices

The article details Meituan's five‑year journey in instant logistics, describing how distributed, high‑concurrency backend architectures were progressively upgraded to microservices, how AI is integrated for pricing, ETA and dispatch, and the operational techniques used to ensure scalability, fault tolerance, and high availability.

AIDistributed SystemsLogistics
0 likes · 8 min read
Evolution of Meituan Instant Logistics Distributed System Architecture and Practices
JD Retail Technology
JD Retail Technology
Mar 12, 2021 · Backend Development

Cache Synchronization in High‑Concurrency Environments: Problems and JD's CDC‑Based Solution

The article reviews common cache‑side data‑sync patterns, highlights their inconsistency and data‑loss risks under high load, and presents JD's solution that combines Cache‑Aside, Change Data Capture, message queues, delayed consumption, versioning, and persistence to ensure eventual consistency between cache and relational databases.

CDCCacheData Consistency
0 likes · 7 min read
Cache Synchronization in High‑Concurrency Environments: Problems and JD's CDC‑Based Solution
21CTO
21CTO
Feb 15, 2021 · Backend Development

From Java Developer to Architect: Lessons on Building High‑Concurrency Systems

The author reflects on their path from a senior Java developer to a software architect, describing early misconceptions, the pitfalls of over‑focusing on code, the importance of mastering existing components, and how design patterns and maintainability become essential when assembling high‑concurrency, distributed architectures.

Design PatternsDistributed SystemsSoftware Architecture
0 likes · 8 min read
From Java Developer to Architect: Lessons on Building High‑Concurrency Systems
Liangxu Linux
Liangxu Linux
Feb 12, 2021 · Backend Development

Why Is Nginx So Fast? A Deep Dive into Its Process and Event Model

This article explains Nginx's high performance by examining its multi‑process architecture, asynchronous event‑driven design, modular components, and I/O multiplexing mechanisms such as epoll, while also comparing it with Apache and detailing connection limits and request handling flow.

BackendEvent-drivenNginx
0 likes · 11 min read
Why Is Nginx So Fast? A Deep Dive into Its Process and Event Model
ITPUB
ITPUB
Feb 10, 2021 · Backend Development

From Java Developer to Architect: Lessons on High‑Concurrency Systems and Component‑Based Design

The author shares a personal journey from senior Java developer to aspiring architect, reflecting on interview mishaps, the pitfalls of over‑focusing on code, the importance of leveraging existing components, integrating them effectively, and applying design patterns for reusable, maintainable high‑concurrency systems.

Design Patternsbackend-developmentcomponent integration
0 likes · 10 min read
From Java Developer to Architect: Lessons on High‑Concurrency Systems and Component‑Based Design
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 28, 2021 · Backend Development

How Real-World Crises Shaped My Backend Coding Mastery

The author reflects on four pivotal experiences—from handling billion‑scale system outages to deep‑diving into JVM internals—that dramatically boosted his coding skills, emphasizing practical learning, robust code, and continuous self‑challenge for backend engineers.

JVMNetwork I/Ocode robustness
0 likes · 10 min read
How Real-World Crises Shaped My Backend Coding Mastery
21CTO
21CTO
Jan 28, 2021 · Backend Development

From Single Server to Cloud‑Native: Taobao’s 14‑Step Architecture Evolution

This article traces Taobao's backend architecture evolution—from a single‑server setup to distributed clusters, caching, load balancing, database sharding, microservices, containerization, and finally cloud‑native deployment—highlighting the technologies and design principles that enable scaling from hundreds to millions of concurrent users.

Backend ArchitectureCloud NativeDistributed Systems
0 likes · 22 min read
From Single Server to Cloud‑Native: Taobao’s 14‑Step Architecture Evolution
Qunar Tech Salon
Qunar Tech Salon
Jan 21, 2021 · Backend Development

Design and Implementation of Qunar's High‑Concurrency Instant Messaging System

The article details Qunar's in‑house instant messaging platform, covering its purpose, protocol choices (XMPP with protocol‑buffer optimization), architecture based on ejabberd, message flow, reliability mechanisms, extensions such as bots and HTTP APIs, as well as extensive system‑level tuning for high‑concurrency TCP connections.

ErlangInstant MessagingSystem optimization
0 likes · 15 min read
Design and Implementation of Qunar's High‑Concurrency Instant Messaging System
Alibaba Cloud Native
Alibaba Cloud Native
Jan 16, 2021 · Backend Development

How Real-World High‑Concurrency Challenges Shaped My Coding Skills

The author recounts four pivotal experiences—from handling a billion‑scale transaction system and joining Taobao’s ad‑hoc “firefighter” squad, to rewriting a communication framework and deep‑diving into JVM internals—illustrating how real‑world challenges and collaborative learning dramatically sharpened his coding and system‑reliability skills.

JVMhigh concurrencyjava
0 likes · 11 min read
How Real-World High‑Concurrency Challenges Shaped My Coding Skills
Top Architect
Top Architect
Jan 15, 2021 · Backend Development

Design and Technical Solutions for a High‑Concurrency Flash Sale System

This article examines the challenges of building a flash‑sale (秒杀) system—such as overselling, massive concurrent requests, URL exposure, and database bottlenecks—and presents a comprehensive backend architecture that combines separate databases, dynamic URLs, static pages, Redis clustering, Nginx load balancing, SQL optimization, rate‑limiting, asynchronous order processing, and service degradation techniques.

Nginxbackend designflash sale
0 likes · 13 min read
Design and Technical Solutions for a High‑Concurrency Flash Sale System
Programmer DD
Programmer DD
Jan 11, 2021 · Backend Development

Mastering Cache Strategies: Prevent Database Bottlenecks in High‑Traffic Systems

This article explains how large‑scale internet applications can use various caching patterns—Cache‑Aside, Read‑Through, Write‑Through, Write‑Behind—and mitigation techniques for consistency, stampede, penetration, jitter, and avalanche to keep databases from becoming performance bottlenecks under massive traffic spikes.

Backend PerformanceCache ConsistencyDistributed Systems
0 likes · 9 min read
Mastering Cache Strategies: Prevent Database Bottlenecks in High‑Traffic Systems
21CTO
21CTO
Jan 9, 2021 · Backend Development

How to Build a Robust Flash‑Sale System that Handles Millions of Requests

This article explores the key challenges of designing a flash‑sale (秒杀) system—such as overselling, high concurrency, request flooding, and database strain—and presents a comprehensive backend architecture with database design, dynamic URLs, caching, rate limiting, async ordering, and service degradation techniques.

Backend ArchitectureDatabase designasynchronous processing
0 likes · 13 min read
How to Build a Robust Flash‑Sale System that Handles Millions of Requests
Top Architect
Top Architect
Dec 22, 2020 · Backend Development

Design and Implementation of a High‑Concurrency Short URL Service

This article explains the benefits of short URLs, outlines their basic workflow, and details a backend design that uses an incremental issuer, base conversion, persistent storage, caching, batch ID allocation, and distributed issuers to achieve efficient, high‑concurrency short‑URL generation.

high concurrencyjavaredis
0 likes · 10 min read
Design and Implementation of a High‑Concurrency Short URL Service
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Dec 22, 2020 · Backend Development

How Short URLs Work: From Generation to High‑Performance Service Design

This article explains why short URLs are used in SMS and other platforms, outlines their benefits, describes the basic workflow of mapping long URLs to short ones, and dives into backend design choices such as incremental ID generation, storage strategies, caching, batch allocation, and distributed generation using Redis and Java.

Backendhigh concurrencyjava
0 likes · 11 min read
How Short URLs Work: From Generation to High‑Performance Service Design
Code Ape Tech Column
Code Ape Tech Column
Dec 12, 2020 · Backend Development

Building a Scalable Short‑URL Service with Redis and Java

Short URLs are popular in SMS and social media because they save characters, look tidy, enable analytics, and hide parameters; this article explains their benefits, the basic redirect workflow, and provides a detailed backend design—including storage choices, high‑concurrency strategies, distributed ID generation, and a Java‑Redis implementation.

Backenddistributed systemhigh concurrency
0 likes · 11 min read
Building a Scalable Short‑URL Service with Redis and Java
IT Architects Alliance
IT Architects Alliance
Dec 10, 2020 · Backend Development

Designing a High‑Concurrency Ticket Spike System: Load Balancing, Stock Deduction, and Go Implementation

This article explores the architecture and implementation of a high‑concurrency ticket‑spike system, covering distributed load‑balancing, Nginx weighted round‑robin configuration, Go‑based local and remote stock deduction with Redis, performance testing, and strategies to avoid overselling and underselling.

Godistributed systemhigh concurrency
0 likes · 19 min read
Designing a High‑Concurrency Ticket Spike System: Load Balancing, Stock Deduction, and Go Implementation
Selected Java Interview Questions
Selected Java Interview Questions
Dec 8, 2020 · Backend Development

High‑Concurrency Performance Tuning of a Java SSM E‑commerce Project: Diagnosis, Optimization, and Results

This article details a complete end‑to‑end high‑concurrency tuning process for a Java SSM monolithic e‑commerce system, covering problem identification, root‑cause analysis, a series of JVM, Tomcat, Redis and JDBC optimizations, horizontal scaling, code refactoring, and the resulting stability improvements.

JVMSSMTomcat
0 likes · 9 min read
High‑Concurrency Performance Tuning of a Java SSM E‑commerce Project: Diagnosis, Optimization, and Results
Architect
Architect
Dec 5, 2020 · Backend Development

High‑Concurrency Ticket Spike System Architecture and Implementation with Nginx, Redis, and Go

The article analyzes the extreme‑traffic challenges of China’s 12306 ticket‑spike service, presents a layered load‑balancing architecture using OSPF, LVS, and Nginx weighted round‑robin, and demonstrates a Go‑based prototype that combines local in‑memory stock deduction with Redis‑backed global stock control to achieve stable, high‑throughput ticket purchasing without overselling.

GoNginxhigh concurrency
0 likes · 20 min read
High‑Concurrency Ticket Spike System Architecture and Implementation with Nginx, Redis, and Go
dbaplus Community
dbaplus Community
Dec 3, 2020 · Backend Development

Boosting Distributed Lock Throughput for Thousands of Orders per Second

Learn how to overcome the concurrency bottleneck of traditional distributed locks in high‑traffic e‑commerce scenarios by applying segment‑based locking and other optimization techniques, enabling thousands of orders per second while preventing inventory overselling.

backend optimizationdistributed-locke‑commerce
0 likes · 11 min read
Boosting Distributed Lock Throughput for Thousands of Orders per Second
Architecture Digest
Architecture Digest
Nov 25, 2020 · Backend Development

Design and Implementation of a Short URL Service Using Redis and MySQL

The article explains why short URLs are popular, outlines their basic workflow, and details a backend service design that uses an incremental ID generator, Redis caching, MySQL storage, batch allocation, and distributed strategies to efficiently create and manage short links.

high concurrencymysqlshort URL
0 likes · 10 min read
Design and Implementation of a Short URL Service Using Redis and MySQL
Top Architect
Top Architect
Nov 8, 2020 · Backend Development

Flash Sale (Seckill) System Architecture, Technical Challenges and Solutions

This article analyzes the business flow of flash‑sale (seckill) systems, identifies ten technical challenges such as high concurrency, bandwidth, stock‑deduction and cheating, and presents architecture principles, design patterns, code examples, and safety mechanisms to build a reliable, scalable backend for flash‑sale scenarios.

System Architecturebackend-developmentcaching
0 likes · 34 min read
Flash Sale (Seckill) System Architecture, Technical Challenges and Solutions
Java Architect Essentials
Java Architect Essentials
Nov 2, 2020 · Cloud Computing

High-Concurrency Architecture and Optimization Strategies in Cloud Development

During the pandemic, the Yunnan “Anti‑Epidemic” mini‑program faced over 80 W requests per minute, prompting an analysis of how cloud development’s serverless, auto‑scaling architecture—covering data pipelines, cloud functions, and cloud databases—can ensure high performance, availability, and cost‑effective handling of massive concurrent traffic.

Cloud FunctionsServerlesscloud computing
0 likes · 19 min read
High-Concurrency Architecture and Optimization Strategies in Cloud Development
Architecture Digest
Architecture Digest
Nov 1, 2020 · Backend Development

Design and Technical Challenges of High‑Concurrency Flash Sale (Seckill) Systems

The article analyzes flash‑sale (秒杀) business characteristics, outlines the technical challenges of massive concurrent requests, and presents architectural principles, backend design, database strategies, concurrency control, anti‑cheat measures, and practical code examples to build a reliable high‑throughput system.

BackendSystem Designflash sale
0 likes · 31 min read
Design and Technical Challenges of High‑Concurrency Flash Sale (Seckill) Systems
Java Captain
Java Captain
Oct 31, 2020 · Backend Development

Flash Sale (Seckill) System Analysis, Technical Challenges, Architecture Design, and High‑Concurrency Solutions

This article examines the end‑to‑end workflow of a flash‑sale system, outlines its unique characteristics and technical challenges, and presents a layered architecture—including frontend, site, service, and database designs—along with concurrency control, anti‑cheating measures, and data‑safety strategies for handling massive traffic.

System Architecturecachingflash sale
0 likes · 34 min read
Flash Sale (Seckill) System Analysis, Technical Challenges, Architecture Design, and High‑Concurrency Solutions
Top Architect
Top Architect
Oct 21, 2020 · Backend Development

Design and Technical Solutions for a High‑Concurrency Flash Sale System

This article examines the challenges of building a flash‑sale (秒杀) system—such as overselling, high concurrency, request throttling, and database strain—and presents a comprehensive backend design using separate databases, dynamic URLs, static pages, Redis clustering, Nginx, token‑bucket rate limiting, asynchronous order processing, and service degradation strategies.

asynchronous processingbackend designflash sale
0 likes · 15 min read
Design and Technical Solutions for a High‑Concurrency Flash Sale System
Programmer DD
Programmer DD
Oct 19, 2020 · Backend Development

How to Build a High‑Performance Flash‑Sale System: Architecture, Challenges & Solutions

This article explores the end‑to‑end design of a flash‑sale (秒杀) system, detailing business flow, technical challenges, architectural principles, front‑end and back‑end design, concurrency handling, anti‑cheating measures, data safety, and practical solutions for high‑traffic e‑commerce scenarios.

System Architecturedatabase scalingflash sale
0 likes · 36 min read
How to Build a High‑Performance Flash‑Sale System: Architecture, Challenges & Solutions
Architects' Tech Alliance
Architects' Tech Alliance
Oct 8, 2020 · Backend Development

Evolution of Server‑Side Architecture from Single‑Machine to Cloud‑Native for High Concurrency

This article outlines the step‑by‑step evolution of a high‑traffic e‑commerce backend—from a single‑machine setup through caching, load balancing, database sharding, microservices, containerization, and finally cloud deployment—while summarizing the key technologies and design principles at each stage.

BackendMicroservicesScalability
0 likes · 18 min read
Evolution of Server‑Side Architecture from Single‑Machine to Cloud‑Native for High Concurrency
Top Architect
Top Architect
Oct 8, 2020 · Backend Development

Flash Sale (秒杀) System Architecture, Technical Challenges and Solutions

This article analyses the complete flash‑sale business flow, enumerates its unique characteristics and technical challenges such as high concurrency, bandwidth pressure, inventory overselling, and then presents a layered architecture—including frontend static pages, site‑level throttling, service‑level queuing, database sharding, caching, and anti‑cheat mechanisms—along with concrete Java code examples and best‑practice recommendations for building a reliable, high‑performance flash‑sale system.

Distributed SystemsSystem Architectureflash sale
0 likes · 32 min read
Flash Sale (秒杀) System Architecture, Technical Challenges and Solutions
Liangxu Linux
Liangxu Linux
Oct 1, 2020 · Operations

Boost Linux High‑Concurrency Performance with Essential Kernel Tweaks

This guide explains how to configure Linux system limits, kernel TCP parameters, and I/O event mechanisms to enable a single process to handle a large number of simultaneous connections, improving server throughput and stability under high‑concurrency workloads.

Kernel TuningLinuxhigh concurrency
0 likes · 13 min read
Boost Linux High‑Concurrency Performance with Essential Kernel Tweaks
Architecture Digest
Architecture Digest
Sep 30, 2020 · Backend Development

Introduction to Linux Socket Programming and OpenResty Deployment

This article explains Linux socket programming techniques such as non‑blocking I/O and epoll, discusses caching and asynchronous design for high‑performance servers, and provides a step‑by‑step guide to installing, configuring, and developing with OpenResty (Nginx + Lua) on Linux and Windows environments.

LuaOpenRestyhigh concurrency
0 likes · 12 min read
Introduction to Linux Socket Programming and OpenResty Deployment
Laravel Tech Community
Laravel Tech Community
Sep 27, 2020 · Databases

Using MySQL for Persistent Data and Redis for Read‑Only Data: Consistency Strategies and High‑Concurrency Solutions

The article explains how MySQL stores persistent data while Redis serves read‑only data, outlines read/write request handling, discusses consistency issues in low and high concurrency scenarios, and provides practical solutions such as cache invalidation, queue‑based updates, and deployment considerations.

Data ConsistencyQueuecaching
0 likes · 6 min read
Using MySQL for Persistent Data and Redis for Read‑Only Data: Consistency Strategies and High‑Concurrency Solutions
Java Architect Essentials
Java Architect Essentials
Sep 25, 2020 · Backend Development

Challenges and Solutions for Large‑Scale Concurrency in E‑commerce Flash Sales

The article examines the technical difficulties of handling tens of thousands of requests per second in flash‑sale systems, analyzes root causes such as API design, overload, cheating, and data‑safety issues, and proposes practical backend strategies—including Redis caching, load‑balancing, rate‑limiting, and optimistic locking—to maintain performance and reliability.

backend optimizationflash salehigh concurrency
0 likes · 15 min read
Challenges and Solutions for Large‑Scale Concurrency in E‑commerce Flash Sales
Youku Technology
Youku Technology
Sep 24, 2020 · Backend Development

Technical Practices for High‑Performance Ticketing Platforms: A Damai Case Study

Damai’s TicketingPaaS combines high‑performance snapshot caching, SVG‑based seat digitalization, and LoRa‑enabled edge intelligence to handle Double‑11‑scale traffic, ensure seat consistency, and provide resilient on‑site entry, while offering extensible APIs and exploring blockchain and 5G for future ticket authenticity and immersive experiences.

BlockchainIoTcloud edge
0 likes · 12 min read
Technical Practices for High‑Performance Ticketing Platforms: A Damai Case Study
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 20, 2020 · Databases

Database Read/Write Separation: Principles, Advantages, Disadvantages, and Implementation Strategies

Database read/write separation, alongside sharding and master‑slave architectures, mitigates high‑concurrency bottlenecks by distributing reads to replicas and writes to a primary, offering scalability and performance benefits while introducing challenges such as replication lag, routing complexity, and resource utilization trade‑offs.

Master‑SlaveRead-Write Separationhigh concurrency
0 likes · 10 min read
Database Read/Write Separation: Principles, Advantages, Disadvantages, and Implementation Strategies
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 20, 2020 · Backend Development

How to Build a Robust Flash Sale System: Architecture, Challenges, and Code Solutions

This article examines the critical issues of overselling, high concurrency, request throttling, and database design in flash‑sale systems, then outlines a comprehensive backend architecture with Redis clustering, Nginx load balancing, dynamic URLs, rate‑limiting, asynchronous order processing, and Java code examples to achieve a resilient high‑throughput solution.

Backend Architectureflash salehigh concurrency
0 likes · 13 min read
How to Build a Robust Flash Sale System: Architecture, Challenges, and Code Solutions
Top Architect
Top Architect
Sep 17, 2020 · Backend Development

Cache Consistency Strategies: Cache‑Aside Pattern, Deleting vs. Updating Cache, and Queue‑Based Solutions for High Concurrency

The article explains how distributed cache‑aside patterns work, why deleting stale cache entries is often preferable to updating them, analyzes basic and complex cache‑database inconsistency scenarios, and proposes a JVM‑queue‑driven, single‑threaded update mechanism with practical considerations for high‑concurrency environments.

BackendConsistencyDistributed Systems
0 likes · 11 min read
Cache Consistency Strategies: Cache‑Aside Pattern, Deleting vs. Updating Cache, and Queue‑Based Solutions for High Concurrency
Aikesheng Open Source Community
Aikesheng Open Source Community
Sep 17, 2020 · Backend Development

Understanding Rate Limiting: Leaky Bucket and Token Bucket Algorithms with a Python Example

This article explains the principles of leaky‑bucket and token‑bucket rate‑limiting algorithms, compares their behavior in high‑concurrency e‑commerce scenarios, and provides a complete Python implementation to illustrate how token‑bucket can handle burst traffic while maintaining system stability.

PythonToken Buckethigh concurrency
0 likes · 7 min read
Understanding Rate Limiting: Leaky Bucket and Token Bucket Algorithms with a Python Example
Programmer DD
Programmer DD
Sep 15, 2020 · Backend Development

Solving Distributed Cache Consistency: Cache‑Aside Pattern & Lazy Update Strategies

This article explains the classic Cache‑Aside pattern, analyzes common cache‑database consistency problems in high‑traffic systems, and presents practical solutions—including delete‑first updates, internal JVM queues, lazy recomputation, and routing considerations—to ensure reliable data synchronization under heavy concurrency.

Backend ArchitectureData Consistencycache-aside
0 likes · 11 min read
Solving Distributed Cache Consistency: Cache‑Aside Pattern & Lazy Update Strategies
High Availability Architecture
High Availability Architecture
Sep 11, 2020 · Backend Development

Design Principles and Practical Implementation of Network Coroutines in iQIYI's libfiber

This article explains the design concepts, programming practices, performance optimizations, and real‑world applications of iQIYI's open‑source network coroutine library libfiber, covering non‑blocking I/O, coroutine scheduling, event‑engine design, synchronization mechanisms, and its use in high‑performance CDN and DNS services.

asynchronous I/Oevent-driven programminghigh concurrency
0 likes · 25 min read
Design Principles and Practical Implementation of Network Coroutines in iQIYI's libfiber
Architect
Architect
Sep 9, 2020 · Backend Development

Cache Aside Pattern and Solutions for Cache‑Database Consistency in High‑Concurrency Environments

The article explains the classic Cache Aside pattern, why deleting rather than updating cache is preferred, analyzes basic and complex cache inconsistency scenarios, and proposes a queue‑based lazy update solution with practical considerations for read‑write blocking, request routing, and hotspot handling in high‑traffic systems.

ConsistencyDistributed SystemsQueue
0 likes · 11 min read
Cache Aside Pattern and Solutions for Cache‑Database Consistency in High‑Concurrency Environments
HomeTech
HomeTech
Sep 9, 2020 · Databases

Using TiDB for High-Concurrency Event Management

The article details how TiDB was deployed for the high-concurrency '818 Global Car Night' event, providing robust database solutions for real-time transactions and analytics.

Database ManagementEvent TechnologyTiDB
0 likes · 10 min read
Using TiDB for High-Concurrency Event Management