Skip to content
Tagged articles

Backend Architecture

500 articles · Page 1 of 5
Java Captain
Java Captain
Nov 7, 2026 · Industry Insights

Why ByteDance Embraces Go/Rust While Alibaba Sticks with Java: History, Talent, and Migration Economics

The article explains how historical regional talent pools, legacy codebases, and cost-benefit analysis drove Chinese tech giants' language choices: ByteDance adopted Go/Rust due to its Beijing-based PHP/C++ heritage and greenfield start, while Alibaba remains on Java because of its Hangzhou roots, massive Spring ecosystem, and prohibitive migration costs for marginal gains.

Backend ArchitectureChinese tech giantsGo
0 likes · 9 min read
Why ByteDance Embraces Go/Rust While Alibaba Sticks with Java: History, Talent, and Migration Economics
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Oct 29, 2026 · Backend Development

API Idempotency Deep Dive: 8 Patterns, 4-Layer Defense & Production Code

A comprehensive guide to API idempotency covering concept clarification, six sources of duplicate requests, a golden formula (unique key + deduplication storage + atomic operation), four-layer defense architecture, eight implementation patterns with code examples, common pitfalls with solutions, and interview preparation questions.

Backend ArchitectureDistributed SystemsIdempotency
0 likes · 45 min read
API Idempotency Deep Dive: 8 Patterns, 4-Layer Defense & Production Code
AI Large-Model Wave and Transformation Guide
AI Large-Model Wave and Transformation Guide
Oct 27, 2026 · Backend Development

OntoL7.0 Architecture: MySQL8 Migration with SQLite Dialect Translation

The article details OntoL7.0's technical architecture after migrating business data to MySQL8, maintaining a single codebase with two isolated data stores (MySQL for business, SQLite for system) plus graph and vector storage, using a dialect translation layer to convert SQLite syntax to MySQL at the driver level.

Backend ArchitectureChromaDBDatabase Migration
0 likes · 5 min read
OntoL7.0 Architecture: MySQL8 Migration with SQLite Dialect Translation
Ray's Galactic Tech
Ray's Galactic Tech
Oct 14, 2026 · Backend Development

From Chatbot to AI Agent: Why a Single While Loop Fails in Production

The article details the first week of the Aegis project, demonstrating why a naive while-loop agent loop fails in production and how to replace it with deterministic contracts, a finite state machine, bounded execution budgets, server-side tool authorization, and reproducible failure testing using local mocks.

AI agentBackend ArchitectureGo
0 likes · 25 min read
From Chatbot to AI Agent: Why a Single While Loop Fails in Production
Mike Chen Rui
Mike Chen Rui
Oct 12, 2026 · Backend Development

Nginx Static-Dynamic Separation: Principles, Architecture & Practical Configuration

This article explains Nginx static-dynamic separation principles and architecture, showing how Nginx routes static files directly via root/alias while proxying dynamic requests to backend services, with complete configuration examples including caching headers and proxy settings that can reduce backend load by over 70%.

Backend ArchitectureCDNNginx
0 likes · 5 min read
Nginx Static-Dynamic Separation: Principles, Architecture & Practical Configuration
ITPUB
ITPUB
Oct 7, 2026 · Backend Development

Rails 8 Drops Redis: How PostgreSQL's SKIP LOCKED Powers SolidQueue

Rails 8 replaces Redis with database-backed SolidQueue, SolidCache, and SolidCable, leveraging PostgreSQL's SKIP LOCKED for efficient task queues and arguing that most applications overpay a hidden 'middleware tax' for specialized infrastructure they don't actually need.

Backend ArchitecturePostgreSQLRails 8
0 likes · 14 min read
Rails 8 Drops Redis: How PostgreSQL's SKIP LOCKED Powers SolidQueue
CodeSmart Hoops
CodeSmart Hoops
Oct 3, 2026 · Backend Development

Building a Custom Redis Distributed Session: Token Design, Dual-Index Storage & Atomic Login

This article walks through designing a production-grade Redis-backed distributed session system, covering why single-node sessions fail under load balancing, secure token generation with SecureRandom, dual-index Redis storage using Hash and Set with Lua atomic writes, sliding vs absolute expiration, multi-device login limits, and complete login/logout/kick-out implementation with Redisson.

Backend ArchitectureMulti-Device LoginRedis
0 likes · 31 min read
Building a Custom Redis Distributed Session: Token Design, Dual-Index Storage & Atomic Login
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Sep 29, 2026 · Backend Development

10 System Design Questions That Decide Big Tech Interview Success

This article dissects 10 high-frequency system design questions — seckill, short URL, distributed ID, delayed tasks, leaderboard, real-time push, short-video feed, sharding, rate limiting, and config center — with architecture diagrams, core code, and comparative solutions for each.

Backend ArchitectureDistributed SystemsMessage Queue
0 likes · 73 min read
10 System Design Questions That Decide Big Tech Interview Success
Data Bricklaying Diary
Data Bricklaying Diary
Sep 21, 2026 · Backend Development

Scaling Isn't Just Adding Instances: End-to-End Capacity, Traffic & Cost Design

This article argues that true system scaling requires end-to-end capacity planning across ingress, task processing, dependencies, and recovery—not merely adding instances—and shows how to translate business growth into workload models, manage backpressure, set per-link capacity budgets, validate with realistic load tests, and balance cost against performance.

Auto ScalingBackend Architecturebackpressure
0 likes · 24 min read
Scaling Isn't Just Adding Instances: End-to-End Capacity, Traffic & Cost Design
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Sep 11, 2026 · Backend Development

Dubbo Internals Deep Dive: Architecture, Protocols, Load Balancing, Fault Tolerance, SPI & Triple Protocol

This comprehensive technical guide covers Dubbo's five-role architecture, service exposure/reference flows, protocol/serialization selection, four load balancing strategies, six cluster fault-tolerance policies, SPI adaptive extension mechanism, and Dubbo 3.x Triple protocol with application-level service discovery — complete with code-level call chains, comparison tables, and production-grade selection criteria.

Backend ArchitectureDubboFault Tolerance
0 likes · 52 min read
Dubbo Internals Deep Dive: Architecture, Protocols, Load Balancing, Fault Tolerance, SPI & Triple Protocol
Cloud Architecture
Cloud Architecture
Aug 20, 2026 · Backend Development

How a JSON Schema Can Power Billions‑Daily Dynamic Forms: Enterprise‑Level Data Model Architecture

This article explains why dynamic forms are fundamentally a dynamic data‑model problem, outlines a complete enterprise‑grade architecture that compiles JSON Schema into a cached, versioned runtime, and details the end‑to‑end submission flow, multi‑tenant governance, indexing, projection, and observability needed to sustain billions of daily submissions.

