Skip to content
Tagged articles

event-driven architecture

82 articles · Page 1 of 1
Tencent Technical Engineering
Tencent Technical Engineering
Nov 15, 2026 · Artificial Intelligence

Super-Agent & Octop Team Mode: Convergent Designs for Parallel AI Agents

This article compares DeepSeek's Super-Agent architecture with Octop's team mode, revealing how both independently adopted a two-layer dispatcher-worker design, event-driven asynchronous execution, context isolation, and local execution with cloud coordination to enable parallel multi-agent task processing while preserving security and continuity.

Context ManagementOctopSuper-Agent
0 likes · 44 min read
Super-Agent & Octop Team Mode: Convergent Designs for Parallel AI Agents
Architect's Guide
Architect's Guide
Nov 11, 2026 · Backend Development

6 Spring Event Best Practices from Production Failures

The author shares six critical Spring Event best practices derived from production incidents, covering graceful shutdown requirements, startup event loss prevention, suitability for eventual consistency over strong consistency, reliability through retry mechanisms, and mandatory idempotency for subscribers.

IdempotencyKafkaSpring Event
0 likes · 11 min read
6 Spring Event Best Practices from Production Failures
Alibaba Cloud Native
Alibaba Cloud Native
Nov 11, 2026 · Artificial Intelligence

DeepSeek SuperAgent Architecture Explained: Design, Code & Our Flock Practice

This article analyzes DeepSeek's SuperAgent architecture, detailing its dual-layer Router/Worker design, event-driven triggers, context management with Inline/Spill and chain-of-recall, full-duplex async execution, and compute-state-environment separation. It compares with Cursor, LangChain, Anthropic, and Cognition approaches, examines the open-source prototype's code-level decisions (model proposes/code decides, outbox pattern, security layers), and shares the author's Flock system implementation for multi-human multi-agent collaboration.

AI agent architectureContext ManagementDeepSeek
0 likes · 56 min read
DeepSeek SuperAgent Architecture Explained: Design, Code & Our Flock Practice
SmartApe AI
SmartApe AI
Nov 11, 2026 · Artificial Intelligence

Qwen Code 1.0 Open Sources Harness: Unified Event-Driven Agent Architecture

Qwen Code 1.0 merges Qoder's Harness capabilities into an open-source release, introducing a unified event mechanism that routes external inputs through adapters into standard events, enabling scalable agent orchestration with hand-brain separation and distributed evolution from in-memory bus to multi-node clusters.

AI AgentHarnessQoder
0 likes · 5 min read
Qwen Code 1.0 Open Sources Harness: Unified Event-Driven Agent Architecture
Machine Heart
Machine Heart
Nov 10, 2026 · Artificial Intelligence

HyperAgent Architecture: 8 Traits for Agents That Do Jobs, Not Just Answer Questions

openJiuwen's HyperAgent architecture defines eight key traits—proactivity, persistence, growth, collaboration, determinism, extensibility, openness, and economy—supported by a layered AgentOS with event-driven runtime, persistent agents, CoRSI recursive improvement, and swarm-based heterogeneous collaboration for real-world deployment.

AI agentsAgentOSHyperAgent
0 likes · 36 min read
HyperAgent Architecture: 8 Traits for Agents That Do Jobs, Not Just Answer Questions
AsiaInfo Technology: New Tech Exploration
AsiaInfo Technology: New Tech Exploration
Nov 9, 2026 · Industry Insights

Billing for Intelligence: How the Value Exchange Hub Will Define the Internet of Agents

Dr. Ouyang Ye argues that billing systems must evolve from static connectivity ledgers into real-time value exchange hubs to support the Internet of Agents, using dynamic intelligence pricing, multi-party revenue sharing via smart contracts, and event-driven architectures with AI-powered pricing engines.

Billing SystemsCSP TransformationDynamic Pricing
0 likes · 13 min read
Billing for Intelligence: How the Value Exchange Hub Will Define the Internet of Agents
TechVision Expert Circle
TechVision Expert Circle
Nov 6, 2026 · R&D Management

Why One Notice Takes 6 Channels: 2026 Fixes for Enterprise Notification Fragmentation

Forrester's 2026 survey reveals 53% of employees check six-plus channels for a single critical notice; this article dissects the technical root causes — siloed architectures, disjointed push mechanisms, and missing unified identity — quantifies productivity losses from context switching and duplicate work, and evaluates three mature 2026 solution architectures: a unified notification hub, AI-driven aggregation assistants, and protocol-level standardization via Matrix, illustrated by a real-world case cutting daily search time from 62 to 11 minutes.

AI assistantInformation ArchitectureMatrix protocol
0 likes · 14 min read
Why One Notice Takes 6 Channels: 2026 Fixes for Enterprise Notification Fragmentation
Cambridge Mofang Notes
Cambridge Mofang Notes
Nov 4, 2026 · Artificial Intelligence

DeepSeek Super Agent Architecture: Continuous, Multi-Task AI Without Session Juggling

DeepSeek's Super Agent architecture uses a dual-layer Router/Worker design, event-driven triggers with two-level filtering, asynchronous multi-channel interaction, compute-state-environment separation, and an external watchdog to enable persistent, proactive multi-task AI agents that maintain context across sessions and reduce human monitoring overhead.

Agent ArchitectureAsynchronous ProcessingCompute-State Separation
0 likes · 22 min read
DeepSeek Super Agent Architecture: Continuous, Multi-Task AI Without Session Juggling
Architecture Pony
Architecture Pony
Nov 3, 2026 · Backend Development

