This article details production-ready Go distributed transaction patterns including Outbox for reliable event publishing, RocketMQ transaction messages, SAGA orchestration with compensation, TCC resource reservation, payment unknown-state handling, capacity planning, fault validation matrices, and operational recovery loops with concrete PostgreSQL schemas and Go code examples.
This article provides a comprehensive guide to distributed transactions in microservices, covering CAP/BASE theory, four major patterns (2PC, local message table, TCC, SAGA), eight common production faults with root causes and fixes, selection guidelines, a troubleshooting SOP, and high-availability standards.
China Postal Savings Bank integrated with the Leqi platform's shared invoice service, enabling automatic invoice generation upon payment via a three-layer-one-core architecture using microservices, TCC distributed transactions, and domestic technology stack, achieving 99.9% success rate and seconds-level invoicing.
This article explains distributed transaction concepts, CAP theorem trade-offs, and three solutions: two-phase commit (2PC), try-confirm-cancel (TCC), and message queue-based eventual consistency with idempotency requirements.
This article details the engineering implementation and performance optimization of TCC distributed transactions in Go microservices, using an order placement scenario with inventory locking and wallet freezing, covering data models, idempotent state machines, recovery workers, hotspot optimization, and observability.
This comprehensive guide covers distributed transaction theory (CAP/BASE), compares six solutions (2PC, TCC, SAGA, Seata AT, RocketMQ transaction messages, local message tables), provides runnable code for Seata AT, TCC, and RocketMQ patterns, and analyzes critical pitfalls like empty rollback, hanging, and idempotency with solutions.
CAP theoremIdempotencyRocketMQ transaction messages
The article explains why a single order operation can involve multiple services and databases, introduces the challenges of distributed transactions, and compares three common solutions—Two‑Phase Commit, TCC, and Saga—detailing their mechanisms, strengths, weaknesses, and suitable scenarios.
The article explains why ACID guarantees break down in distributed systems, introduces the BASE and CAP trade‑offs, then details six concrete transaction solutions—2PC, 3PC, TCC, Saga, local message tables, and reliable messages—highlighting their processes, drawbacks, and a decision framework for selecting the right approach.
The article compares Seata‑AT, TCC, and Saga distributed‑transaction patterns, explains their two‑phase or three‑phase mechanisms, outlines performance and consistency trade‑offs, and provides concrete guidance on which solution fits backend micro‑service scenarios such as core commerce, third‑party integration, or admin tools.
This article explains the fundamentals of distributed transactions, outlines the CAP theorem trade‑offs, and compares three concrete solutions—two‑phase commit, TCC, and a message‑queue based eventual‑consistency approach—detailing their workflows, advantages, and drawbacks.
The article reviews the most common distributed transaction patterns—TCC, Saga, reliable messaging, 2PC, and Seata's AT mode—explaining their principles, ideal use‑cases, implementation details, and trade‑offs so architects can select the most suitable solution for their microservice systems.
This article explains why distributed transactions are essential in microservice architectures, introduces Alibaba's open‑source Seata solution, compares its AT, TCC and Saga modes, shows step‑by‑step Docker deployment, provides full Spring Cloud code examples, and lists common pitfalls and debugging tips.
Distributed transactions have no universal silver bullet; architects must balance consistency, latency, throughput, complexity, and operational cost, and choose among SAGA, TCC, and Outbox patterns based on concrete trade‑offs, failure handling, and real‑world engineering constraints.
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.
This guide explains the TCC (Try‑Confirm‑Cancel) distributed transaction model for Go microservices, covering its principles, comparison with 2PC and Saga, architecture, implementation steps, code examples, real‑world e‑commerce case, failure scenarios, table design, and production‑grade best practices.
This article explains the TCC (Try‑Confirm‑Cancel) transaction model, its three practical variants, and provides a step‑by‑step guide with code examples for integrating Seata TCC into a Spring‑Boot e‑commerce order service, while addressing common pitfalls such as idempotency, empty rollbacks, and hanging transactions.
Learn how to design a robust, high‑performance seckill architecture that can endure millions of concurrent requests by breaking down business flow, defining precise technical metrics, and implementing a four‑layer system—access, traffic‑shaping, business logic, and data—using CDN, APISIX, Redis, RocketMQ, and MySQL with detailed code examples.
This comprehensive guide explains the core concepts of transactions, local and distributed transaction models, the CAP theorem, various distributed transaction solutions such as 2PC, TCC, reliable messaging, and maximum effort notifications, and compares their trade‑offs for modern microservice architectures.
This guide explains Seata's open‑source distributed transaction solution, compares its AT, TCC, Saga, and XA modes, details core components and workflow, and provides step‑by‑step instructions for quick integration in microservice backends.
This article explains why distributed transactions are difficult in micro‑service architectures, illustrates the problem with an e‑commerce order example, and presents seven practical solutions—including 2PC, 3PC, TCC, reliable messaging, best‑effort notification, Seata AT, and eBay's event‑queue—along with guidance on selecting the right approach for different consistency and performance requirements.
This article explains the fundamentals of distributed transactions, illustrates why they are essential for multi‑service operations such as e‑commerce order processing, and compares four major solutions—two‑phase commit, three‑phase commit, TCC, and message‑queue based eventual consistency—detailing their workflows, advantages, and drawbacks.
This article explains common distributed‑transaction solutions, describes the author’s own compensation‑plus‑local‑message‑table approach for merging customers across databases, outlines the TCC model with its Try‑Confirm‑Cancel phases, and details why TCC was rejected due to complexity, long resource locks, and rollback issues.
This article explains the TCC (Try‑Confirm‑Cancel) distributed transaction pattern, compares it with traditional solutions, details its three‑phase workflow, provides Java code examples for each phase, and discusses exception handling, timeout control, asynchronous processing, suitable scenarios, and common pitfalls for backend microservice development.
Learn how Seata's TCC mode addresses distributed transaction challenges when AT mode cannot handle non-relational resources, by detailing its three-phase workflow, handling of common anomalies like empty rollbacks, idempotency, and hanging, and weighing its benefits against complexity.
The article explains how to achieve transaction consistency in distributed internet systems by balancing CAP trade‑offs and presents common design approaches such as 2PC, 3PC, TCC, reliable message delivery, best‑effort notification, and database‑transaction plus compensation mechanisms.
This article explains the fundamentals of distributed transactions, covering ACID properties, the CAP theorem, two‑phase commit, TCC compensation, and a message‑queue based eventual consistency approach, while highlighting their advantages, drawbacks, and practical application scenarios.
This article explains the fundamentals of ACID transactions, the challenges of multi‑data‑source operations, surveys common distributed‑transaction solutions such as 2PC, 3PC, TCC, transaction‑status tables and message‑queue based eventual consistency, and then details the implementation of Seata’s AT mode in a micro‑service e‑commerce scenario.
This article explains the TCC (Try‑Confirm‑Cancel) distributed transaction model, its three phases, three practical variants, and provides a complete Seata‑based Java implementation with code samples, exception handling strategies, and deployment tips for backend services.
This article introduces five widely used, free C/C++ compilers—GCC, Clang/LLVM, Tiny C Compiler, Microsoft Visual C++, and Digital Mars—detailing their main features, platform support, typical usage commands, and ideal application scenarios for developers seeking lightweight or powerful compilation tools.
This article explores strategies for seamless data migration—including full, incremental, and binlog‑based approaches—and examines distributed transaction models such as XA, BASE, TCC, and AT, outlining their components, workflows, advantages, challenges, and supporting tools like Seata and Canal.
This article analyzes common distributed‑transaction scenarios, explains the CAP theorem’s relevance, compares ACID/BASE, TCC, XA, 2PC/3PC, Saga and AT patterns, and provides a decision‑making framework to help architects select the most suitable approach for their microservice systems.
This article explains the evolution of distributed systems, outlines their benefits and challenges, and details key consistency mechanisms such as the CAP theorem, XA two‑phase and three‑phase commit, MQ‑based transactions, and the TCC pattern, with real‑world application scenarios.
This article explains how to build a TCC‑style distributed transaction layer for Redis using Go, detailing the two‑phase commit workflow, handling of prepare, commit, and rollback phases, the associated consistency challenges, and providing full code examples.
This article introduces eight essential distributed‑transaction techniques—including 2PC, 3PC, TCC, Saga, distributed locks, local message tables, reliable message transactions, and best‑effort notifications—detailing their workflows, advantages, drawbacks, and suitable business scenarios to help engineers choose the right solution.
This article explains the principles of distributed transaction messages, comparing 2PC, TCC, and transactional messaging, and provides detailed walkthroughs of RocketMQ and Kafka implementations, including their two‑phase processes, broker handling, and source‑code insights for ensuring data consistency in asynchronous systems.
This article explains ACID properties of single‑node transactions, the challenges of multi‑data‑source operations, surveys common distributed‑transaction solutions such as 2PC, 3PC, TCC, status‑table and message‑queue approaches, and details the implementation of Seata's AT mode with lock and rollback mechanisms.
This article examines the challenges of maintaining data consistency across micro‑service boundaries, walks through real‑world payment and gifting scenarios, compares classic solutions such as 2PC, saga, TCC, local‑message tables and transaction messages, and finally recommends a pragmatic approach for building reliable distributed transaction mechanisms.
This article explains the fundamentals of database transactions, the ACID properties, and why distributed transactions are needed, then walks through the implementation details of redo/undo logs, local transactions, CAP and BASE theory, and evaluates five major distributed‑transaction solutions—2PC, TCC, local‑message tables, maximum‑effort notification, and Saga—with concrete examples, pros, and cons.
This article explains core distributed‑system concepts such as the CAP theorem, ACID and BASE transaction models, idempotent design, and various distributed transaction mechanisms including two‑phase and three‑phase commit, TCC/Saga compensation, message‑based transactions, and popular frameworks like JDTS and Seata.
This article analyzes the challenges of distributed transactions in a micro‑service order system, compares XA, TCC, and SAGA patterns, and details how the open‑source DTM framework is applied to achieve reliable order creation while handling crashes, rollbacks, idempotency, and network anomalies.
This article explains the design principles of Seata-go's TCC mode, how it handles exceptions, and provides step‑by‑step guidance for implementing and using TCC in Go microservices, along with future roadmap insights.
This article explains the fundamentals of single‑ and multi‑data‑source transactions, surveys common distributed transaction models such as 2PC, 3PC, TCC, status‑table and message‑middleware approaches, and then details the implementation of Seata's AT mode with diagrams, code snippets, and lock handling.
This article demystifies distributed transactions using Alibaba's Seata, explaining reverse compensation, core concepts (TC, TM, RM), the two‑phase commit protocol, and detailed walkthroughs of AT, TCC, XA, and Saga modes with code examples and step‑by‑step procedures.
This article explains the challenges of distributed transactions in micro‑service architectures and presents Seata's various solutions—including two‑phase commit, XA, AT, TCC, Saga and message‑based approaches—while covering fundamental concepts such as ACID, CAP and BASE.
This article explains the basic concepts of transactions, distinguishes local and distributed transactions, introduces the CAP and BASE theories, and compares major distributed‑transaction solutions such as 2PC, XA, Seata, TCC, reliable‑messaging and maximum‑effort notification, highlighting their trade‑offs.
This article provides a comprehensive technical overview of distributed transactions, covering basic concepts, local and distributed transaction models, the CAP and BASE theories, two‑phase commit (2PC), XA and Seata implementations, TCC patterns, reliable‑message consistency with RocketMQ, and maximum‑effort notification approaches, along with a comparative analysis of each solution.
The article examines common microservice transaction consistency techniques—including blocking retries, asynchronous queues, TCC compensation transactions, local message tables, and MQ transactions—explaining their mechanisms, advantages, drawbacks, and practical code examples for ensuring data integrity across distributed services.
The article explains various techniques for ensuring data consistency in distributed microservice architectures, including blocking retries, asynchronous queues, TCC compensation transactions, local message tables, and MQ transactions, while discussing their advantages, drawbacks, and practical implementation details.
This article examines common strategies for handling inter‑service call failures in microservice architectures, comparing blocking retries, asynchronous queues, TCC compensation transactions, local message tables, and MQ‑based transactions, and discusses their advantages, drawbacks, and practical implementation considerations.
This article explains the fundamentals of ACID, compares monolithic and distributed transaction models, and details various distributed transaction strategies—including 2PC, 3PC, TCC, local message tables, MQ transactions, max‑effort notifications, Saga, and Seata—highlighting their mechanisms, trade‑offs, and practical considerations.
This article explains the fundamentals of transactions, the challenges of distributed transactions, introduces ACID, CAP and BASE theories, and compares practical solutions such as two‑phase commit, TCC, Seata, reliable message‑based eventual consistency, and maximum‑effort notification, concluding with a comparative analysis of their trade‑offs.
This article explains the fundamentals of local transactions, highlights their advantages and limitations, introduces the challenges of distributed transactions across services and databases, and reviews common solutions such as 2PC, reliable messaging, TCC, and max‑effort notification.
This article introduces Seata's approach to distributed transactions, covering the concept of reverse compensation, core components (TC, TM, RM), the two‑phase commit protocol, and detailed walkthroughs of Seata's AT, TCC, XA, and Saga modes with practical examples and diagrams.
This article explains the fundamentals of single‑source and multi‑source transactions, reviews common distributed‑transaction patterns such as 2PC, 3PC, TCC, transaction‑status tables and message‑queue based eventual consistency, and then details the implementation and isolation mechanisms of Seata’s AT mode for microservice architectures.
This article explains how to perform full, incremental, and binlog‑based data migrations, compares their trade‑offs, and introduces distributed transaction models such as XA, BASE, TCC, and AT, helping developers choose the right strategy for consistency and performance.
This article explains the fundamentals of distributed consistency, covering consistency levels, ACID and CAP principles, BASE theory, and practical protocols such as 2PC, 3PC, and TCC, while also discussing real‑world patterns like cache consistency and reliable messaging.
This article examines how vertical and horizontal data partitioning leads to migration and consistency challenges, outlines full, full‑plus‑incremental, and binlog‑based migration strategies, and compares strong‑consistency XA transactions with flexible BASE approaches such as TCC and AT, including their components, workflows, advantages, and drawbacks.
This article explains the fundamentals of distributed transactions, including ACID properties, consistency models, sharding strategies, and the two‑phase, three‑phase, and TCC protocols, while discussing CAP and BASE theories and the challenges of implementing reliable distributed databases.
This article analyzes the challenges of distributed transactions in multi‑node systems and compares various solutions—including 2PC, 3PC, TCC, Saga, local message tables, and MQ‑based approaches—detailing their mechanisms, trade‑offs, and practical implementations with concrete examples from order and cart services.
This article explains the end‑to‑end design of a coupon system for e‑commerce, covering promotion types, core workflows, service architecture, database schema, distributed transaction handling, scaling strategies, rate limiting, and consistency mechanisms such as TCC.
This article explains the fundamentals of distributed transactions, covering ACID, CAP and BASE theories, and reviews various consistency solutions such as two‑phase commit, three‑phase commit, TCC, local message tables, MQ approaches and the Seata framework, highlighting their advantages and drawbacks.
The article explains how micro‑service architectures create data‑consistency challenges that require distributed transaction strategies, compares strong‑consistency protocols like 2PC/3PC with eventual‑consistency approaches such as TCC and Saga patterns, and discusses their trade‑offs, implementation complexity, and suitability for real‑world scenarios like a points‑based sign‑in system.
seadt is a Golang‑based TCC distributed‑transaction framework for Shopee Financial Products that lets initiators run multi‑service operations as if they were local DB actions, providing TM, RM, and TC components, automatic proxy generation, and robust handling of empty commits, rollbacks, hanging branches, and concurrency issues.
This article explains the fundamentals of distributed transactions, the ACID properties, various consistency models, database sharding strategies, and the two‑phase, three‑phase, and TCC commit protocols, while also discussing CAP, BASE, and practical challenges in large‑scale systems.
This article explains the fundamentals of distributed transactions, the ACID properties, various consistency models (strong, weak, eventual), sharding strategies (vertical and horizontal), the CAP and BASE theories, and the practical implementations of two‑phase, three‑phase, and TCC commit protocols, highlighting their advantages and drawbacks.
This article explains the fundamentals of distributed transactions, covering ACID properties, consistency models, sharding strategies, CAP and BASE theories, and compares two‑phase, three‑phase, and TCC commit protocols to illustrate how modern systems maintain data integrity across multiple nodes.
seadt is a self‑developed Golang distributed‑transaction framework for Shopee’s financial products that adopts the TCC model, providing a global Transaction Coordinator, embedded Transaction Managers and Resource Managers via an SDK to ensure atomic two‑phase commits, idempotency, high availability, and eventual consistency in loan‑processing flows, with future Saga support planned.
This article explains the TCC (Try‑Confirm‑Cancel) transaction model, its three practical variants, common pitfalls such as empty rollbacks, idempotency and hanging, and provides step‑by‑step Java code examples for integrating Seata TCC into a Spring Cloud micro‑service order system.
This article explores the challenges of data consistency in distributed systems, explains fundamental concepts such as CAP and BASE, compares industry solutions like 2PC, Saga, TCC, and local message tables, and shares practical insights from payment service refactoring and Alipay's DTS framework.
This article explains the fundamentals of transactions, compares monolithic and distributed transaction models, and walks through various distributed transaction solutions such as 2PC, 3PC, TCC, local message tables, MQ transactions, max‑effort notifications, Saga, and Seata, highlighting their trade‑offs and practical considerations.
This article explains how data consistency is achieved through local ACID transactions, global XA/2PC mechanisms, CAP and BASE theories, and practical patterns such as reliable events, TCC, and SAGA, providing a comprehensive overview for architects designing distributed systems.
This article explains the fundamentals of database transactions, defines distributed transactions, and provides a comprehensive comparison of classic solutions such as XA, SAGA, TCC, local message tables, transaction messages, maximum‑effort notifications, and AT mode, while also covering exception handling and the sub‑transaction barrier technique.
This article explains the evolution from local to distributed transactions, detailing the XA protocol, the two‑phase commit process, the LCN framework, the TCC model, and the design of business compensation mechanisms for reliable microservice systems.
This article explains distributed transactions, covering ACID properties, consistency models, sharding strategies, the CAP and BASE principles, and detailed mechanisms such as two‑phase commit, three‑phase commit, and the TCC pattern, illustrating how to maintain data integrity across multiple databases.
This article explains the fundamentals of distributed transactions, compares classic solutions such as two‑phase commit (XA), SAGA, TCC, local message tables, transaction messages, and maximum‑effort notifications, and presents a sub‑transaction barrier technique to handle network anomalies and ensure idempotency, isolation, and rollback safety.
To handle distributed transactions in micro‑service systems, the article compares 2PC, TCC, maximum‑effort notification and reliable messaging, then shows how Spring Boot can use RabbitMQ delayed queues—leveraging dead‑letter exchanges, TTL and routing—to achieve eventual consistency for order‑payment workflows.
This article explains the fundamentals of distributed transactions, compares classic solutions such as XA, Saga, TCC, local message tables, and transaction messages, and presents a sub‑transaction barrier technique that gracefully handles idempotency, empty rollbacks, and hanging issues in microservice architectures.
This article explains the fundamentals of distributed transactions, illustrates classic solutions such as two‑phase commit (XA), SAGA, TCC, local message tables, transactional messaging, and maximum‑effort notifications, and introduces a sub‑transaction barrier technique to handle network anomalies in microservice architectures.
This article introduces the fundamental concepts of distributed transactions, explains ACID and BASE properties, and systematically presents classic solutions such as two‑phase commit, SAGA, TCC, local message tables, transaction messages, maximum‑effort notifications, and sub‑transaction barriers for reliable microservice architectures.
This article explains the principles, advantages, and drawbacks of various distributed transaction solutions—including XA two‑phase commit, three‑phase commit, TCC, Saga, and message‑based eventual consistency—while showing how they are implemented in Java/Spring environments and when each should be used.
This article examines common distributed transaction patterns in micro‑service architectures—including blocking retries, asynchronous queues, TCC compensation, local message tables, and MQ transactions—explaining their mechanisms, advantages, drawbacks, and practical implementation details.
The article explains the concept of distributed transactions, why they are needed in micro‑service architectures, presents the CAP and BASE theories, and reviews major solutions such as two‑phase commit, three‑phase commit, TCC, local message tables, message‑based transactions, max‑effort notifications, Sagas and the Seata framework.
The article explains common microservice transaction patterns—including blocking retry, asynchronous queues, TCC compensation transactions, and local message tables—detailing their implementations, advantages, drawbacks, and practical code examples for ensuring data consistency in distributed systems.
The article classifies common microservice business scenarios, matches each with suitable distributed transaction patterns such as reliable messages, TCC, SAGA, and XA, and demonstrates practical implementations using DTM, SEATA, and RocketMQ with code examples and a feature comparison table.
The article examines common strategies for handling service call failures and maintaining data consistency in microservice architectures, comparing blocking retries, asynchronous queues, TCC compensation transactions, local message tables, and MQ transactions, highlighting their trade‑offs, implementation details, and practical considerations.
This article explains the principles, workflows, advantages and drawbacks of various distributed transaction solutions—including XA two‑phase commit, Java Transaction API, chained transaction managers, three‑phase commit, TCC, reliable message‑based eventual consistency and maximum‑effort notification—while comparing ACID and BASE theories for modern backend systems.
This article examines distributed transaction protocols—including XA two‑phase commit, JTA, three‑phase commit, TCC, and message‑based eventual consistency—detailing their mechanisms, advantages, drawbacks, and practical usage scenarios in modern backend systems.
This article explains the theory behind TCC distributed transactions, describes its three-phase workflow and roles, and provides a complete Python implementation using the DTM framework, including deployment steps, code examples, and handling of both successful commits and rollbacks.
This article explains the fundamentals of distributed transactions, compares classic solutions such as XA, Saga, TCC, local message tables, and transactional messages, discusses their trade‑offs, and introduces advanced techniques like sub‑transaction barriers to handle network anomalies in microservice architectures.
This article examines common techniques for handling service call failures in micro‑service architectures—blocking retries, asynchronous queues, TCC compensation transactions, local message tables, and MQ transactions—detailing their implementations, pitfalls, and trade‑offs to achieve reliable data consistency.
This article examines the challenges of distributed transactions in microservice architectures and compares five practical solutions—Seata (2PC), TCC, transactional messaging, local message tables, and a custom Kola approach—highlighting their principles, implementations, advantages, and prerequisites.
This article introduces the open‑source Seata distributed transaction solution, explains its AT, TCC, SAGA and XA modes, describes the TC‑TM‑RM components and workflow, and provides a step‑by‑step Spring Boot demo with Docker, Maven dependencies, configuration, and code examples for a multi‑service purchase scenario.
This article explains the importance of distributed transactions in micro‑service architectures, reviews ACID properties, compares various solutions such as 2PC/3PC, XA, local message tables, transactional messages, TCC, Saga, and introduces the Seata framework with its AT, TCC, and Saga modes, while also discussing consistency versus consensus with Paxos.
This article explores the fundamentals of distributed transactions in microservice architectures, detailing ACID properties, classic protocols like 2PC/3PC and XA, modern patterns such as TCC, Saga, local message tables, transaction messages, and the Seata framework, while comparing their trade‑offs with Paxos consensus.
This article examines the challenges of building a generic TCC distributed‑transaction framework on Spring, explaining why every TCC service must participate in RM‑local transactions, why the framework should intercept the Spring TransactionManager, how to handle fault recovery, idempotency of Confirm/Cancel, and the pitfalls of relying on Cancel for rollback, concluding with practical recommendations.
This article provides a comprehensive technical guide to distributed transactions, covering ACID fundamentals, consistency models, sharding techniques, CAP and BASE theories, and detailed implementations of two‑phase, three‑phase, and TCC protocols, while highlighting their advantages, limitations, and practical considerations.
This article explains the challenges of distributed transactions in micro‑service architectures and reviews major solutions such as 2PC/3PC, XA, TCC, Saga, local message tables, transactional messages, and the Seata framework, comparing their consistency, performance, and implementation trade‑offs.
This article analyzes the challenges of distributed transactions in microservice architectures, explains ACID, CAP and BASE theories, compares consistency models, and evaluates practical solutions such as two‑phase commit, local message tables, TCC, and reliable messaging with code examples and implementation details.
This article explains how 58 Recruitment’s ETX framework applies CAP and BASE theories, along with log‑first and TCC patterns, to achieve distributed eventual consistency and high availability for large‑scale transaction processing in backend systems.
This article explains the evolution of transaction management from local and distributed (2PC/3PC) transactions in monolithic systems to the challenges in microservices, introduces the BASE theory, and details four microservice‑compatible consistency patterns—reliable event notification, max‑effort notification, business compensation, and TCC—along with their trade‑offs.