Backend ArchitectureData ModelingJSON Schema
0 likes · 36 min read
How a JSON Schema Can Power Billions‑Daily Dynamic Forms: Enterprise‑Level Data Model Architecture
Architecture Digest
Architecture Digest
Aug 17, 2026 · Backend Development

From a Naïve Scheduled Task to Scalable Delayed‑Task Solutions for 10M+ Orders

The article dissects a common interview question about automatically canceling unpaid orders, explains why a simple cron job fails at massive scale, and presents three robust designs—Redis expiration, Redis ZSet polling, and MQ/time‑wheel approaches—plus pitfalls and a ready‑to‑use answer template.

Backend ArchitectureDelayed TaskDistributed Systems
0 likes · 11 min read
From a Naïve Scheduled Task to Scalable Delayed‑Task Solutions for 10M+ Orders
Java Tech Workshop
Java Tech Workshop
Aug 17, 2026 · Backend Development

How to Keep Redis and MySQL Consistent? Update DB First or Delete Cache First?

This article analyzes why cache and database can become inconsistent, compares four basic cache‑update patterns, explains the delayed double‑delete technique, shows how to use MQ for retrying cache deletions, and evaluates Canal binlog subscription as a zero‑intrusion solution for strong eventual consistency.

Backend ArchitectureCache AsideCache Consistency
0 likes · 28 min read
How to Keep Redis and MySQL Consistent? Update DB First or Delete Cache First?
Ray's Galactic Tech
Ray's Galactic Tech
Aug 13, 2026 · Backend Development

Event Sourcing Primer: Rebuilding State Without a Database

This article explains how event sourcing replaces the traditional current‑state table with an immutable event log, allowing systems to reconstruct any state, handle concurrency, support auditing, and power flexible read models through projections, while outlining the necessary architectural components such as aggregates, event stores, snapshots, outbox, idempotency, and the natural transition to CQRS.

Backend ArchitectureCQRSIdempotency
0 likes · 32 min read
Event Sourcing Primer: Rebuilding State Without a Database
Code Farming
Code Farming
Aug 13, 2026 · Databases

Redis vs MySQL for Shopping Carts: Why I Chose the Option That Can Lose Data

The article explains that a shopping cart can tolerate loss of recent writes but not accumulated items, outlines the data model with seven fields and a unique key, compares client‑side storage options, details merge strategies for guest and logged‑in carts, and evaluates Redis, MySQL, and hybrid solutions with concrete trade‑offs.

Backend ArchitectureData ConsistencyRedis
0 likes · 13 min read
Redis vs MySQL for Shopping Carts: Why I Chose the Option That Can Lose Data
Code Farming
Code Farming
Aug 4, 2026 · Backend Development

Why 50,000 Simultaneous Registrations Crashed the System—and How Isolation Prevents It

When an education company faced 50,000 concurrent re‑registration requests, its monolithic internal‑external architecture collapsed, but by physically separating networks, enforcing gateway rate‑limiting and circuit‑breaking, pre‑loading data into Redis, and using one‑way Kafka streams, the system remained stable.

Backend ArchitectureCircuit BreakingKafka
0 likes · 6 min read
Why 50,000 Simultaneous Registrations Crashed the System—and How Isolation Prevents It
Java Tech Workshop
Java Tech Workshop
Aug 3, 2026 · Backend Development

A Ready‑to‑Use Spring Boot Template for Seamless Third‑Party Integration

The article explains why ad‑hoc third‑party integrations quickly become unmaintainable, identifies four common pain points, and presents a layered architecture using template method, strategy and factory patterns that abstracts common concerns such as retries, logging and signing, dramatically reducing duplicated code and maintenance effort.

Backend ArchitectureJavaSpring Boot
0 likes · 20 min read
A Ready‑to‑Use Spring Boot Template for Seamless Third‑Party Integration
Top Architect
Top Architect
Jul 23, 2026 · Backend Development

How Taobao’s Backend Architecture Evolved Over a Decade

The article walks through Taobao’s backend architecture transformation from a single‑server setup to a cloud‑native, micro‑service ecosystem, detailing fourteen evolutionary stages—including separate Tomcat and DB, caching, load balancing, sharding, NoSQL, ESB, containerization, and cloud deployment—while highlighting key concepts, challenges, and design principles.

Backend ArchitectureCloud NativeDistributed Systems
0 likes · 23 min read
How Taobao’s Backend Architecture Evolved Over a Decade
SpringMeng
SpringMeng
Jul 23, 2026 · Backend Development

Escape the if‑else Nightmare: Why Workflow Orchestration Is a Game‑Changer

The article explains how excessive if‑else branching in multi‑business systems leads to maintenance chaos, and demonstrates how a workflow engine combined with plugin extensions can isolate code, simplify extensions, and improve reliability through configurable flow chains and node execution.

Backend ArchitectureJavaWorkflow Orchestration
0 likes · 6 min read
Escape the if‑else Nightmare: Why Workflow Orchestration Is a Game‑Changer
The Dominant Programmer
The Dominant Programmer
Jul 21, 2026 · Backend Development

Practical Guide to Applying Domain‑Driven Design in Spring Boot Microservices

This guide explains Domain‑Driven Design (DDD) and shows how to structure Spring Boot microservices by organizing code around business domains, detailing strategic and tactical concepts, package layouts, layer responsibilities, cross‑domain communication, comparisons with traditional layering, evolution steps, and common FAQs.

Backend ArchitectureDDDJava
0 likes · 19 min read
Practical Guide to Applying Domain‑Driven Design in Spring Boot Microservices
DeepNoMind
DeepNoMind
Jul 18, 2026 · Backend Development

How Twilio Segment Replaced Hundreds of Microservices with a Single Monolith

The Twilio Segment team migrated their server‑side event‑forwarding infrastructure from a sprawling microservice architecture to a single monolithic service, detailing the performance bottlenecks, operational overhead, testing challenges, trade‑offs, and productivity gains that drove the decision.

Backend Architectureevent forwardingmicroservices
0 likes · 15 min read
How Twilio Segment Replaced Hundreds of Microservices with a Single Monolith
Airbnb Technology Team
Airbnb Technology Team
Jul 16, 2026 · Backend Development

Viaduct Five‑Year Review: Modernizing a Data‑Driven Service Mesh

Over five years, Airbnb's Viaduct service mesh grew traffic eightfold, doubled the number of owning teams to over 130, tripled its codebase to 1.5 million lines, halved incident minutes, and kept operational costs linear with QPS, leading to a major redesign and open‑source release.

AirbnbBackend ArchitectureGraphQL
0 likes · 14 min read
Viaduct Five‑Year Review: Modernizing a Data‑Driven Service Mesh
Yumin Fish Harvest
Yumin Fish Harvest
Jul 16, 2026 · Backend Development

Step 1 of DDD in Action: A Preferred Store Case Study Shows How to Apply Strategic Design