Spring Boot Event-Driven Decoupling: ApplicationEvent Patterns & Pitfalls

This article explores Spring Boot's ApplicationEvent mechanism for decoupling business side effects, detailing synchronous default behavior, transaction-boundary listeners, async patterns with dedicated thread pools, exception handling strategies, event chaining, and practical refactoring of an order service, while contrasting in-process events with message queues.

ApplicationEventDecoupling PatternsMessage Queue Integration
0 likes · 24 min read
Spring Boot Event-Driven Decoupling: ApplicationEvent Patterns & Pitfalls
AI2ML AI to Machine Learning
AI2ML AI to Machine Learning
Nov 3, 2026 · Artificial Intelligence

DeepSeek Super Agent: Event-Driven Router-Worker Architecture with Persistent SQLite Memory

The article traces 10 evolutionary stages of AI agent construction from prompt workflows to first-principles-driven agents, then details DeepSeek's super agent architecture: an event-driven, dual-layer Router-Worker system with persistent SQLite state machine, engineering capabilities for concurrency, fault tolerance, and delivery reliability, and a memory design that stores facts externally via SQL substring matching rather than vector search.

AI agentsAgent EvolutionDeepSeek
0 likes · 11 min read
DeepSeek Super Agent: Event-Driven Router-Worker Architecture with Persistent SQLite Memory
Baobao Algorithm Notes
Baobao Algorithm Notes
Nov 2, 2026 · Artificial Intelligence

LobeHub's 83k-Star Super-Agent: Building What DeepSeek Only Theorizes

LobeHub's open-source multi-agent system implements DeepSeek's Super-agent principles in production, using Manager/Worker division, task-based workflows, event-driven filtering, three-layer compute/state/environment separation, and an acceptance system with data flywheel for model fine-tuning — all while dogfooding the platform to develop itself.

AI agent orchestrationAcceptance TestingDeepSeek
0 likes · 17 min read
LobeHub's 83k-Star Super-Agent: Building What DeepSeek Only Theorizes
Tech Freedom Circle
Tech Freedom Circle
Nov 2, 2026 · Artificial Intelligence

DeepSeek Super-agent: OS-Inspired Agent Architecture with Scheduling, Caching & Watchdog

The article analyzes DeepSeek's Super-agent architecture, showing how it maps operating system concepts—process scheduling, page caching, compute-storage separation, and watchdog mechanisms—to build a dual-layer Router-Worker agent system that enables continuous, efficient, proactive, and persistent autonomous agents, with source code insights from the open-source prototype.

Agent ArchitectureBYOMDeepSeek Super-agent
0 likes · 42 min read
DeepSeek Super-agent: OS-Inspired Agent Architecture with Scheduling, Caching & Watchdog
Architecture and Beyond
Architecture and Beyond
Nov 1, 2026 · Artificial Intelligence

DeepSeek Harness Super-agent Architecture: Engineering Trade-offs in Autonomous Agent Systems

This article analyzes DeepSeek Harness's Super-agent architecture, dissecting its dual-layer Router-Worker design, event-driven routing, context caching, speculative execution, and compute-storage separation, while highlighting trade-offs like cross-layer communication overhead, async complexity, and security risks in BYOM deployments.

Agent ArchitectureContext ManagementDeepSeek Harness
0 likes · 22 min read
DeepSeek Harness Super-agent Architecture: Engineering Trade-offs in Autonomous Agent Systems
PaperAgent
PaperAgent
Oct 31, 2026 · Artificial Intelligence

DeepSeek's Super-Agent: Open-Source Architecture for Continuous, Proactive AI Collaborators

DeepSeek releases dsh-superagent-prototype, a next-gen agent architecture using a dual-layer Router/Worker design, event-driven triggers with two-level filtering and subscription pass-through, context management via inline/spill and chained recall, async ReAct loops, compute-storage separation, and a Watchdog for self-healing; experiments show 12.4 min p50 task completion but 3.8x token overhead versus single-session baselines.

AI agentsAgent ArchitectureContext Management
0 likes · 13 min read
DeepSeek's Super-Agent: Open-Source Architecture for Continuous, Proactive AI Collaborators
James' Growth Diary
James' Growth Diary
Oct 31, 2026 · Artificial Intelligence

Multi-Agent Orchestration: Making Collaboration Attributable with Event Streams

This article explains how to make multi-agent collaboration traceable by treating the coordination process as an explicit event stream, covering team structure as configuration, delegation and handoff events with reasons, speaker change signals, and session rollover, enabling auditability and debugging of agent interactions.

Agent orchestrationcollaboration traceabilityevent-driven architecture
0 likes · 30 min read
Multi-Agent Orchestration: Making Collaboration Attributable with Event Streams
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Oct 22, 2026 · Backend Development

CQRS in Practice: Why It's Not Just Database Read/Write Separation — Domain Model Decoupling Costs & Red Lines

The article explains CQRS as domain model separation rather than database read/write splitting, detailing command/query model boundaries, event-driven synchronization challenges, consistency trade-offs, engineering pitfalls like event reliability and view explosion, when to avoid CQRS, and a reference e-commerce order implementation with consistency-based query routing.

Architecture Patternsconsistency modelscqrs
0 likes · 15 min read
CQRS in Practice: Why It's Not Just Database Read/Write Separation — Domain Model Decoupling Costs & Red Lines
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Oct 18, 2026 · Backend Development

Escaping the Distributed Monolith: Why Microservices Fail Without Domain Decoupling

A real e-commerce stress test reveals a distributed monolith where services are physically separated but logically coupled via shared databases, synchronous write chains, and shared domain models. The article dissects three coupling layers, control-plane risks, and an incremental decoupling strategy with an architectural review checklist.

