After a decade of microservices, the article argues that AI agents expose semantic gaps across CRM, ERP, and other systems, and proposes an Ontology Service Layer that unifies objects, relationships, states, metrics, actions, policies, and evidence to enable controlled, auditable AI‑native execution.
The article explains why IT and business often operate in silos, then outlines four concrete steps—flattening mutual understanding, forming an integrated product team, establishing incentive systems, and adopting service‑oriented architecture—to improve collaboration, with a practical data‑integration tool recommendation for smoother data alignment.
The article explains how abandoning go-kit and rebuilding the EasyMS project around configuration governance reshaped the project structure, startup flow, and service evolution, delivering an engineering‑grade configuration system with versioning, atomic snapshots, deep merging, and safe hot‑updates for long‑term microservice maintenance.
This article introduces MuditaOS, an open‑source embedded operating system for the minimalist Mudita Pure phone, detailing its FreeRTOS‑based service architecture, type‑safe message passing, lifecycle management, and the technical stack that enables a low‑power, E‑Ink‑optimized mobile experience.
Microservices and SOA differ in architecture design, communication methods, service granularity, governance, and deployment, with microservices favoring decentralized, fine‑grained, container‑based approaches while SOA relies on larger, centrally orchestrated services via an ESB, making each suited to distinct enterprise scenarios.
This article explains the design, features, and deployment architecture of a unified Layer‑7 load‑balancing service that supports both classic and VPC networks, offering intelligent routing, session persistence, health checks, hot‑config reload, and high availability for cloud‑native environments.
This article explores the concept of privacy (virtual) phone numbers, their features and deployment modes, and details a multi‑stage engineering evolution—from a simple door‑to‑door recycling prototype to a service‑oriented architecture and a high‑availability disaster‑recovery system—demonstrating how they protect user data, improve system reliability, and support rapid business growth.
Microservices and Service‑Oriented Architecture (SOA) both aim to modularize systems, but they differ in design philosophy, technology heterogeneity, governance, and deployment, with microservices favoring fine‑grained, independent services, decentralized governance, and container‑based continuous delivery, while SOA relies on larger, centrally managed services via an ESB.
This article explains the fundamentals of Remote Procedure Call (RPC), its role in distributed systems, the architecture and workflow of RPC frameworks, and compares popular implementations such as Thrift, Dubbo, and Spring Cloud with other communication styles like REST, SOAP, and SOA.
This article presents comprehensive guidelines for designing robust, secure, and maintainable enterprise services, covering API path conventions, request handling, input/output parameter design, business logic recommendations, exception handling, dependency management, monitoring, degradation strategies, encryption, and system admission practices.
This article outlines comprehensive best‑practice guidelines for designing robust, secure, and maintainable backend services—covering API path conventions, request handling, parameter design, error codes, dependency management, monitoring, degradation strategies, legacy service handling, encryption, access control, and tamper‑proof mechanisms, with practical code examples.
This article explains how to design microservice architectures by applying domain‑driven design concepts such as bounded contexts and aggregates, using context mapping and event‑storming techniques to define clear service boundaries, handle communication, and balance consistency with availability.
This article presents comprehensive guidelines for designing flexible, secure, and maintainable API services, covering standardized paths, request handling, parameter design, business logic, exception management, dependency classification, monitoring, degradation strategies, handling legacy services, and encryption measures to ensure robust service architecture.
This article explores essential service design considerations beyond standard guidelines, covering API path structuring, request handling, parameter design, security measures, monitoring, degradation strategies, and code examples to help build flexible, secure, and maintainable backend services.
The article recounts how a fast‑growing event‑processing platform initially embraced microservices, then faced queue bottlenecks, test‑suite overload, and operational complexity, leading the team to consolidate over 140 services into a single, shared‑queue architecture, and shares the practical insights and trade‑offs learned from this transition.
This article explains the fundamentals of Remote Procedure Call (RPC), its core components and workflow, compares it with other communication methods, lists popular RPC frameworks, and distinguishes RPC from SOA, SOAP, and REST, providing a comprehensive overview for backend developers.
This article explains the fundamentals of Remote Procedure Call (RPC) frameworks, their underlying architecture, communication steps, role of providers, consumers, and registries, and compares popular RPC solutions with other service paradigms such as SOA, SOAP, and REST.
The article analyzes high coupling problems caused by multiple controller calls and third‑party integrations in a Java settlement backend, and proposes a dedicated TPS microservice with unified Feign interfaces, enum‑based routing, and factory patterns to decouple frontend and backend logic while providing implementation examples and diagrams.
This article explains why remote procedure call (RPC) is essential for modern distributed services, describes the evolution from monolithic to service‑oriented architectures, and details the core components, communication steps, serialization, service discovery, and full call flow of an RPC framework.
The article describes how redesigning a TV streaming service from a single to a dual‑service architecture, leveraging Android Binder, optimized protocol startup, adaptive networking, and session‑based monitoring dramatically boosted stability above 99%, protocol success over 98.5%, and issue‑resolution efficiency via systematic batch analysis and A/B testing.
The team upgraded Taobao’s feed mixing by deploying an independent xhuffle service built on the xrec framework, which unifies ad and natural recommendation objectives, decouples strategy from business logic, and uses a serial integration to keep average latency under 30 ms while improving both natural and ad metrics, with plans to extend mixing to short video, live streams, and broader scenarios.
To cope with soaring traffic on Bilibili’s effect‑advertising engine, the team systematically measured latency, eliminated redundant Redis calls, switched JSON to Protobuf, applied branch‑prediction hints, loop‑unrolling and AVX256 SIMD, introduced object‑pooling and an inverted‑index request format, cutting CPU usage by 21 % and boosting peak throughput 13 %.
This article explains the OSI seven‑layer network model, compares RPC and HTTP services, describes RPC architecture, synchronous and asynchronous calls, and reviews popular RPC frameworks such as gRPC, Thrift, and Dubbo, helping developers choose the right approach for enterprise back‑end systems.
This article examines the challenges of a complex supply‑chain system built on Spring Cloud, proposes introducing an API layer to handle aggregation, distributed calls and decoration, and further adopts a Backend‑for‑Frontend (BFF) approach to reduce service coupling, improve client‑specific optimization, and streamline team responsibilities.
This article explains the fundamental differences between RPC and HTTP interfaces, their underlying protocols, component architectures, popular frameworks, performance characteristics, and provides guidance on when to use each approach in backend service development.
This article explains the fundamental differences between RPC and HTTP interfaces, describes their underlying client‑server architectures, compares performance, transport protocols, load balancing and service governance, and provides guidance on when to choose each approach in modern backend development.
This article compares RPC and HTTP interfaces, detailing their architectures, popular frameworks, performance characteristics, load‑balancing, and service‑governance features, and provides practical guidance on selecting the right approach for internal high‑performance services or external cross‑platform APIs.
This article analyzes data‑dependency issues in a micro‑service based supply‑chain system, compares an initial data‑redundancy approach with a message‑driven solution, and finally proposes a decoupled real‑time synchronization architecture using the Bifrost middleware to improve query performance and maintain consistency.
This article explains the fundamental differences between RPC and HTTP services, covering OSI model layers, RPC architecture components, synchronous vs asynchronous calls, popular RPC frameworks such as gRPC, Thrift, and Dubbo, and when to choose each approach for enterprise applications.
This article explains why Medium transitioned from a monolithic Node.js application to a microservice architecture, outlines the core design principles, shares practical strategies for building, deploying, and observing services, and warns about common pitfalls such as the microservice syndrome.
The Baidu Tieba rule engine is a low‑code platform that lets non‑developers define, compile, and execute dynamic business rules through modular components, variable handling, JSON‑based rule trees, and customizable disposition handlers, supporting synchronous, asynchronous and parallel execution to reduce hard‑coded logic, deployment frequency, and maintenance effort.
This article outlines the design and implementation of a unified data service platform that standardizes data access, accelerates model processing, provides flexible API construction, and ensures high availability through gateway, caching, and monitoring, ultimately reducing cost and improving efficiency for both C‑end and B‑end applications.
HiMock is a comprehensive mock platform designed to overcome traditional mock limitations by offering low‑code, code‑decoupled, high‑performance, and full‑scenario support across multiple protocols and front‑end/back‑end channels, enabling efficient testing, performance benchmarking, and parallel development for complex services such as bike, e‑bike, and ride‑hailing.
When service load spikes, instead of merely adding machines, this article explains how the AKF Scale Cube model—covering X‑axis horizontal scaling, Y‑axis functional or business splitting, and Z‑axis data partitioning—offers elegant, fine‑grained strategies to boost microservice performance and reliability.
This article explores how microservice architecture, guided by Domain‑Driven Design principles such as bounded contexts, aggregates, and context mapping, defines service boundaries, improves autonomy, and influences communication patterns, including event‑driven integration, synchronous APIs, and BFF strategies, while addressing consistency, scalability, and deployment challenges.
The article reviews the historical progression of front‑end build techniques from simple script loading and file concatenation to dependency‑based bundlers like webpack and vite, and proposes a future service‑oriented build model to overcome scalability limits.
The article presents a comprehensive overview of JD Daojia's Open Platform, detailing its service lifecycle—from platform introduction, service design, publishing, and authorization to state management and traffic‑control mechanisms—while explaining the underlying RPC‑based architecture and fixed‑window rate‑limiting algorithm.
Bilibili’s full‑chain load‑testing architecture embeds a unique scenario identifier in every request, propagates it through RPC, databases, caches and async queues, isolates production data via shadow resources, and provides a transparent SDK, link analyzer and mock server, enabling comprehensive testing that uncovered dozens of issues and boosted live‑streaming TPS by 140 % without major code changes.
The article describes how Ctrip built a unified data service platform that standardizes API development, leverages multiple storage engines, introduces token‑based security, Sentinel rate‑limiting, caching, and automatic contract generation to dramatically cut development cycles and improve reliability for big‑data workloads.
This article details the architecture, service design, performance optimizations, sorting mechanisms, and stability strategies of Baidu's comment middle‑platform, illustrating how it evolved to support billions of daily requests with high availability, low latency, and scalable distributed services.
This article explains the fundamental differences between RPC (Remote Procedure Call) and HTTP services, covering OSI layers, RPC architecture components, synchronous vs asynchronous calls, and popular frameworks such as gRPC, Thrift, and Dubbo, to help developers choose the right approach.
The article explains microservices architecture, detailing its defining characteristics, the role of domain‑driven design and bounded contexts, how aggregates and context mapping help define service boundaries, and discusses communication patterns, eventual consistency, event‑storming, and the backend‑for‑frontend approach for building resilient, loosely‑coupled systems.
Meituan Waimai’s advertising engine team built a platformized solution that standardizes business capabilities, data handling, and development workflow through reusable Action/Stage units, a unified context container, and a robust scheduling engine, achieving 28% faster development, over 65% Action reuse, and improved quality and stability.
This article explains how to break monolithic applications into domain‑driven microservices by defining clear bounded contexts, using aggregates, applying context‑mapping and event‑storming techniques, and choosing appropriate communication patterns such as asynchronous events, CAP trade‑offs, and BFF for frontend integration.
This article explains how to design microservice architectures by applying domain‑driven design concepts such as bounded contexts and aggregates, using context mapping and event‑storming techniques to identify service boundaries, and discusses communication patterns, CAP trade‑offs, and the Backend‑for‑Frontend approach.
This article explains why Redis needs high availability, defines failure scenarios, compares common HA solutions, and walks through four deployment patterns—from a single instance to a three‑Sentinel architecture—highlighting their trade‑offs and practical implementation details.
The article explains common timeout points in synchronous, asynchronous, and message‑queue communication between services, and provides client‑side and server‑side strategies—including request tracing, retry policies, idempotency, fast‑fail handling, and max‑effort notifications—to mitigate these problems in backend systems.
The iQIYI Basic Data Platform unifies internal data exchange standards, integrates massive multi‑business data, and implements high‑availability solutions for ID services, messaging, HBase storage, and read‑write scaling, showcasing practical engineering approaches to big‑data reliability and performance.
This article explains the fundamentals of Remote Procedure Call (RPC), its historical evolution, core concepts such as remote procedures and calls, practical examples, analogies, and the challenges it introduces—like latency, address‑space isolation, partial failures, and concurrency—while highlighting RPC’s pivotal role in enabling scalable distributed architectures.
This article explains how to design microservice architectures by applying Domain‑Driven Design principles, defining bounded contexts and aggregates, using context mapping and event‑storming to identify service boundaries, and addressing communication, consistency, and orchestration challenges in distributed systems.
This article explains how to break a monolithic system into well‑defined microservices by applying domain‑driven design concepts such as bounded contexts and aggregates, using context mapping and event‑storming techniques, and addressing communication, consistency, and orchestration challenges in distributed cloud‑native architectures.
This article explains how to design microservice architectures by applying domain‑driven design concepts such as bounded contexts and aggregates, using context mapping, event storming, and BFF patterns to define clear service boundaries, achieve loose coupling, high cohesion, and handle distributed system challenges.
This article provides a comprehensive technical overview of large‑scale distributed website architecture, covering its characteristics, design goals, architectural patterns, performance, high availability, scalability, extensibility, security, agility, and a detailed example evolution from a single‑server setup to a multi‑layer, service‑oriented system.
This article compares RPC and HTTP services by explaining their protocol foundations, the OSI network layers, RPC architecture components, synchronous versus asynchronous calls, and popular frameworks such as gRPC, Thrift, and Dubbo, while also outlining when each approach is appropriate for enterprise development.
In this article, a programmer recounts the recent Bilibili outage, analyzes its timeline, proposes technical root‑cause hypotheses such as CDN failure and service‑chain avalanche, shares insights from the platform’s high‑availability architecture, and outlines preventive techniques for building more resilient backend systems.
The article introduces Kuaishou's Havok data‑service platform—a one‑stop, configuration‑driven solution that lowers development barriers—and details the comprehensive high‑availability architecture, including hierarchical isolation, elastic scaling, link grading, disaster recovery, and rate‑limiting mechanisms that enable zero‑failure support for large‑scale events.
The article examines how large‑scale systems at Google, eBay, Twitter and Amazon have converged on multi‑language microservice architectures, describing their evolution, service ecosystems, incentive mechanisms, standards, operational challenges, and best practices for building, maintaining and deprecating services.
This article introduces Kuaishou's data platform serviceification, outlining the background challenges for data engineers, the platform's architecture and key technologies such as configuration‑driven development, multi‑mode APIs, data acceleration, and high‑availability mechanisms, and concludes with a summary of achievements and future directions.
This article analyzes the typical evolution from monolithic to RPC-based services, explains why sharding and database partitioning cannot alone achieve unlimited scaling due to connection limits, and introduces a unitization approach that assigns each application to a specific database shard to overcome those constraints.
This article introduces Kuaishou's data service platform, outlining the background challenges of data development, the platform's architecture and service models, key technologies such as configuration‑driven development, multi‑mode APIs, data acceleration, high‑availability mechanisms, and discusses its current performance and future development directions.
The article explores how abstract thinking influences product managers' ability to create clear product architecture diagrams, explains why and when to draw them, outlines three main diagram types, and provides step‑by‑step guidance for designing effective architecture visualizations.
The article explains a three‑component backend architecture—microservices, message queues, and scheduled tasks—detailing their design principles, service layering, job handling, and practical deployment considerations to build extensible, reliable internet projects.
This article explains the concept of gray (canary) release, outlines a simple system architecture with essential components, details common traffic‑splitting strategies, and demonstrates both basic and complex implementation scenarios using Nginx, gateway services, and database migration techniques.
This article explains the concept of gray (canary) release, outlines a basic architecture with essential components, describes common gray release strategies such as header, cookie, and parameter based routing, and provides practical guidance for implementing gray releases using Nginx, gateway services, and handling complex scenarios like multi‑service and database migrations.
This article explains Uber's Domain‑Oriented Microservice Architecture (DOMA), describing why microservices were adopted, the challenges of scaling them, the concepts of domains, layers, gateways and extensions, and provides practical advice for organizations looking to reduce complexity while retaining flexibility.
Uber’s Domain‑Oriented Microservice Architecture (DOMA) tackles the growing complexity of large‑scale microservice systems by organizing services into domains, layers, and gateways, offering improved reliability, clearer ownership, and faster development, while providing practical guidance for teams adopting similar architectures.
This article explains the concept of gray release, outlines a simple architecture with essential components, describes common routing strategies, and shows how to implement gray releases using Nginx, gateway services, and complex multi‑service scenarios to ensure controlled, low‑risk deployments.
This article explains how Kuaishou’s data‑service platform tackles high development barriers and repetitive work by introducing a self‑service, configuration‑driven architecture, multi‑mode APIs, efficient data acceleration, and robust high‑availability mechanisms, while outlining its evolution and future roadmap.
This article outlines Kuaishou's evolution of a unified big‑data service platform, detailing the pain points of data development, the platform's architecture, key technologies such as configuration‑as‑development, multi‑mode APIs, data acceleration, high‑availability mechanisms, and future directions for data‑service modernization.
This article explains Kuaishou's data service platform, detailing the background challenges of high development barriers and duplicated work, the platform's architecture and key technologies such as configuration‑driven development, multi‑mode APIs, data acceleration, and high‑availability mechanisms, and concludes with future directions.
This article explains the concept of gray release, outlines a simple architecture with essential components, describes common strategies such as header, cookie, and parameter based routing, and provides detailed implementation guidance for Nginx, gateway, and complex multi‑service scenarios.
The article examines two ways to define Feign interfaces in a microservice architecture—having the service producer define the Feign client (SPI) versus letting the service consumer define it (API)—and compares their constraints, flexibility, dependency management, and impact on development workflow.
This article recounts a startup's journey from a tiny serverless stack to a 1‑million‑user architecture, analyzing systemic failures, cost issues, and architectural decay, then proposes service‑size classifications, dependency patterns, and a Minimal Business Unit refactoring approach to achieve scalable, low‑overhead growth.
This article explains why RPC is essential for distributed services, defines its core concepts and architecture, compares it with REST, SOAP and SOA, outlines the components and call flow, and reviews key technologies and popular Java‑based RPC frameworks such as Dubbo, Thrift and Avro.
This article presents a comprehensive SOA service‑architecture planning methodology—from end‑to‑end business process analysis and data‑architecture design to technical platform assessment, integration mapping, service‑catalog creation, and practical case study—showing how to identify, refine, and organize reusable services in a micro‑services and mid‑platform environment.
This article presents a structured approach to mastering microservices, covering a learning pyramid, a step‑by‑step roadmap, weekly ARTS habits, and detailed explanations of the six essential components that together form a robust microservice architecture.
This article details the end‑to‑end design, iterative evolution, and technical architecture of an intelligent lending API platform, covering workflow abstraction, service decomposition, security mechanisms, monitoring, and performance optimizations that enable scalable, reliable integration with multiple financial institutions.
Tencent Cloud’s senior engineer Li Kaibin outlines the cloud‑based face‑effects platform, detailing its AI‑driven features such as face fusion, beauty, virtual makeup, segmentation and age‑gender transformation, the CNN‑based model training pipeline, a layered service architecture with elastic scaling and robust monitoring, and future expansions into video effects, international regions and low‑code integration.
The article examines how Google, eBay, Twitter and Amazon evolved their massive systems into multi‑language microservice ecosystems, highlighting the organic growth of services, incentive‑driven design, standards emergence, service ownership, operational practices, and anti‑patterns for building and scaling cloud‑native architectures.
This article analyzes the interference and latency problems caused by traditional service‑level Mock tools in a microservice environment and proposes a four‑component solution—servlet agent, local Mock proxy, Mock server, and configuration client—to isolate Mock functionality, eliminate cross‑application impact, and improve test stability.
Segment’s engineering team recounts their evolution from a simple monolith to a sprawling micro‑service ecosystem and back again, detailing queue bottlenecks, repo fragmentation, shared‑library chaos, and how consolidating everything into a single codebase restored performance, scalability, and developer productivity.
Modular Android projects isolate business logic into independent modules, improving structure, collaboration, and maintenance, while inter‑module communication can use direct dependencies, EventBus/broadcasts, routing frameworks like ARouter, or interface‑based services, with the latter offering low coupling, high readability, and flexible, performant interactions.
The article explains how traditional monolithic, RPC, and sharding architectures eventually hit MySQL connection limits, why simple database partitioning cannot guarantee unlimited scaling, and proposes a unitization approach that restricts each service to a single database shard to overcome connection‑count bottlenecks.
An in‑depth look at cloud computing explains its PC‑like architecture, the IaaS/PaaS/SaaS stack, operational hurdles, market segmentation, and practical insights from industry examples such as Alibaba’s e‑commerce cloud, PaaS offerings, SDN, and private‑cloud considerations.
This article details Gaode's practical experience in building a unit‑based service architecture, covering challenges like request routing, unit isolation, and data synchronization, and explains the design choices, deployment strategies, performance metrics, and future optimization plans.
Implementing an API gateway in a microservice architecture addresses key challenges such as external‑internal isolation, backend security, operational cost reduction, streamlined change processes, and client‑service decoupling, while enabling features like service circuit breaking, gray releases, and online testing to simplify development and improve reliability.
The article outlines Alibaba's progression from a monolithic All‑In‑One architecture through vertical application splitting, distributed services, and finally microservice adoption with Pandora container isolation, detailing technical stacks, challenges, operational practices, and future directions.
The article explains why traditional sharding and database partitioning cannot guarantee limitless scalability, examines the connection‑limit problems of RPC‑based services, and introduces unitization as a practical approach to achieve true unlimited scaling while managing database connections efficiently.
The article provides a comprehensive overview of Tencent Cloud’s OCR platform, detailing its service architecture, product capabilities, integration methods, performance metrics, engineering improvements, testing automation, and operational considerations, offering developers practical insights into building and deploying OCR solutions on the cloud.
The article recounts Segment's journey from a monolithic system to a sprawling micro‑service architecture, the operational pain points that emerged, and how consolidating over 140 services into a single codebase improved testing speed, deployment simplicity, and overall developer productivity while revealing new trade‑offs.
This article explains why Medium transitioned from a monolithic Node.js application to a microservice architecture, outlines the three core design principles, shares practical strategies for service creation, decoupling, observability, deployment, and how to avoid common microservice pitfalls.
In this detailed talk, Didi senior engineer Du Huan explains the challenges of building large microservice frameworks, outlines design principles such as the Rule of Least Power, describes the evolution of service frameworks, and shares concrete implementation techniques and business benefits of Didi's Go‑based platform.
The article presents a comprehensive overview of the challenges, evolution, design principles, and concrete implementation techniques behind building a large‑scale microservice framework at Didi, illustrating how systematic abstraction, reliable I/O handling, and strict interface stability can dramatically improve development efficiency and system robustness.
In his Go China talk, senior Didi engineer Du Huan outlined the design and implementation of a large‑scale microservice framework that abstracts I/O, injects tracing via protocol hijacking, optimizes timers, and enforces fail‑fast circuit breaking, delivering faster development, higher stability, seamless upgrades, and a unified operating‑system‑like layer for thousands of services.
58.com tackles the challenge of storing and searching billions of heterogeneous posts by employing a unified post center, a category‑attribute service, and an external search engine, using vertical table splitting, JSON‑based extensible fields, compressed keys, and horizontally sharded indexes to achieve massive scalability and high throughput.
The article explains how to build a flexible, extensible internet project architecture by combining micro‑services, message‑queue communication, and scheduled jobs, detailing service layering, responsibilities, data isolation, reliability concerns, and practical deployment considerations for large‑scale backend systems.
This article presents a comprehensive case study of how JD's Service Market improved the performance of its core "Available Plugin List" service by analyzing self‑optimizations, resolving external resource conflicts, designing a unified caching model, and implementing asynchronous cache construction using binlog and MQ, ultimately achieving a six‑fold traffic surge handling during peak events.
This article explains the fundamentals of Remote Procedure Call (RPC), the motivations behind RPC frameworks like Dubbo, their core components and communication processes, and outlines the technical considerations required to design a high‑performance, reliable RPC system for distributed Java applications.
The iQIYI video backend team outlines their microservice journey, detailing service decomposition strategies, choosing Spring Cloud for its low migration cost and rich ecosystem, and building a shared platform of registries, configuration, gateways, monitoring, and CI/CD to boost efficiency, reliability, and scalability while planning future adoption of service mesh and domain‑driven design.
This article explains the fundamentals of Remote Procedure Call (RPC), covering its definition, architectural components, communication protocols, serialization process, complete call workflow, and the main technologies and frameworks used in modern backend systems.