This article walks through a complete DDD strategic‑design workshop for a community‑focused retail e‑commerce system, showing how to identify business goals, split sub‑domains, decide core versus supporting domains, define bounded contexts, build a unified language, draw context maps, capture risks, and prepare review artefacts before moving to tactical design.

Backend ArchitectureBounded ContextDDD
0 likes · 33 min read
Step 1 of DDD in Action: A Preferred Store Case Study Shows How to Apply Strategic Design
Huolala Tech
Huolala Tech
Jul 15, 2026 · Backend Development

Too Many Complex Business Rules? How a Rule Visualization Platform Simplifies Management

The article explains why scattered, frequently changing business rules cause maintenance headaches, and introduces a rule visualization configuration platform that provides visual authoring, validation, approval, gray release, and local execution to make complex rule iteration safer and more efficient.

Backend ArchitectureGray ReleaseLiteFlow
0 likes · 28 min read
Too Many Complex Business Rules? How a Rule Visualization Platform Simplifies Management
Yumin Fish Harvest
Yumin Fish Harvest
Jul 14, 2026 · Backend Development

Mastering CQRS: When to Separate Read and Write in DDD

This article explains how CQRS splits write operations that enforce business rules using domain models from read operations optimized for page performance, illustrates common pitfalls of mixing the two, and provides concrete Java code, SQL examples, migration steps, validation checklists, and best‑practice guidelines for implementing lightweight CQRS in a DDD‑based backend.

Backend ArchitectureCQRSCommand Query Separation
0 likes · 26 min read
Mastering CQRS: When to Separate Read and Write in DDD
AI Engineer Programming
AI Engineer Programming
Jul 14, 2026 · Backend Development

How vLLM Generates Tokens: A Deep Dive into the Source Code

This article walks through vLLM’s token‑generation pipeline by dissecting its source files, process roles, ZMQ communication, scheduling, and deployment considerations, revealing how prompts become streamed token IDs and highlighting the key factors that limit concurrency and performance.

Backend ArchitectureGPU memoryLLM inference
0 likes · 17 min read
How vLLM Generates Tokens: A Deep Dive into the Source Code
YiSu Grain
YiSu Grain
Jul 9, 2026 · Backend Development

Why Adding Cache First Is the Wrong Move for Slow Systems

The article explains that performance tuning should start with pinpointing bottlenecks using response time, throughput, concurrency and resource utilization metrics, then choose appropriate measures—caching, async processing, database tuning, horizontal scaling, and rate‑limiting—rather than blindly adding a cache.

Asynchronous ProcessingBackend ArchitectureHorizontal Scaling
0 likes · 12 min read
Why Adding Cache First Is the Wrong Move for Slow Systems
IoT Full-Stack Technology
IoT Full-Stack Technology
Jul 9, 2026 · Backend Development

Comprehensive Collection of Java Backend Architecture Diagrams

This article compiles a comprehensive set of 31 Java‑related architecture diagrams, covering core components such as the class loader, JVM, threading, Spring, Hibernate, as well as related technologies like Android, Linux kernel, cloud computing, and enterprise solutions, each illustrated with detailed images.

AndroidBackend ArchitectureHibernate
0 likes · 5 min read
Comprehensive Collection of Java Backend Architecture Diagrams
LuTiao Programming
LuTiao Programming
Jul 8, 2026 · Backend Development

AI Hotspots Shift: GPT Real‑Time Voice, Seedance Video, Grok Coding – Pressure on Java Back‑ends

Recent AI releases—OpenAI’s GPT‑Live for full‑duplex voice, ByteDance’s Seedance for multi‑shot video generation, and xAI’s Grok 4.5 for coding and knowledge work—force Java back‑end teams to evolve from handling orders and queues to managing diverse AI capabilities, routing, task orchestration, cost, audit and security.

AI IntegrationBackend ArchitectureGPT‑Live
0 likes · 19 min read
AI Hotspots Shift: GPT Real‑Time Voice, Seedance Video, Grok Coding – Pressure on Java Back‑ends
YiSu Grain
YiSu Grain
Jul 7, 2026 · Fundamentals

Why Cache Isn't a Magic Bullet: How Redis Can Still Overload Your Database

The article explains how caching, especially with Redis, reduces database load in high‑traffic scenarios, but also details three cache failure modes—avalanche, penetration, and breakdown—and provides concrete mitigation techniques to keep systems stable.

Backend ArchitectureCacheRedis
0 likes · 13 min read
Why Cache Isn't a Magic Bullet: How Redis Can Still Overload Your Database
Cloud Architecture
Cloud Architecture
Jul 4, 2026 · Backend Development

Production-Ready SMS Verification Login System: Security Countermeasures and Engineering

This article presents a comprehensive guide to building a production-grade SMS verification login system, covering threat modeling, multi-layer rate limiting, state management with Redis, asynchronous message handling, multi‑provider routing, token issuance and operational monitoring to ensure security, cost control, and high availability.

Backend ArchitectureOutboxRedis
0 likes · 36 min read
Production-Ready SMS Verification Login System: Security Countermeasures and Engineering
Niu Liu
Niu Liu
Jul 4, 2026 · Backend Development

Designing an E‑commerce Pricing Engine with Aviator Rule Engine

The article explains how a unified ActivityBO model and three Aviator rule‑chains (check, compute, show) were used to build a flexible pricing‑engine middle‑platform that handles 40+ promotion types, solves allocation precision, supports self‑service configuration, and dramatically reduces deployment time for e‑commerce businesses.

AviatorBackend ArchitecturePricing Engine
0 likes · 13 min read
Designing an E‑commerce Pricing Engine with Aviator Rule Engine
Niu Liu
Niu Liu
Jun 29, 2026 · Big Data

Designing a Real‑Time Data Warehouse Backend with Flink and Paimon for SMBs

The article walks through the architecture and core workflow of a lightweight real‑time data warehouse built on Flink and Paimon, covering service‑layer refactoring, CDC task lifecycle, dual Flink submission modes, metadata synchronization, and layered security measures for small‑to‑medium enterprises.

Backend ArchitectureCDCFlink
0 likes · 11 min read
Designing a Real‑Time Data Warehouse Backend with Flink and Paimon for SMBs
Tinker Programmer
Tinker Programmer
Jun 29, 2026 · Backend Development

Why Bounded Contexts Are the Real Basis for Splitting Microservices

The article explains how bounded contexts, defined by language boundaries rather than functional ones, guide the logical separation of a payroll system into distinct domains, illustrating the process with concrete terminology lists, ambiguity detection, authority mapping, code examples, and deployment‑agnostic module structures.

Backend ArchitectureBounded Contextdomain-driven design
0 likes · 13 min read
Why Bounded Contexts Are the Real Basis for Splitting Microservices
ZhiKe AI
ZhiKe AI
Jun 7, 2026 · Backend Development

