Backend Development 28 min read

Designing High‑Performance, High‑Concurrency, High‑Availability Backend Systems: Methodologies and Practices

This article shares a backend engineer’s comprehensive methodology and practical experiences for building systems that simultaneously achieve high performance, high concurrency, and high availability, covering performance optimization, caching strategies, scaling techniques, fault tolerance, and operational best practices across application, storage, and deployment layers.

JD Tech
JD Tech
JD Tech
Designing High‑Performance, High‑Concurrency, High‑Availability Backend Systems: Methodologies and Practices

Overview

The article begins with an overview of the MCube rendering pipeline: it checks template cache status, fetches the latest template if needed, loads the template, converts the product into a view‑tree structure, resolves expressions and custom events, binds them, and finally renders the view.

High‑Performance Chapter

Performance is analyzed from three dimensions—computation, communication, and storage. Common performance bottlenecks include complex business logic, full GC pauses, slow downstream services, and large tables or inefficient Elasticsearch shards. The author proposes read‑write oriented optimizations, illustrated with a diagram of practical methods.

Read Optimization: Cache‑Database Fusion

For read‑heavy workloads, the strategy is to keep the database as the source of truth and use caches (local or distributed) to accelerate reads. For write‑heavy workloads, the approach flips: cache is the primary source, with asynchronous database updates.

Write Optimization: Asynchronous Processing for Flash‑Sale Scenarios

High‑spike traffic (e.g., flash sales) is handled by immediately acknowledging the order, persisting it asynchronously via a message queue, and using cache to store SKU inventory. After successful stock deduction, a notification (e.g., SMS) is sent to the user.

High‑Concurrency Chapter

Concurrency is tackled through three scaling axes:

Horizontal (X‑axis) Scaling: Adding machines and shards to increase throughput during peak events (e.g., Double‑11). Application layer scaling is stateless and container‑based; storage scaling involves adding shards and handling data migration.

Vertical (Y‑axis) Scaling: Evolving from monolith to SOA, microservices, and service mesh, guided by Domain‑Driven Design (DDD) to separate business domains (product, order, payment, fulfillment).

Vertical (Z‑axis) Scaling: Addressing database connection limits by sharding (partitioning) and using master‑slave replication; also introducing geographic “unit” deployments to keep traffic and data close to users.

DDD Practice in Retail Logistics

The author describes how DDD is applied to split the logistics platform into domains such as product‑service, order, payment‑settlement, and fulfillment, each with its own microservice set. Business processes (forward and reverse flows) are illustrated with diagrams.

High‑Availability Chapter

Availability is ensured through protection and redundancy across three layers:

Application Layer

Rate Limiting: Token‑bucket, leaky‑bucket, sliding‑window, and counter algorithms are compared.

Circuit Breaking & Degradation: Prevent downstream failures from cascading; use manual (config‑center switches) and automatic (Hystrix‑like) mechanisms.

Timeouts: Set progressive timeouts following a “funnel” principle to fail fast.

Retries: Configure retry counts with idempotency checks; avoid retry storms.

Isolation: System‑level, environment‑level, data‑level, core/non‑core flow, read/write (CQRS), and thread‑pool isolation are detailed.

Compatibility: Forward and backward compatibility strategies to avoid data loss during version upgrades.

Storage Layer

High availability is achieved via replication (master‑slave, multi‑master, leaderless) and partitioning (range‑based and hash‑based). Specific technologies discussed include MySQL, Redis Cluster, Elasticsearch, and Kafka.

Deployment Layer

Deployment evolves from single‑machine to multi‑region, multi‑datacenter architectures using redundancy and load balancing. The current setup uses Docker containers across multiple data centers, dual‑room MySQL, dual‑room Redis, and single‑room Elasticsearch.

Conclusion

The software development journey is portrayed as a continuous battle against technical and business complexity. From a backend perspective, the author shares years of experience in building B‑ and C‑side systems that meet the “three‑high” requirements (high performance, high concurrency, high availability), inviting readers to discuss and improve together.

Finally, a recruitment notice for JD Logistics Platform Technology Department is included, encouraging interested engineers to apply via email.

BackendMicroservicesscalabilityHigh Availabilitysystem designhigh concurrencyhigh performance
JD Tech
Written by

JD Tech

Official JD technology sharing platform. All the cutting‑edge JD tech, innovative insights, and open‑source solutions you’re looking for, all in one place.

0 followers
Reader feedback

How this landed with the community

login Sign in to like

Rate this article

Was this worth your time?

Sign in to rate
Discussion

0 Comments

Thoughtful readers leave field notes, pushback, and hard-won operational detail here.