Bounded Contextarchitectural reviewcoupling analysis
0 likes · 24 min read
Escaping the Distributed Monolith: Why Microservices Fail Without Domain Decoupling
Qborfy AI
Qborfy AI
Oct 14, 2026 · R&D Management

AI-Native SDLC: The Real Bottlenecks Beyond Code Generation

This article introduces AI-Native SDLC, explaining why code generation is no longer the bottleneck in software development and how the bottleneck has shifted to requirements specification, context management, verification, governance, and production feedback loops, outlining a 7-layer architecture, artifact-driven workflow, and a 9-part series roadmap.

AI-Native SDLCAgentic WorkflowR&D Process
0 likes · 14 min read
AI-Native SDLC: The Real Bottlenecks Beyond Code Generation
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 8, 2026 · Backend Development

What Is Apache Kafka? Core Features, Use Cases & Why Engineers Learn It

This article introduces Apache Kafka as a distributed streaming platform, detailing its core advantages—high throughput via sequential writes and zero-copy, horizontal scalability through partitions, durability with 7-day retention and replication—and key use cases including log aggregation, event-driven architectures, real-time analytics, and big data integration with tools like Flink and Spark Streaming.

KafkaKafka Streamsbig-data-integration
0 likes · 5 min read
What Is Apache Kafka? Core Features, Use Cases & Why Engineers Learn It
Su San Talks Tech
Su San Talks Tech
Sep 24, 2026 · Artificial Intelligence

Why Developers Are Choosing AutoGen: The 'Meeting Room' Model for Multi-Agent AI

This article analyzes Microsoft's AutoGen framework, contrasting its conversation-driven 'meeting room' architecture with LangGraph's flowchart approach, detailing v0.4's event-driven Actor model, Java integration options, ideal use cases like contract review, and trade-offs including token costs and maintenance mode status.

AI agentsAutoGenJava integration
0 likes · 17 min read
Why Developers Are Choosing AutoGen: The 'Meeting Room' Model for Multi-Agent AI
BanTech Think Tank
BanTech Think Tank
Sep 21, 2026 · Backend Development

Postal Savings Bank's Configurable Payment Architecture for Long-Tail Livelihood Scenarios

China Postal Savings Bank details its architectural innovation for a highly configurable payment platform serving diverse long-tail public welfare scenarios, covering schema-driven dynamic forms, immersive interaction design, parameterized routing, and a full-lifecycle security compliance system that cut onboarding time from days to hours.

agile developmentconfigurable payment architectureevent-driven architecture
0 likes · 17 min read
Postal Savings Bank's Configurable Payment Architecture for Long-Tail Livelihood Scenarios
LuTiao Programming
LuTiao Programming
Sep 20, 2026 · Backend Development

How to Guarantee Single Order Processing When Payment Callbacks Fire 10 Times

The article explains how to handle duplicate payment callbacks in Spring Boot using database unique constraints, conditional state updates, an outbox pattern for reliable event publishing, and downstream idempotency, ensuring orders are processed exactly once even if the payment platform sends repeated notifications.

IdempotencyOutbox Patterndatabase constraints
0 likes · 17 min read
How to Guarantee Single Order Processing When Payment Callbacks Fire 10 Times
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Aug 24, 2026 · Artificial Intelligence

How Huawei Cloud AI Queue Redefines Multi-Agent Communication with Asynchronous Event‑Driven Architecture

The article analyzes the engineering challenges of large‑scale multi‑agent AI systems—such as connection loss, synchronous blocking, and traffic spikes—and explains how Huawei Cloud AI Queue, built on RocketMQ with Lite Topic, Session Log, and priority topics, provides an event‑driven, elastic, and observable communication backbone for stable, scalable agent collaboration.

AI QueueAgent CommunicationAsynchronous Messaging
0 likes · 16 min read
How Huawei Cloud AI Queue Redefines Multi-Agent Communication with Asynchronous Event‑Driven Architecture
Ray's Galactic Tech
Ray's Galactic Tech
Aug 12, 2026 · Backend Development

Message Queue Showdown: When to Use Kafka, RabbitMQ, or Pulsar

This article dissects common MQ mis‑selections, categorises four message types, explains the five architectural roles of a message broker, compares Kafka, RabbitMQ and Pulsar on capabilities and trade‑offs, and provides a step‑by‑step selection guide with real‑world code snippets and best‑practice patterns.

KafkaMessage QueueOutbox Pattern
0 likes · 26 min read
Message Queue Showdown: When to Use Kafka, RabbitMQ, or Pulsar
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Aug 5, 2026 · Backend Development

Domain Event Reliability & Eventual Consistency: Production-Ready DDD Event-Driven Patterns

This article details a production-ready event-driven architecture for DDD microservices, covering the complete domain event flow, local event table for message loss prevention, three idempotency patterns for duplicate consumption, ordering solutions, five common pitfalls, and a five-layer eventual consistency architecture.

IdempotencyLocal Event TableMessage Queue
0 likes · 12 min read
Domain Event Reliability & Eventual Consistency: Production-Ready DDD Event-Driven Patterns
Yumin Fish Harvest
Yumin Fish Harvest
Jul 10, 2026 · Backend Development

When One Aggregate Isn’t Enough: Using Domain Services and Domain Events

The article explains why cross‑aggregate business logic belongs in domain services, how domain events capture immutable business facts, and demonstrates practical Spring Boot implementations—including in‑process publishing, message‑queue integration, and the Outbox pattern—while highlighting pitfalls and verification techniques.