Why Event Sourcing Rebuilds State from an Event Sequence

The article explains how Event Sourcing stores immutable, ordered events instead of the current state, details aggregate rehydration, snapshots, and projections, clarifies its orthogonal relationship with CQRS and DDD, and debunks four common misconceptions about the pattern.

Backend ArchitectureCQRSDDD
0 likes · 13 min read
Why Event Sourcing Rebuilds State from an Event Sequence
Architect's Guide
Architect's Guide
May 27, 2026 · Backend Development

Comprehensive Collection of Java Backend Architecture Diagrams

This article compiles over thirty detailed architecture diagrams covering Java class loaders, JVM, Spring, Hibernate, Android, Linux kernel, cloud computing, and various enterprise technologies, offering developers a visual reference library for understanding and designing Java backend systems.

Backend ArchitectureHibernateJVM
0 likes · 5 min read
Comprehensive Collection of Java Backend Architecture Diagrams
samdeepthink
samdeepthink
May 20, 2026 · Backend Development

Designing a Scalable Delivery Dispatch System for Chain Restaurants

The article details a three‑module architecture—capacity verification, platform routing, and status synchronization—showing how a chain restaurant can dynamically choose third‑party delivery services across multiple cities, handle asynchronous checks, prioritize platforms, and ensure reliable callbacks and resends.

Backend ArchitectureJavaRouting
0 likes · 13 min read
Designing a Scalable Delivery Dispatch System for Chain Restaurants
TonyBai
TonyBai
May 11, 2026 · Backend Development

Why Go Builds and Rust Optimizes: The Only Viable Backend Strategy for 2026

The article argues that modern backend systems inevitably hit a scalability wall, and the most effective way to cross it is to use Go for fast, simple service orchestration while delegating performance‑critical, resource‑intensive components to Rust, combining both languages to balance development speed, cost, and reliability.

Backend ArchitectureCloud Cost ManagementGo
0 likes · 10 min read
Why Go Builds and Rust Optimizes: The Only Viable Backend Strategy for 2026
TonyBai
TonyBai
May 7, 2026 · Backend Development

Why an AWS Evangelist Calls Go’s Concurrency a Joke Compared to JVM’s Superior Model

The article revisits the heated debate sparked by AWS evangelist James Ward, who argues that Go’s concurrency primitives are inferior to the JVM’s virtual threads, structured concurrency, and effect systems, using a demanding connection‑pool challenge to illustrate the trade‑offs and guide architects in choosing the right model for their workloads.

Backend ArchitectureConcurrencyEffect Systems
0 likes · 11 min read
Why an AWS Evangelist Calls Go’s Concurrency a Joke Compared to JVM’s Superior Model
Architect
Architect
May 2, 2026 · Backend Development

From a 30‑Minute DIY Agent to Harness as the New Backend – What Gaps Remain for an Agent‑Ready System?

The article examines a minimal 30‑minute Agent loop demo, then analyzes how Harness can serve as the backend by introducing a runtime capability registry, worker lifecycle management, diverse triggers, and unified tracing, outlining four concrete design actions to close the gaps for agent‑ready systems.

AgentBackend ArchitectureCapability Registry
0 likes · 18 min read
From a 30‑Minute DIY Agent to Harness as the New Backend – What Gaps Remain for an Agent‑Ready System?
IT Services Circle
IT Services Circle
May 2, 2026 · Backend Development

Why Add an Nginx Layer in Front of Spring Cloud Gateway?

The article explains that Nginx and Spring Cloud Gateway serve different roles—Nginx as a network gateway handling static files, load balancing, SSL termination, and ops tasks, while Gateway focuses on business routing—so using both together improves performance, scalability, and operational separation.

Backend ArchitectureNginxSpring Cloud Gateway
0 likes · 5 min read
Why Add an Nginx Layer in Front of Spring Cloud Gateway?
AliExpress Tech
AliExpress Tech
Apr 27, 2026 · Backend Development

Building ACE: Applying Financial‑Style Architecture to a Unified Cross‑Border E‑Commerce Campaign Platform

The article details how the AliExpress Campaign Engine (ACE) was built from FY25 foundations to FY26’s four‑pillar system—gateway, workbench, standardization, and intelligent AI—using financial‑system analogies to solve duplicated effort, high maintenance costs, and stability risks across multiple e‑commerce business lines.

AI automationBackend Architecturecampaign platform
0 likes · 35 min read
Building ACE: Applying Financial‑Style Architecture to a Unified Cross‑Border E‑Commerce Campaign Platform
JD Tech
JD Tech
Apr 23, 2026 · Backend Development

How JD Upgraded Its B‑Side Order Storage Architecture to Tackle Elasticsearch High‑Concurrency Pressure

Facing explosive merchant growth and soaring order volumes, JD redesigned its B‑side POP order storage by isolating large tenants, applying double‑hash routing, expanding clusters, buffering updates, and automating data archiving, ultimately delivering a high‑performance, scalable Elasticsearch platform that sustains massive traffic spikes.

Backend ArchitectureCluster ScalingData Skew
0 likes · 16 min read
How JD Upgraded Its B‑Side Order Storage Architecture to Tackle Elasticsearch High‑Concurrency Pressure
Wu Shixiong's Large Model Academy
Wu Shixiong's Large Model Academy
Apr 17, 2026 · Backend Development

How Claude Code’s Memory System Works: From SHA‑256 Storage to Coalescing Extraction

This article dissects Claude Code’s Memory subsystem, explaining the distinction between Session logs and persistent Memory, the SHA‑256‑based storage layout, file indexing, four memory types, prompt injection steps, two write pathways, the ExtractionCoordinator’s coalescing strategy, and how to explain the design in interviews.

Backend ArchitectureClaude CodeConcurrency
0 likes · 19 min read
How Claude Code’s Memory System Works: From SHA‑256 Storage to Coalescing Extraction
Architect Chen
Architect Chen
Apr 16, 2026 · Operations

L4 vs L7 Load Balancing at Million‑Concurrency: Which Is More Stable?

The article compares Layer‑4 and Layer‑7 load‑balancing solutions for million‑concurrency scenarios, outlining their use cases, advantages, typical tools, performance characteristics, and why large enterprises often combine both to achieve high stability and flexible traffic control.

Backend ArchitectureL4L7
0 likes · 3 min read
L4 vs L7 Load Balancing at Million‑Concurrency: Which Is More Stable?
Architecture Breakthrough
Architecture Breakthrough
Apr 16, 2026 · Backend Development

Mastering Asynchronous Processing: Design Principles, Patterns, and Risks

This comprehensive guide explains the purpose, core concepts, suitable scenarios, common patterns, benefits, and potential pitfalls of asynchronous processing, offering detailed design, development, review, and operational principles to help teams build reliable, high‑throughput systems.

