Tagged articles
timeout handling
13 articles · Page 1 of 1
This article explains why an AI agent's 'completed' message can hide duplicate purchase orders after API timeouts, detailing how to verify actual creation status, implement idempotent retries with stable request IDs, distinguish cancellation from revocation, and test failure scenarios using concrete examples like REQ01 and PO8601.
API DesignIdempotencyRetry Logic
0 likes · 19 min read

An AI customer service agent's P99 latency spiked from 800ms to 8.2s when a user with 2,147 orders triggered an unbounded tool that returned 1.8MB JSON (400k tokens), causing the model to hallucinate; fixes included limiting results to 5 orders with 4 fields, adding timeouts, and implementing fallback responses, restoring P99 to 890ms.
AI agent debuggingLLM tool designagent performance
0 likes · 10 min read

This article explains why automatic retries after agent timeouts can duplicate business actions, and details how to distinguish call failures from executed side effects, implement execution-side idempotency guarantees, reconcile using original action identifiers, and define safe recovery rules with human escalation when outcomes remain unknown.
IdempotencyRetry Logicagent systems
0 likes · 17 min read

The author migrates a high-frequency internal inventory query from REST to gRPC in Spring Boot 4.1, discovering that gRPC's contract-first approach, binary encoding, and explicit timeout handling improve interface governance for service-to-service RPC, while REST remains better for web-facing and low-frequency APIs.
API ContractProtobufSchema Evolution
0 likes · 17 min read

This article explains how to handle massive concurrent requests in a group‑buy scenario by using Redis distributed locks to avoid database overselling, MQ delayed messages for timeout processing, and a local outbox table to guarantee reliable cross‑service notifications.
Distributed LockMessage QueueReliable Messaging
0 likes · 8 min read

The article explains a simplified order‑payment flow, identifies common causes of lost orders and duplicate payments, and provides practical backend strategies such as intermediate payment states, timeout queries, idempotent notifications, and Redis‑based duplicate‑submission protection.
Order Processingduplicate-submissionpayment
0 likes · 5 min read

This article explains the inner workings of InnoDB’s lock‑wait timeout thread, detailing how it scans waiting slots, identifies timed‑out transactions, processes timeout logic, and notifies the affected transactions, while also covering related data structures and configuration variables.
Database InternalsInnoDBMySQL
0 likes · 8 min read


DevOpsJun 26, 2024 · Backend Development
This article analyzes why distributed transactions are difficult in large‑scale microservice architectures, explains the importance of unique transaction IDs, idempotency, and timeout handling, and presents pragmatic approaches such as local logging, undo‑log tables, NoSQL ID arrays, and selective locking to achieve reliable consistency.
IdempotencyTransaction IDdatabase
0 likes · 15 min read

The article explains that distributed transactions in micro‑service architectures are difficult because they must guarantee atomicity across heterogeneous services, handle time‑outs, and reconcile results using unique transaction IDs, undo‑logs, or NoSQL strategies, while balancing locking, availability, and consistency trade‑offs.
IdempotencyTransaction IDdistributed transactions
0 likes · 18 min read

This article explains how to handle asynchronous operations and waiting in Python Playwright using proper wait conditions, explicit waits, and condition variables to improve test stability.
PlaywrightPythonWait Conditions
0 likes · 6 min read

This article analyzes a real production incident caused by improper thread‑pool usage, explains common misconceptions about core parameters, demonstrates faulty code examples, and provides concrete recommendations for configuring thread pools, handling timeouts, and avoiding deadlocks in Java backend services.
CompletableFutureJava ConcurrencySpring @Async
0 likes · 14 min read

The article explains why distributed transactions in micro‑service architectures are hard—due to remote failures, timeouts, and lack of atomic guarantees—and outlines practical approaches such as unique transaction IDs, audit logs, SQL/NoSQL persistence, TCC, Saga or compensation patterns to achieve reliable consistency while balancing availability.
Idempotencydistributed transactionstimeout handling
0 likes · 17 min read

This article explains the typical order flow in payment systems, identifies external and internal order loss scenarios, and provides concrete measures such as adding a "payment in progress" state, setting timeout queries, ensuring idempotent notifications, and using Redis hashes to avoid duplicate submissions.
Idempotencyorder losspayment
0 likes · 5 min read