Domain EventDomain ServiceOutbox Pattern
0 likes · 10 min read
When One Aggregate Isn’t Enough: Using Domain Services and Domain Events
Tinker Programmer
Tinker Programmer
Jul 1, 2026 · Backend Development

How Domain Events Decouple Communication Between Bounded Contexts

The article analyzes the pitfalls of synchronous calls in a payroll microservice, defines domain events and their naming conventions, compares them with message‑queue messages, and presents two concrete implementations—Spring ApplicationEvent for intra‑process decoupling and RocketMQ with a transactional outbox for cross‑process communication—while also clarifying when event sourcing is appropriate.

DDDRocketMQSpring ApplicationEvent
0 likes · 15 min read
How Domain Events Decouple Communication Between Bounded Contexts
webdream
webdream
Jun 24, 2026 · Backend Development

Combine or Split Endorsement and Policy? Microservice for Life‑Insurance

The article analyzes whether endorsement (policy changes) and policy management should reside in a single microservice or be split into two, weighing data consistency, cohesion, operational simplicity, scaling, deployment independence, fault isolation, team size, and compliance, and provides a concrete decision framework and split strategy.

cqrsdomain-driven designevent-driven architecture
0 likes · 11 min read
Combine or Split Endorsement and Policy? Microservice for Life‑Insurance
LuTiao Programming
LuTiao Programming
May 21, 2026 · Backend Development

Stop Fighting Microservice Calls—Why Experts Prefer Event‑Driven Architecture for Decoupling Distributed Systems

The article explains how traditional synchronous microservice calls create tight coupling, cascading failures, scaling bottlenecks, and high latency, and demonstrates that adopting an event‑driven architecture with producers, consumers, and a message broker such as Kafka can fully decouple services, improve scalability, and enable patterns like event sourcing and CQRS.

KafkaMessage Brokercqrs
0 likes · 14 min read
Stop Fighting Microservice Calls—Why Experts Prefer Event‑Driven Architecture for Decoupling Distributed Systems
Code Archaeology
Code Archaeology
May 19, 2026 · Fundamentals

Architecture vs Design: A Spectrum for Smarter Technical Decisions

This article explains that architecture and design form a continuous spectrum distinguished by three dimensions—significance of trade-offs, investment level, and strategic vs tactical scope—helping engineers clarify decision impact and make wiser technical choices.

Martin Fowlerevent-driven architecturemicroservices
0 likes · 6 min read
Architecture vs Design: A Spectrum for Smarter Technical Decisions
Senior Xiao Ying
Senior Xiao Ying
Apr 16, 2026 · Backend Development

Say Goodbye to Data Chaos: Using CloudEvents to Standardize Event Formats in Spring Boot

Spring Boot can adopt the CloudEvents specification to unify event payloads across microservices, eliminating format inconsistencies; the article explains the spec, shows structured and binary HTTP modes, provides Maven dependencies, configuration, and code examples for producers, consumers, and reactive handling with Spring Cloud Function.

CloudEventsHTTPJava
0 likes · 12 min read
Say Goodbye to Data Chaos: Using CloudEvents to Standardize Event Formats in Spring Boot
Cloud Architecture
Cloud Architecture
Mar 29, 2026 · Backend Development

Smart Parking Guidance Using Kafka, Flink, and Spring Boot

This article presents a senior architect’s end‑to‑end design of a smart parking guidance system, detailing how high‑frequency sensor streams are ingested via Spring Boot gateways, processed with Kafka and Flink for stateful de‑duplication, debouncing, and aggregation, and finally served through Redis, PostgreSQL and Spring Boot APIs for real‑time vehicle routing.

FlinkKafkaSmart Parking
0 likes · 35 min read
Smart Parking Guidance Using Kafka, Flink, and Spring Boot
Amap Tech
Amap Tech
Feb 3, 2026 · Artificial Intelligence

Building a Scalable AI Agent Smart Task Framework for Offline & Event‑Driven Use

After LLMs entered the deep‑water stage, developers realized that agents must go beyond passive Q&A to support asynchronous, long‑running, and subscribable tasks; this article details the design, architecture, and engineering challenges of the “Xiao Gao Teacher AI Agent” smart‑task system, from event‑driven logic to fault‑tolerant deployment.

AI AgentLLMScalable Backend
0 likes · 19 min read
Building a Scalable AI Agent Smart Task Framework for Offline & Event‑Driven Use
Code Wrench
Code Wrench
Jan 18, 2026 · Backend Development

How Go Powers a Smart Factory: Config, Tracing, and Event‑Driven Architecture

This article explains how a Go‑based smart factory evolves from a prototype to a production‑grade system by externalizing configuration with Viper, injecting Trace IDs for end‑to‑end observability, and adopting an event‑driven architecture to achieve flexible, maintainable, and scalable industrial automation.

Configuration ManagementDistributed TracingGo
0 likes · 13 min read
How Go Powers a Smart Factory: Config, Tracing, and Event‑Driven Architecture
FunTester
FunTester
Nov 10, 2025 · Frontend Development

Why Custom Events Are the Secret to Cleaner Front‑End Code

Custom events let developers decouple UI components by broadcasting semantic actions, offering a flexible alternative to direct calls or global state, and improving maintainability, testability, and performance, with best‑practice naming, payload design, bubbling, and cancelable options explained alongside practical JavaScript examples.

Decouplingcustom eventsevent-driven architecture
0 likes · 10 min read
Why Custom Events Are the Secret to Cleaner Front‑End Code
Selected Java Interview Questions
Selected Java Interview Questions
Nov 2, 2025 · Backend Development