Asynchronous ProcessingBackend Architectureperformance
0 likes · 22 min read
Mastering Asynchronous Processing: Design Principles, Patterns, and Risks
SpringMeng
SpringMeng
Apr 11, 2026 · Backend Development

How a New Tech Lead Crafted an Elegant Payment System Architecture

The article breaks down the complexities of payment processing by outlining business background, decomposing the workflow into modular steps, illustrating sequence diagrams, designing data structures, and addressing related domains such as product and coupon management, while highlighting key technical challenges like TCC transactions, locking, and retry mechanisms.

Backend ArchitectureOrder ProcessingTCC
0 likes · 8 min read
How a New Tech Lead Crafted an Elegant Payment System Architecture
Ray's Galactic Tech
Ray's Galactic Tech
Apr 10, 2026 · Backend Development

Building a Production‑Ready Go Function Calling Server: Architecture, Design, and Best Practices

This article explains why Function Calling requires a robust server‑side architecture, walks through a real e‑commerce use case, details the Go‑based protocol, modular design, concurrency handling, security, observability, deployment strategies, testing approaches, and a step‑by‑step roadmap for turning a demo into a production‑grade system.

Backend ArchitectureFunction CallingGo
0 likes · 37 min read
Building a Production‑Ready Go Function Calling Server: Architecture, Design, and Best Practices
Top Architect
Top Architect
Apr 10, 2026 · Backend Development

Essential Microservice Design Patterns Every Architect Should Know

This article provides a comprehensive overview of microservice architecture, outlining its core goals, design principles, and a wide range of decomposition, integration, database, event‑driven, observability, and cross‑cutting concern patterns, complete with practical examples and diagrams.

Backend ArchitectureDesign Patternsmicroservices
0 likes · 22 min read
Essential Microservice Design Patterns Every Architect Should Know
LuTiao Programming
LuTiao Programming
Apr 8, 2026 · Backend Development

From Chaos to Production: Building a Real Food-Delivery Backend with Spring Boot

The article chronicles the step‑by‑step evolution of a small team’s chaotic food‑delivery backend into a production‑ready system, detailing how they introduced layering, transactions, security, caching, async processing, messaging, observability, scalability, resilience, containerization, and testing using Spring Boot, Kafka, Redis, JWT, and Docker.

Backend ArchitectureKafkaRedis
0 likes · 10 min read
From Chaos to Production: Building a Real Food-Delivery Backend with Spring Boot
Java Tech Workshop
Java Tech Workshop
Apr 5, 2026 · Backend Development

How to Build a SpringBoot Multi‑Module Project with Service/DAO/Web Layered Design

The article explains why a single‑module SpringBoot project becomes problematic as business complexity grows, outlines the benefits of a multi‑module architecture—including clear responsibilities, high cohesion, faster compilation, and smoother microservice migration—and provides a step‑by‑step guide with Maven configuration, module responsibilities, code examples, packaging commands, and common pitfalls.

Backend ArchitectureMavenMulti-Module
0 likes · 15 min read
How to Build a SpringBoot Multi‑Module Project with Service/DAO/Web Layered Design
JD Tech
JD Tech
Apr 3, 2026 · Backend Development

How to Achieve Lightweight Process‑Level Service Isolation in a Distributed Microservice System

This article analyzes the growing complexity of a distributed microservice platform and presents three isolation strategies—application splitting, Hystrix thread‑/semaphore isolation, and a lightweight process‑level grouping approach—detailing their implementation, trade‑offs, and practical results for high‑traffic promotions.

Backend ArchitectureHystrixdeployment
0 likes · 9 min read
How to Achieve Lightweight Process‑Level Service Isolation in a Distributed Microservice System
Ray's Galactic Tech
Ray's Galactic Tech
Mar 26, 2026 · Backend Development

Why Go + PostgreSQL + sqlc Is the Secret to High‑Concurrency Backend Architecture

This article explains how combining Go, PostgreSQL, and sqlc creates a Zero‑ORM architecture that restores SQL to the center of high‑performance, highly controllable, and maintainable backend services, covering design principles, layer responsibilities, schema and query patterns, connection‑pool tuning, transaction handling, observability, and practical best‑practice checklists.

Backend ArchitectureGoPostgreSQL
0 likes · 36 min read
Why Go + PostgreSQL + sqlc Is the Secret to High‑Concurrency Backend Architecture
LuTiao Programming
LuTiao Programming
Mar 25, 2026 · Backend Development

From Confusion to Mastery: A Structured Path for System Design Skills

The article explains why many developers get stuck when moving from writing business code to system design, outlines a step‑by‑step engineering learning path that covers core components, hands‑on examples, trade‑off analysis, interview preparation, and communication techniques to build a holistic system‑design mindset.

Backend Architecturecache strategyinterview preparation
0 likes · 7 min read
From Confusion to Mastery: A Structured Path for System Design Skills
Tech Freedom Circle
Tech Freedom Circle
Mar 25, 2026 · Backend Development

Cracking Alibaba’s 10M Orders Interview: Architecture Seven‑Suite + Heterogeneous Storage Solution

The article dissects Alibaba’s second‑round interview question on handling 10 million daily order queries, exposing why a single sharding answer fails and presenting a comprehensive architecture‑seven‑suite combined with heterogeneous storage (MySQL, HBase, ClickHouse, ES, Redis, MQ) to achieve high concurrency, low latency, and reliable data consistency.

Backend ArchitectureDistributed Systemsdatabase scaling
0 likes · 40 min read
Cracking Alibaba’s 10M Orders Interview: Architecture Seven‑Suite + Heterogeneous Storage Solution
IT Services Circle
IT Services Circle
Mar 7, 2026 · Backend Development

Beyond Simple Redis: Advanced Multi‑Level Cache Strategies for High‑Performance Backend Systems

This article explores a series of unconventional yet practical caching designs—including consistent hashing with local caches, request‑scope caching, session‑level caching, client‑side caching, pre‑loading, and graceful degradation—to dramatically improve backend response times, reliability, and interview impact.

Backend ArchitectureConsistencyperformance
0 likes · 18 min read
Beyond Simple Redis: Advanced Multi‑Level Cache Strategies for High‑Performance Backend Systems
Top Architect
Top Architect
Feb 23, 2026 · Backend Development

How Taobao Scaled: 14 Evolution Steps of a Massive Backend Architecture

This article walks through the step‑by‑step evolution of a large‑scale e‑commerce backend—from a single‑server setup to microservices, containerization, and cloud platforms—highlighting the technical challenges, key technologies, and design principles that enable millions of concurrent users.

Backend Architecturecloud computingdatabase sharding
0 likes · 24 min read
How Taobao Scaled: 14 Evolution Steps of a Massive Backend Architecture
Architect's Guide
Architect's Guide
Feb 21, 2026 · Backend Development

Essential Microservice Design Patterns Every Backend Engineer Should Know

This article surveys common microservice design patterns—including decomposition, integration, event‑driven, cross‑cutting concerns, and observability—explaining their goals, trade‑offs, and practical implementation steps to help architects build scalable, resilient backend systems.

API GatewayBackend Architecturemicroservices
0 likes · 20 min read
Essential Microservice Design Patterns Every Backend Engineer Should Know
Top Architect
Top Architect
Feb 20, 2026 · Backend Development

Why a Workflow Engine Is Essential for Scalable Business Platforms

The article explains how excessive if‑else branching in multi‑business systems harms code maintainability, and demonstrates how a workflow engine combined with a plugin extension mechanism can isolate business logic, simplify testing, and enable flexible execution chains, using the open‑source MemberClub project as a concrete example.

Backend ArchitectureJavaSpringBoot
0 likes · 11 min read
Why a Workflow Engine Is Essential for Scalable Business Platforms
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Feb 12, 2026 · Backend Development

Boost Web Performance 5× with Nginx Static‑Dynamic Separation Architecture

This article explains how separating static and dynamic traffic with Nginx, configuring precise location rules, cache headers, and kernel optimizations can increase throughput by three to five times in high‑concurrency web architectures while reducing backend load and improving maintainability.

Backend ArchitecturePerformance Optimizationdynamic routing
0 likes · 4 min read
Boost Web Performance 5× with Nginx Static‑Dynamic Separation Architecture
Baobao Algorithm Notes
Baobao Algorithm Notes
Feb 12, 2026 · Artificial Intelligence

GLM-5 Unleashed: How the New Chinese LLM Tackles Full‑Stack Architecture and Complex System Design

The article reviews the newly released GLM-5 model, highlighting its ability to generate end‑to‑end system designs, write and debug backend code, and solve large‑scale engineering problems through detailed prompts, positioning it alongside GPT‑5.3 and Claude Opus in the competitive LLM landscape.

AI programmingBackend ArchitectureGLM-5
0 likes · 9 min read
GLM-5 Unleashed: How the New Chinese LLM Tackles Full‑Stack Architecture and Complex System Design
Top Architect
Top Architect
Feb 10, 2026 · Backend Development

Why Process Orchestration Is Essential for Scalable Backend Systems

The article explains how excessive if‑else logic harms maintainability in a business middle‑platform, introduces a flow‑engine and plugin‑extension approach to isolate code and support rapid business expansion, and demonstrates the design with the open‑source MemberClub project, including configuration, node definitions, execution principles and core Java implementation.

Backend ArchitectureJavaflow engine
0 likes · 11 min read
Why Process Orchestration Is Essential for Scalable Backend Systems
LuTiao Programming
LuTiao Programming
Feb 9, 2026 · Backend Development

Stop Memorizing Design Patterns—Use This Engineering Decision Tree to Solve Spring Boot Complexity

The article explains why design patterns often feel useless in Spring Boot projects, introduces a three‑branch decision tree that maps common sources of complexity to suitable patterns, and demonstrates a concrete refactor of an if‑else payment service into a clean, Spring‑managed strategy‑based solution.

Backend ArchitectureDependency InjectionDesign Patterns
0 likes · 9 min read
Stop Memorizing Design Patterns—Use This Engineering Decision Tree to Solve Spring Boot Complexity
Sohu Tech Products
Sohu Tech Products
Feb 4, 2026 · Backend Development

Why LiteFlow Is the Go‑to Rule Engine for Complex Business Logic

LiteFlow is a lightweight, open‑source Chinese rule engine that transforms tangled if‑else code into modular, hot‑deployable components using a simple EL DSL, offering high performance, multi‑language scripting, and visual orchestration for backend systems.

Backend ArchitectureComponent OrchestrationEL DSL
0 likes · 12 min read
Why LiteFlow Is the Go‑to Rule Engine for Complex Business Logic
dbaplus Community
dbaplus Community
Feb 3, 2026 · Backend Development

When Microservices Become a Trap: Risks, Costs, and When They Really Pay Off

This article explains why microservices, while attractive for large systems, introduce hidden costs, operational complexity, network latency, data management challenges, and testing difficulties, and provides a decision framework to determine when a monolith‑first approach is more appropriate.

Backend Architecturemicroservicesmonolith
0 likes · 15 min read
When Microservices Become a Trap: Risks, Costs, and When They Really Pay Off
Architect's Guide
Architect's Guide
Jan 27, 2026 · Databases

How to Scale an Order System with Sharding, Distributed IDs, and Seata Transactions

This article details a comprehensive redesign of a high‑traffic order system, covering the challenges of massive data volume, concurrency pressure, and poor scalability, and presenting a step‑by‑step solution that includes sharding strategy selection, database product comparison, unique ID generation, middleware choice, migration plan, risk mitigation, and FAQ handling.

Backend ArchitectureSeatadatabase scaling
0 likes · 17 min read
How to Scale an Order System with Sharding, Distributed IDs, and Seata Transactions
dbaplus Community
dbaplus Community
Jan 15, 2026 · Backend Development

How to Design a High‑Throughput Database Architecture for a Billion‑Row Daily Log System

This guide breaks down a real‑world interview scenario where a backend engineer must design a scalable database solution for a billing‑log or feed system handling 100 million daily inserts and 100 k QPS reads, covering partitioning vs sharding, sharding key selection, shard count, read‑write separation, multi‑level caching, consistency patterns, hot‑key mitigation, and online schema changes.

Backend ArchitectureOnline Schema ChangeRead-Write Separation
0 likes · 10 min read
How to Design a High‑Throughput Database Architecture for a Billion‑Row Daily Log System
dbaplus Community
dbaplus Community
Jan 8, 2026 · Backend Development

How Big Platforms Verify Username Availability in Milliseconds

This article walks through the layered architecture that large services like Instagram use to instantly check if a username is taken, starting from simple database queries, adding caching, employing Bloom filters, and finally using Trie structures for fast, memory‑efficient lookups.

Backend ArchitectureBloom filterTrie
0 likes · 10 min read
How Big Platforms Verify Username Availability in Milliseconds
Java Backend Technology
Java Backend Technology
Jan 7, 2026 · Backend Development

Why Spring WebFlux Matters: From Blocking MVC to Reactive Non‑Blocking Architecture

The article explains the limitations of Spring MVC's blocking model, introduces Spring WebFlux's reactive, asynchronous, non‑blocking architecture, compares annotation and functional programming models, details core components and request flow, and provides guidance on when and how to adopt WebFlux for high‑concurrency I/O‑intensive applications.