Spring Event-Driven Architecture: Coffee Shop Analogy to High‑Throughput Systems

Using a coffee‑shop metaphor, this article explains how Spring’s event‑driven model—event definitions, publishing, and listeners—enables scalable, decoupled backend systems, compares listeners with MQ, shares performance benchmarks, and provides best‑practice guidelines for reliable, high‑throughput applications.

Springbackend developmentevent-driven architecture
0 likes · 9 min read
Spring Event-Driven Architecture: Coffee Shop Analogy to High‑Throughput Systems
AI Large Model Application Practice
AI Large Model Application Practice
Sep 4, 2025 · Artificial Intelligence

Can Message Queues Power the Next Generation of AI Agents? A Deep Dive into Pulsar

This article examines how traditional high‑performance message queues and event‑driven architectures can be revitalized for AI agents, tracing the evolution of messaging middleware, highlighting key integration points, and showcasing Apache Pulsar's cloud‑native features that enable reliable, scalable, and intelligent multi‑agent systems.

AI AgentApache PulsarMessage Queue
0 likes · 16 min read
Can Message Queues Power the Next Generation of AI Agents? A Deep Dive into Pulsar
Big Data Technology Tribe
Big Data Technology Tribe
Jun 22, 2025 · Cloud Native

How to Ensure Consistent State in Event‑Driven Microservices: 3 Proven Patterns

This article explains the challenges of maintaining data consistency in distributed, event‑driven microservice architectures and introduces three practical patterns—Outbox, Original Event Handling, and Self‑Read—to guarantee reliable state synchronization across services, even when failures occur.

CDCOutbox Patterndistributed transactions
0 likes · 6 min read
How to Ensure Consistent State in Event‑Driven Microservices: 3 Proven Patterns
Selected Java Interview Questions
Selected Java Interview Questions
Nov 28, 2024 · Backend Development

Key Considerations and Best Practices for Using Spring Event in Backend Systems

This article explains critical pitfalls and best‑practice guidelines for employing Spring Event in Java backend applications, covering graceful shutdown requirements, event loss during startup, suitable business scenarios, reliability enhancements, retry mechanisms, idempotency, and the relationship between Spring Event and message queues.

BackendJavaRetry
0 likes · 12 min read
Key Considerations and Best Practices for Using Spring Event in Backend Systems
Programmer1970
Programmer1970
Oct 28, 2024 · Databases

Why Is Redis So Fast? Inside Its Memory Storage, Data Structures, I/O Multiplexing, and Network Protocols

Redis achieves millisecond‑level latency by storing all data in memory, using specially optimized data structures such as SDS, incremental‑rehash hash tables, and ziplists, employing a single‑threaded event‑driven model with epoll‑based I/O multiplexing, and streamlining network communication through the compact RESP protocol, compression, and batching, while also offering flexible eviction and persistence strategies.

Cache EvictionI/O multiplexingdata structures
0 likes · 11 min read
Why Is Redis So Fast? Inside Its Memory Storage, Data Structures, I/O Multiplexing, and Network Protocols
JavaEdge
JavaEdge
Aug 24, 2024 · Backend Development

When to Use Simple vs Detailed Events in Event‑Driven Architecture

This article examines the trade‑offs between simple and detailed events in event‑driven architectures, illustrating their impact on scalability, coupling, and system design through concrete examples, design guidelines, and considerations from domain‑driven design to practical implementation.

backend designdetailed eventsevent-driven architecture
0 likes · 12 min read
When to Use Simple vs Detailed Events in Event‑Driven Architecture
Java Architect Essentials
Java Architect Essentials
Jun 26, 2024 · Databases

Why Organizations Should Consider Using Apache Kafka Instead of Relational Databases

This article explains why organizations may replace traditional relational databases with Apache Kafka as a system of record, highlighting Kafka's economic, scalable, immutable log capabilities, event replay, flexibility for diverse use cases, and its suitability for highly regulated, data‑intensive environments.

Data StreamingImmutable LogKafka
0 likes · 10 min read
Why Organizations Should Consider Using Apache Kafka Instead of Relational Databases
21CTO
21CTO
May 6, 2024 · Backend Development

How McDonald’s Scales 20,000 Orders per Second with Hexagonal and Event‑Driven Architecture

This article narrates how McDonald’s food‑delivery platform uses a hexagonal, event‑driven, micro‑service architecture with serverless functions, message brokers, and schema registries to achieve massive scalability, low latency, and reliable order processing for millions of daily users.

backend developmentevent-driven architecturehexagonal-architecture
0 likes · 8 min read
How McDonald’s Scales 20,000 Orders per Second with Hexagonal and Event‑Driven Architecture
Alibaba Cloud Native
Alibaba Cloud Native
Apr 11, 2024 · Cloud Native

How RocketMQ 5.0 EventBridge Powers Cloud‑Native Event‑Driven Architecture

This article explores the evolution of message middleware, defines event‑driven architecture, explains why it resurfaces in the cloud era, and details RocketMQ 5.0 EventBridge’s design—its CloudEvents‑based abstraction, schema support, rule engine, observability, and real‑world use cases—offering practical guidance for building scalable, decoupled systems.

CloudEventsEventBridgeIoT
0 likes · 15 min read
How RocketMQ 5.0 EventBridge Powers Cloud‑Native Event‑Driven Architecture
MaGe Linux Operations
MaGe Linux Operations
Oct 29, 2023 · Backend Development

Microservices vs Event-Driven Architecture: Key Differences Explained