Backend ArchitectureFluxReactive Programming
0 likes · 13 min read
Why Spring WebFlux Matters: From Blocking MVC to Reactive Non‑Blocking Architecture
Architecture Breakthrough
Architecture Breakthrough
Jan 6, 2026 · Backend Development

How to Monitor and Resolve Failures in Asynchronous Task Processing

In complex systems where multiple modules must cooperate, asynchronous communication boosts throughput but often becomes a black box, so this article outlines three async patterns, their trade‑offs, and a comprehensive monitoring, alerting, and remediation framework for reliable operation.

Backend Architectureasynchronousfailure handling
0 likes · 5 min read
How to Monitor and Resolve Failures in Asynchronous Task Processing
Code Wrench
Code Wrench
Jan 6, 2026 · Backend Development

When to Move from Hooks to Events: A Practical Evolution Guide

This article examines how business scale and system boundaries evolve, explaining when hooks are optimal, why they become problematic, and how to transition smoothly to event‑driven architectures with concrete examples, signals, and a step‑by‑step migration path.

Backend Architectureevent-drivenhooks
0 likes · 9 min read
When to Move from Hooks to Events: A Practical Evolution Guide
Ray's Galactic Tech
Ray's Galactic Tech
Jan 5, 2026 · Backend Development

How We Replaced HTTP Polling with MQTT for Real‑Time, Low‑Latency Messaging

This article recounts the migration from a simple HTTP polling approach to an MQTT‑based real‑time communication architecture, detailing the motivations, technical comparisons, implementation steps, performance gains, operational challenges, and future directions for scalable event‑driven systems.

Backend ArchitectureMQTTReal-time Messaging
0 likes · 8 min read
How We Replaced HTTP Polling with MQTT for Real‑Time, Low‑Latency Messaging
Architect's Guide
Architect's Guide
Jan 5, 2026 · Backend Development

Beyond Sharding: How Unitization Solves Unlimited Service Scaling

The article traces the evolution from monolithic Java apps to RPC services, explains why sharding and database partitioning cannot alone achieve limitless scaling due to connection limits, and introduces unitization—assigning each application to a specific database shard—to overcome the bottleneck.

Backend ArchitectureRPCdatabase sharding
0 likes · 7 min read
Beyond Sharding: How Unitization Solves Unlimited Service Scaling
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jan 5, 2026 · Operations

How to Define “Excellent” QPS Benchmarks for System Capacity Planning

This article provides a comprehensive framework for evaluating system support capability by defining QPS excellence thresholds across industry benchmarks, business types, response time, resource efficiency, performance metrics, architectural guidelines, optimization tactics, and real‑world case studies, culminating in a practical calculation formula.

Backend ArchitectureQPSSystem Performance
0 likes · 5 min read
How to Define “Excellent” QPS Benchmarks for System Capacity Planning
ITPUB
ITPUB
Jan 3, 2026 · Backend Development

How to Build a Scalable Order Cancellation System: 3 Advanced Delayed‑Task Solutions

This article dissects a common interview question about automatically canceling unpaid orders after 30 minutes, explains why naive cron jobs fail at scale, and presents three robust backend designs—Redis ZSet polling, message‑queue delayed messages, and time‑wheel timers—along with practical code snippets and pitfalls to avoid.

Backend ArchitectureDistributed Systemsdelayed tasks
0 likes · 11 min read
How to Build a Scalable Order Cancellation System: 3 Advanced Delayed‑Task Solutions
Java Architect Handbook
Java Architect Handbook
Jan 3, 2026 · Databases

When Should You Avoid JOINs in High‑Concurrency Systems?

The article analyzes a common Java interview question about using JOINs, explaining performance bottlenecks, scalability issues in distributed and micro‑service architectures, and offers practical guidelines and best‑practice alternatives for handling data associations efficiently.

Backend ArchitectureDatabase PerformanceSQL
0 likes · 9 min read
When Should You Avoid JOINs in High‑Concurrency Systems?
Top Architect
Top Architect
Jan 1, 2026 · Backend Development

Why Overusing If‑Else Breaks Your Backend and How a Flow Engine Fixes It

The article explains how excessive if‑else branching in business‑centered back‑ends leads to tangled, hard‑to‑maintain code, and demonstrates how a flow‑engine combined with plugin extensions can isolate business logic, improve extensibility, and simplify testing, using the open‑source MemberClub project as a concrete example.

Backend ArchitectureSpringBootflow engine
0 likes · 9 min read
Why Overusing If‑Else Breaks Your Backend and How a Flow Engine Fixes It
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 19, 2025 · Backend Development

How AI Powered a DDD‑Driven Refactor of Taobao’s Service Package System

This case study shows how AI was used to analyze a monolithic service‑package system, automatically identify bounded contexts, generate DDD‑aligned code skeletons, and refactor duplicated business logic, reducing development effort from 5‑8 person‑days to a configurable solution while improving maintainability and extensibility.

AI-Assisted RefactoringBackend ArchitectureDDD
0 likes · 15 min read
How AI Powered a DDD‑Driven Refactor of Taobao’s Service Package System
Ctrip Technology
Ctrip Technology
Dec 18, 2025 · Backend Development

How UCS Powers Global Traffic Scheduling and Compliance

This article explains how Ctrip’s Universal Control Service (UCS) handles global traffic routing, data‑compliance zones, region failover, and gradual migration by using configurable strategy models, partitioning logic, and a lightweight degradation mask to ensure reliable, compliant user experiences worldwide.

Backend ArchitectureUCSdata compliance
0 likes · 12 min read
How UCS Powers Global Traffic Scheduling and Compliance
dbaplus Community
dbaplus Community
Dec 9, 2025 · Backend Development

How Bilibili Scaled Its Private Messaging System to Handle 10× Traffic

This article analyzes Bilibili's private messaging architecture, identifies performance bottlenecks such as MySQL slow queries, storage limits, and tightly coupled services, and presents a multi‑layer redesign with caching, sharding, BFF separation, and consistency mechanisms to sustain tenfold traffic growth.

Backend ArchitectureBilibilicaching
0 likes · 16 min read
How Bilibili Scaled Its Private Messaging System to Handle 10× Traffic
BirdNest Tech Talk
BirdNest Tech Talk
Dec 1, 2025 · Artificial Intelligence

Why Choose Go for AI Agents? Inside agent-web’s Zero‑Dependency Architecture

This article explains how the agent-web framework builds a powerful AI agent orchestration system in Go without external libraries, detailing the reasons for choosing Go, the use of go:embed for single‑binary deployment, core data structures, planning and execution logic, and the interaction handling that enables both CLI and web interfaces.

AI agentsBackend ArchitectureConcurrency
0 likes · 13 min read
Why Choose Go for AI Agents? Inside agent-web’s Zero‑Dependency Architecture
Architect Chen
Architect Chen
Dec 1, 2025 · Backend Development