Explore the essential distinctions between microservices and event‑driven architecture, covering service granularity, data handling, bounded contexts, and practical use‑case scenarios, to help architects and developers choose the right approach for scalable, responsive software systems.

event-driven architecturemicroservicessoftware design
0 likes · 8 min read
Microservices vs Event-Driven Architecture: Key Differences Explained
MaGe Linux Operations
MaGe Linux Operations
May 6, 2023 · Backend Development

Why Evolving Architecture Beats Rigid Design: Lessons from Amazon and Prime Video

The article explains that building evolvable software systems—using strategies like microservices and event‑driven architecture—allows teams to adapt to changing workloads and business growth, illustrated with real‑world examples from Amazon, Prime Video, and S3, while emphasizing that no single architectural pattern fits all scenarios.

cloud computingevent-driven architectureevolvable systems
0 likes · 6 min read
Why Evolving Architecture Beats Rigid Design: Lessons from Amazon and Prime Video
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Mar 24, 2023 · Cloud Native

Serverless Adoption at NetEase Cloud Music: Architecture, Migration, and Benefits

NetEase Cloud Music transitioned from public FaaS to a private Knative‑based serverless platform, delivering elastic audio‑video processing, multi‑language support, event‑driven scaling across hybrid private and public clouds, boosting resource utilization and cutting costs, though cold‑starts and container expertise remain challenges.

KnativeResource Optimizationcloud native
0 likes · 16 min read
Serverless Adoption at NetEase Cloud Music: Architecture, Migration, and Benefits
phodal
phodal
Oct 24, 2022 · Industry Insights

Unlocking Ultra-Fast Systems: Key Patterns Behind Low‑Latency Architecture

This article provides a comprehensive overview of low‑latency architecture, covering network hardware, system‑level programming strategies, language choices, memory management techniques, event‑driven designs, high‑performance data structures, and visualization approaches for building ultra‑fast computing systems.

High-Performance ComputingJava performanceevent-driven architecture
0 likes · 10 min read
Unlocking Ultra-Fast Systems: Key Patterns Behind Low‑Latency Architecture
IT Architects Alliance
IT Architects Alliance
Oct 9, 2022 · Backend Development

Event‑Driven Messaging Patterns at Wix: Consumption, Projection, End‑to‑End Streaming, In‑Memory KV Stores, Scheduling, Transactions, and Aggregation

The article describes how Wix engineers built a robust, Kafka‑based event‑driven messaging infrastructure for over 1,400 microservices, detailing patterns such as consumption and projection, end‑to‑end streaming with websockets, in‑memory KV stores, schedule‑and‑forget jobs, exactly‑once transactions, and event aggregation to achieve scalability, resilience, and low‑latency data access.

Data StreamingKafkadistributed systems
0 likes · 16 min read
Event‑Driven Messaging Patterns at Wix: Consumption, Projection, End‑to‑End Streaming, In‑Memory KV Stores, Scheduling, Transactions, and Aggregation
vivo Internet Technology
vivo Internet Technology
Oct 9, 2022 · Big Data

Design and Implementation of a Real-Time Marketing Automation Engine at vivo

This fifth installment explains vivo’s real‑time marketing automation engine, detailing its business need, layered architecture (access, processing, output, management, warehouse), scalable event‑queue design, dynamic configuration, unified dispatch, Flink‑based metric enrichment, and rule‑engine integration to achieve low‑latency, high‑throughput personalized targeting.

FlinkMessage Queueevent-driven architecture
0 likes · 13 min read
Design and Implementation of a Real-Time Marketing Automation Engine at vivo
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 29, 2022 · Backend Development

Scaling Event‑Driven Messaging at Wix with Kafka: Key Patterns

This article explains how Wix uses Kafka‑based event‑driven messaging to decouple microservices, improve scalability, and achieve exactly‑once processing through patterns such as consume‑and‑project, end‑to‑end event streams, in‑memory KV stores, scheduled jobs, transactional events, and event aggregation.

Data StreamingKafkadistributed systems
0 likes · 16 min read
Scaling Event‑Driven Messaging at Wix with Kafka: Key Patterns
21CTO
21CTO
Aug 23, 2022 · Cloud Native

How RocketMQ Evolved into a Cloud‑Native Super‑Fusion Messaging Platform

This article traces RocketMQ's transformation from a traditional message queue to a cloud‑native, ultra‑fusion platform that integrates messaging, event‑driven architecture, and streaming, highlighting its historical stages, architectural upgrades, multi‑language SDKs, stateless consumption, and future cloud‑native trends.

Message QueueRocketMQcloud native
0 likes · 22 min read
How RocketMQ Evolved into a Cloud‑Native Super‑Fusion Messaging Platform
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Apr 18, 2022 · Cloud Native

How Huawei Cloud EventGrid and Apache EventMesh Use gRPC to Simplify Event‑Driven Integration

This article explains how Huawei Cloud EventGrid, powered by Apache EventMesh and gRPC, provides a serverless, high‑availability event bus that unifies HTTP, TCP, and message‑queue protocols, enabling composable applications to integrate seamlessly across cloud services and SaaS partners.

EventGridEventMeshevent-driven architecture
0 likes · 15 min read
How Huawei Cloud EventGrid and Apache EventMesh Use gRPC to Simplify Event‑Driven Integration
Alibaba Cloud Native
Alibaba Cloud Native
Apr 10, 2022 · Cloud Computing

Automate Alibaba Cloud EventBridge with Terraform: A Step‑by‑Step IaC Guide

This article explains the core concepts of Alibaba Cloud EventBridge for building event‑driven architectures, compares imperative and declarative IaC approaches, and provides detailed Terraform examples—including a DingTalk alert and a custom bus triggering FunctionCompute—complete with code snippets and deployment steps.

Alibaba CloudEventBridgeIaC
0 likes · 14 min read
Automate Alibaba Cloud EventBridge with Terraform: A Step‑by‑Step IaC Guide
High Availability Architecture
High Availability Architecture
Jan 20, 2022 · Backend Development

Event-Driven Architecture: Concepts, Scenarios, Patterns, and Practical Implementation

This article explains the fundamentals of event‑driven architecture, outlines when it should be used, describes common patterns such as event notification, state transfer, event sourcing, and CQRS, and provides a detailed example of applying these concepts in a content‑platform microservice system with code snippets and deployment considerations.

Backendcqrsevent-driven architecture
0 likes · 17 min read
Event-Driven Architecture: Concepts, Scenarios, Patterns, and Practical Implementation
vivo Internet Technology
vivo Internet Technology
Jan 19, 2022 · Backend Development

Event-Driven Architecture: Concepts, Scenarios, and Implementation Practices

Event‑driven architecture (EDA) coordinates micro‑services through immutable events and a reliable broker, enabling decoupling, asynchronous processing, and state‑change tracking via patterns such as event notification, state transfer, event sourcing, and CQRS, while offering scalability and robustness but demanding careful design to avoid complexity and consistency issues.

Message Queuebackend designcqrs
0 likes · 18 min read
Event-Driven Architecture: Concepts, Scenarios, and Implementation Practices
Programmer DD
Programmer DD
Oct 1, 2021 · Backend Development

How Wix Scales 1400+ Microservices with Event‑Driven Kafka Patterns

This article explains how Wix engineers built a robust, event‑driven messaging infrastructure on Kafka that serves over 1,400 microservices, detailing six key patterns—including consumption‑projection, end‑to‑end event flows, in‑memory KV stores, scheduling, transactional events, and aggregation—that improve scalability, resilience, and operational simplicity.

KafkaMessage Streamingbackend design
0 likes · 19 min read
How Wix Scales 1400+ Microservices with Event‑Driven Kafka Patterns
Top Architect
Top Architect
Sep 7, 2021 · Backend Development

Designing Microservices with Domain‑Driven Design, Context Mapping, and Event Storming

This article explains how to design microservice architectures by applying domain‑driven design, defining bounded contexts, using context mapping and event‑storming techniques, and addressing communication, consistency, and integration patterns such as event‑driven messaging and the Backend‑for‑Frontend approach.

Backend For FrontendBounded ContextContext Mapping
0 likes · 19 min read
Designing Microservices with Domain‑Driven Design, Context Mapping, and Event Storming
Tencent Cloud Developer
Tencent Cloud Developer
Jun 22, 2021 · Cloud Computing

Let's Dive Into Serverless World: Tencent Cloud's Serverless Development and Latest Trends

Tencent Cloud’s serverless platform, now serving over a million developers and billions of daily invocations, accelerates business and education workloads, enables massive elastic scaling, integrates video, GPU, and event‑bus services, and simplifies migration, debugging, and SaaS integration, heralding serverless as the next mainstream cloud paradigm.

Function ComputeTencent Cloudcloud computing
0 likes · 17 min read
Let's Dive Into Serverless World: Tencent Cloud's Serverless Development and Latest Trends
Java High-Performance Architecture
Java High-Performance Architecture
May 29, 2021 · Backend Development

Unlocking Nginx Performance: Inside Its Modular, Event‑Driven Architecture

This article explains how Nginx achieves high performance through its modular design, event‑driven architecture, multi‑stage asynchronous request handling, master‑worker process model, and efficient memory‑pool implementation, contrasting it with traditional web servers and illustrating each concept with diagrams.

Backend PerformanceNGINXProcess Model
0 likes · 9 min read
Unlocking Nginx Performance: Inside Its Modular, Event‑Driven Architecture
Selected Java Interview Questions
Selected Java Interview Questions
Jan 24, 2021 · Backend Development

Decoupling Microservices: Asynchronous Messaging, Event‑Driven Architecture, and CQRS Strategies

The article examines how to reduce tight coupling between microservices by applying module‑division principles, converting synchronous calls to asynchronous messaging, leveraging event‑driven architectures and CQRS, employing local caching and data landing, and refactoring overly coupled services for more resilient backend systems.

Asynchronous Messagingbackend designcqrs
0 likes · 21 min read
Decoupling Microservices: Asynchronous Messaging, Event‑Driven Architecture, and CQRS Strategies
Java Architect Essentials
Java Architect Essentials
Sep 1, 2020 · Backend Development

How to Ensure Data Consistency in Microservices: Patterns and Pitfalls

Microservice architectures struggle with traditional ACID transactions, so this article reviews local and distributed transaction basics, explains why 2PC/3PC are unsuitable, introduces the BASE model, and details four practical consistency patterns—reliable event, async event, business compensation, and TCC—highlighting their mechanisms, advantages, and drawbacks.

BASE theoryData ConsistencyTCC
0 likes · 17 min read
How to Ensure Data Consistency in Microservices: Patterns and Pitfalls
ITPUB
ITPUB
Jul 28, 2020 · Databases

Why MySQL Binlog Can Cause Order Fulfillment Delays and How to Fix It

This article explains MySQL Binlog’s role in event‑driven order processing, analyzes hidden pitfalls such as premature Binlog reads and two‑phase commit issues, and offers practical solutions like retry strategies and direct Binlog consumption to ensure data consistency.