How Nginx Static‑Dynamic Separation Boosts Web Performance

This article explains the principle of Nginx static‑dynamic separation, describes its layered architecture, request routing flow, and key optimization techniques such as caching, compression, load balancing, security limits, and monitoring to dramatically improve overall system performance.

Backend ArchitectureWeb Performanceload balancing
0 likes · 5 min read
How Nginx Static‑Dynamic Separation Boosts Web Performance
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 9, 2025 · Backend Development

Mastering Distributed Communication: Key Concepts and Frameworks for Scalable Backend Systems

This article explains the fundamentals of distributed communication, outlines essential elements such as serialization, transport protocols, service discovery, load balancing, security, and reliability, and reviews popular frameworks like gRPC, Dubbo, Thrift, and OpenFeign for building robust backend architectures.

Backend ArchitectureDubboSerialization
0 likes · 5 min read
Mastering Distributed Communication: Key Concepts and Frameworks for Scalable Backend Systems
NiuNiu MaTe
NiuNiu MaTe
Nov 5, 2025 · Backend Development

How to Build a High‑Concurrency, Strong‑Consistency E‑Commerce Order System

This article dissects the core processes, functional challenges, and architectural design of a high‑throughput, strongly consistent e‑commerce order system, covering forward and reverse flows, order creation, payment, fulfillment, cancellation, after‑sale handling, and the layered backend architecture that powers it.

Backend ArchitectureDistributed SystemsTransaction Consistency
0 likes · 21 min read
How to Build a High‑Concurrency, Strong‑Consistency E‑Commerce Order System
Architect Chen
Architect Chen
Nov 4, 2025 · Backend Development

Mastering RocketMQ: Architecture, Workflow, and Real‑World Use Cases

This article provides a comprehensive overview of RocketMQ, covering its core components (Producer, Broker, Consumer, NameServer), detailed architecture diagrams, step‑by‑step message production and consumption processes, and typical scenarios such as asynchronous decoupling, traffic shaping, transactional messaging, and event‑driven logging.

Backend ArchitectureConsumerDistributed Messaging
0 likes · 6 min read
Mastering RocketMQ: Architecture, Workflow, and Real‑World Use Cases
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Oct 31, 2025 · Backend Development

Microservices vs SOA: Key Differences Every Backend Engineer Should Know

This article compares microservices and SOA, covering design philosophy, service granularity, autonomy, communication mechanisms, and deployment/operations, highlighting how microservices favor lightweight protocols, independent deployment, and container orchestration, while SOA relies on centralized middleware and coarse‑grained services.

Backend ArchitectureSOAcommunication protocols
0 likes · 4 min read
Microservices vs SOA: Key Differences Every Backend Engineer Should Know
Huolala Tech
Huolala Tech
Oct 22, 2025 · Backend Development

Scaling Real‑Time Reconciliation with Dynamic Kafka Consumer Clusters

To ensure fund safety and robust operations, the team built a real‑time reconciliation platform that leverages Kafka, and after encountering scaling bottlenecks with a static consumer model, they implemented a dynamic, partition‑level, weighted load‑balancing consumer cluster that supports automatic scaling and high‑throughput processing.

Backend ArchitectureDistributed SystemsDynamic Scaling
0 likes · 15 min read
Scaling Real‑Time Reconciliation with Dynamic Kafka Consumer Clusters
Lin is Dream
Lin is Dream
Oct 14, 2025 · Backend Development

Designing a Scalable Short‑Link System: From Base62 Encoding to Security

This article explains how to build a production‑grade short‑link service, covering the background of SMS short URLs, Base62 encoding principles, database schema design, request routing, security measures such as custom alphabets, rate limiting, and signed links, and additional management features for operation and monitoring.

Backend ArchitectureSecuritybase62
0 likes · 16 min read
Designing a Scalable Short‑Link System: From Base62 Encoding to Security
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 12, 2025 · Backend Development

Master System Design: 30 Core Concepts Every Backend Engineer Must Know

This article presents a comprehensive guide to essential system‑design concepts—including client‑server architecture, IP addressing, DNS, proxies, latency, HTTP/HTTPS, APIs, REST, GraphQL, databases, scaling, caching, microservices, message queues, rate limiting, API gateways, and more—illustrated with Spring Boot 3 examples and diagrams.

Backend Architecturescalabilitysystem design
0 likes · 30 min read
Master System Design: 30 Core Concepts Every Backend Engineer Must Know
Architect
Architect
Oct 2, 2025 · Backend Development

How WeChat Reading Scaled Its Backend Architecture Over 10 Years

This article chronicles the decade‑long evolution of WeChat Reading’s backend, detailing architectural layers, RPC framework innovations, storage migrations, account system redesign, book data platform construction, and modern content retrieval techniques that together enable high availability and scalability.

Backend ArchitectureService Governancebook data platform
0 likes · 17 min read
How WeChat Reading Scaled Its Backend Architecture Over 10 Years
Architect's Guide
Architect's Guide
Oct 1, 2025 · Backend Development

How to Build High‑Traffic, High‑Concurrency Systems: Key Principles & Practices

Designing high‑traffic, high‑concurrency systems requires careful planning across architecture, client optimization, CDN usage, clustering, caching, database tuning, and service governance, with principles such as statelessness, modularity, and fault‑tolerance to ensure scalability, reliability, and maintainability.

Backend Architecturecachingdatabase scaling
0 likes · 12 min read
How to Build High‑Traffic, High‑Concurrency Systems: Key Principles & Practices
Architect's Guide
Architect's Guide
Sep 28, 2025 · Backend Development

Mastering Microservice Design Patterns: When, Why, and How to Apply Them

An in‑depth guide to microservice architecture explores its evolution, core characteristics, advantages and drawbacks, and walks through essential design patterns—Database per Service, Event Sourcing, CQRS, Saga, BFF, API Gateway, Strangler, Circuit Breaker, Externalized Configuration, and Consumer‑Driven Contract Testing—detailing when and why to use each.

Backend ArchitectureDesign Patterns
0 likes · 28 min read
Mastering Microservice Design Patterns: When, Why, and How to Apply Them
vivo Internet Technology
vivo Internet Technology
Sep 24, 2025 · Backend Development

How Vivo Browser Scaled to Millions: Architecture Upgrade for High‑Performance Coin Incentive System

This article details how Vivo Browser's welfare center was re‑engineered—splitting services, sharding databases, adding arbitration and soft‑transaction mechanisms—to overcome traffic, I/O, and data‑consistency challenges, enabling stable operation at tens of millions of daily active users while reducing storage costs.

Backend ArchitectureData Consistencydatabase sharding
0 likes · 11 min read
How Vivo Browser Scaled to Millions: Architecture Upgrade for High‑Performance Coin Incentive System