Database LogsMySQLTwo-Phase Commit
0 likes · 14 min read
Why MySQL Binlog Can Cause Order Fulfillment Delays and How to Fix It
Architecture Digest
Architecture Digest
Dec 12, 2019 · Backend Development

Nginx Architecture Overview: Modular Design, Event‑Driven Model, Multi‑Stage Asynchronous Processing, and Process Management

This article explains Nginx's high‑performance architecture, covering its modular design, event‑driven processing, multi‑stage asynchronous request handling, master‑worker process model, and memory‑pool mechanism, and compares it with traditional web servers.

NGINXProcess Managementevent-driven architecture
0 likes · 10 min read
Nginx Architecture Overview: Modular Design, Event‑Driven Model, Multi‑Stage Asynchronous Processing, and Process Management
Programmer DD
Programmer DD
Feb 22, 2019 · Backend Development

Why Event‑Driven and Microkernel Architectures Can Transform Your Backend

This article explains how event‑driven and microkernel architectures provide flexible, decoupled designs for complex backend systems, comparing centralized and decentralized patterns, outlining their structures, advantages, drawbacks, and suitable scenarios, and offering practical guidance for implementation.

BackendMicrokernelevent-driven architecture
0 likes · 12 min read
Why Event‑Driven and Microkernel Architectures Can Transform Your Backend
Architecture Talk
Architecture Talk
Sep 30, 2018 · Backend Development

Why Event‑Driven Architecture Beats Command‑Driven Design in Microservices

This article explains how shifting from synchronous command‑driven interactions to asynchronous event‑driven flows reduces coupling, improves scalability, and enables flexible querying in distributed systems, while also discussing hybrid patterns, the single‑writer principle, and practical advantages illustrated with Kafka‑based examples.

EventsKafkaQueries
0 likes · 13 min read
Why Event‑Driven Architecture Beats Command‑Driven Design in Microservices
Efficient Ops
Efficient Ops
Aug 12, 2018 · Backend Development

Inside Nginx: How It Starts, Handles Requests, and Key Callbacks Explained

This article provides a comprehensive walkthrough of Nginx’s startup sequence, master‑worker process communication, critical callback configurations, and the detailed flow of HTTP request handling, supplemented with GDB debugging steps and example module development for deeper insight into its modular architecture.

event-driven architecturegdb debugginghttp request processing
0 likes · 14 min read
Inside Nginx: How It Starts, Handles Requests, and Key Callbacks Explained
21CTO
21CTO
May 25, 2017 · Cloud Computing

Serverless Explained: How It Transforms Cloud Architecture and Boosts Efficiency

This article introduces Serverless computing, explains its core concepts such as BaaS and FaaS, outlines its key characteristics, and showcases real-world use cases ranging from data processing pipelines to web applications, highlighting benefits, challenges, and future trends.

AWS LambdaBaaSFaaS
0 likes · 10 min read
Serverless Explained: How It Transforms Cloud Architecture and Boosts Efficiency
Meituan Technology Team
Meituan Technology Team
Nov 4, 2016 · Backend Development

Understanding NIO: From Blocking I/O to Non-Blocking I/O Models

The article explains how NIO replaces the thread‑intensive blocking I/O model with a non‑blocking, event‑driven architecture that lets a single thread handle many connections, covering BIO vs NIO differences, selector mechanics, Reactor/Proactor patterns, buffer strategies, practical use cases, and framework recommendations.

Buffer ManagementI/O multiplexingJava Networking
0 likes · 19 min read
Understanding NIO: From Blocking I/O to Non-Blocking I/O Models
Architecture Digest
Architecture Digest
Jun 24, 2016 · Fundamentals

Rethinking Web Frameworks: From Ideal Design to Practical Implementation

This article explores how an ideal web framework—featuring a unified data model, reusable code, event‑driven logic, and language‑agnostic architecture—can be realized in practice, discussing frontend and backend realities, graph‑based data modeling, and the benefits for maintainability and extensibility.

Data ModelingWeb Frameworkevent-driven architecture
0 likes · 25 min read
Rethinking Web Frameworks: From Ideal Design to Practical Implementation
21CTO
21CTO
Sep 15, 2015 · Fundamentals

Can a Unified Event‑Driven Architecture Revolutionize Web Frameworks?

This article explores how ideal web frameworks could evolve by separating data description from logic, using event‑driven architectures, graph databases, and cross‑language integration to achieve minimal, maintainable, and extensible code, while contrasting current practices like React, Angular, and Meteor.

BackendData ModelingWeb Framework
0 likes · 26 min read
Can a Unified Event‑Driven Architecture Revolutionize Web Frameworks?
21CTO
21CTO
Sep 14, 2015 · Fundamentals

Can Event‑Driven Architecture Revolutionize Web Frameworks?

The article explores how ideal web frameworks could evolve by separating data description from logic, using event‑driven architectures, graph databases, and cross‑language components to achieve minimal, maintainable, and extensible code, while discussing practical implementations, challenges, and philosophical foundations.

Data ModelingFrontend Developmentevent-driven architecture
0 likes · 25 min read
Can Event‑Driven Architecture Revolutionize Web Frameworks?

Understanding Stream Processing, Event Sourcing, and Complex Event Processing

The article explains the fundamentals of stream processing, event sourcing, and complex event processing, comparing raw event storage with aggregated results, illustrating architectures with Kafka, Samza, and other frameworks, and highlighting benefits such as scalability, flexibility, and decoupling for modern data‑driven systems.

Apache KafkaApache Samzabig data
0 likes · 11 min read
Understanding Stream Processing, Event Sourcing, and Complex Event Processing