Skip to content
Tagged articles

Idempotency

417 articles · Page 1 of 5
CodeSmart Hoops
CodeSmart Hoops
Nov 12, 2026 · Information Security

API Security Deep Dive: Signatures, Timestamps, Nonces & Replay Prevention

This comprehensive guide answers 12 critical API security questions covering HMAC signatures, timestamp and nonce replay prevention, constant-time comparison against timing attacks, Redis SETNX atomic operations, appId/appSecret management, and key rotation strategies for robust API protection.

API SecurityHMACIdempotency
0 likes · 25 min read
API Security Deep Dive: Signatures, Timestamps, Nonces & Replay Prevention
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
Data Bricklaying Diary
Data Bricklaying Diary
Nov 10, 2026 · Backend Development

Why 'Completed' Doesn't Mean Done: Verifying Order Creation After Timeouts & Retries

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 designDistributed SystemsIdempotency
0 likes · 19 min read
Why 'Completed' Doesn't Mean Done: Verifying Order Creation After Timeouts & Retries
Data Bricklaying Diary
Data Bricklaying Diary
Nov 10, 2026 · R&D Management

Training Engineering Judgment When AI Writes the Code

The article argues that AI-generated code hides junior developers' understanding, and proposes a training loop of prediction, failure reproduction, condition variation, and scheduled mentorship within real tasks to build engineering judgment rather than relying on code volume or delivery completeness.

AI-assisted developmentGoogle SREIdempotency
0 likes · 10 min read
Training Engineering Judgment When AI Writes the Code
Chengwu Tech Stack
Chengwu Tech Stack
Nov 10, 2026 · Industry Insights

Full AI vs AI-Assisted Development: Speed, Risk, and Acceptance Compared

The article compares full AI development and AI-assisted development using a bricklaying metaphor and a notification retry case study, analyzing how human intervention points affect speed, risk, and acceptance across investigation, design, implementation, review, testing, deployment, operations, and handover.

AI-assisted developmentIdempotencyacceptance criteria
0 likes · 30 min read
Full AI vs AI-Assisted Development: Speed, Risk, and Acceptance Compared
Xiaolin Talks Programming
Xiaolin Talks Programming
Nov 8, 2026 · Backend Development

Building a Robust Member Points System with Spring Boot: Account Model, Idempotency & Reconciliation

This article details a production-grade member points and growth system built on Spring Boot, covering account modeling with ledger tables, batch-based expiration, FIFO deduction, idempotency keys, freeze/unfreeze flows, high-concurrency Redis pre-deduction with async DB persistence, anti-fraud layers, and a three-equation reconciliation framework with automated repair.

Anti-FraudDistributed SystemsIdempotency
0 likes · 34 min read
Building a Robust Member Points System with Spring Boot: Account Model, Idempotency & Reconciliation
IT Services Circle
IT Services Circle
Nov 6, 2026 · Artificial Intelligence

Beyond Caching: Architectural Solutions for Agent Context Compression Losing Tool Calls

The article analyzes why context compression in AI agents loses tool call history, causing duplicate executions, and presents five architectural fixes: an independent action ledger, idempotent interception with signatures, explicit compression prompts, external storage with retrieval, and hierarchical summarization.

AI agentsAction LedgerContext Management
0 likes · 10 min read
Beyond Caching: Architectural Solutions for Agent Context Compression Losing Tool Calls
Architecture Pony
Architecture Pony
Nov 4, 2026 · Backend Development

Spring Boot Distributed Locks: From Redisson Watchdog to RedLock Controversy

This article analyzes distributed locking in Spring Boot using Redis and Redisson, covering atomic locking with SET NX EX, watchdog lease renewal, reentrant Hash-based design, pub/sub wait notification, the RedLock algorithm debate including Martin Kleppmann's GC pause and clock jump critiques, and production pitfalls with annotation-based AOP encapsulation.

IdempotencyRedissonRedlock
0 likes · 23 min read
Spring Boot Distributed Locks: From Redisson Watchdog to RedLock Controversy
Data Bricklaying Diary
Data Bricklaying Diary
Nov 4, 2026 · Artificial Intelligence

From Chat to Completion: The Missing Links in Agent-Driven Procurement Workflows

This article analyzes the gaps between conversational approval and actual system execution in Agent-driven procurement workflows, detailing required handoffs, verification steps, pause/resume logic, compensation handling, and testing strategies to ensure agents reliably create verified purchase orders rather than just acknowledging requests.

Human-in-the-LoopIdempotencyOPM
0 likes · 15 min read
From Chat to Completion: The Missing Links in Agent-Driven Procurement Workflows
Xiaolin Talks Programming
Xiaolin Talks Programming
Nov 4, 2026 · Backend Development

Building Financial-Grade Double-Entry Bookkeeping with Spring Boot 3: From Domain Model to End-of-Day Reconciliation

This article walks through implementing a financial-grade double-entry bookkeeping system using Spring Boot 3, MyBatis, and MySQL, covering domain modeling with immutable entries and derived balances, a posting engine with idempotency and debit-credit validation, balance calculation via snapshots and incremental deltas, end-of-day trial balance verification, cross-system reconciliation, and production concerns like precision handling, sharding strategies, and hot-account mitigation.

IdempotencyMyBatisSpring Boot
0 likes · 36 min read
Building Financial-Grade Double-Entry Bookkeeping with Spring Boot 3: From Domain Model to End-of-Day Reconciliation
Java Architect Essentials
Java Architect Essentials
Nov 4, 2026 · Artificial Intelligence

GPT Pro for Complex Systems: Structured Workflow Beats Raw Speed Claims

The article warns that GPT Pro's speed on complex system code isn't universally guaranteed and recommends a structured workflow: provide service boundaries, call chains, and reproduction steps; analyze one risk point at a time (e.g., idempotency key failure in retries); review diffs in isolated branches; run integration, stress, and regression tests before deployment.

AI-assisted developmentGPT ProIdempotency
0 likes · 3 min read
GPT Pro for Complex Systems: Structured Workflow Beats Raw Speed Claims
SpringMeng
SpringMeng
Nov 3, 2026 · Artificial Intelligence

5 Agent Engineering Questions That Separate Builders from Buzzword Users

The author shares five practical engineering challenges — tool timeout handling, RAG retrieval debugging, long-context memory management, infinite loop prevention, and workflow recovery — that reveal whether Agent developers have real production experience beyond buzzwords like RAG and tool calling.

AI agentsIdempotencyLangGraph
0 likes · 11 min read
5 Agent Engineering Questions That Separate Builders from Buzzword Users
Architecture Pony
Architecture Pony
Nov 3, 2026 · Backend Development

Spring Boot RabbitMQ Reliability: From RabbitTemplate to Dead Letter Queues in Production

This comprehensive guide covers Spring Boot RabbitMQ integration for production reliability, detailing three message-loss scenarios, the three-layer exchange/queue/binding model, publisher confirms and returns, manual acknowledgment modes, local vs requeue retry strategies, dead letter queue triggers, and practical patterns for idempotency, ordering, and backlog handling with code examples.

Dead Letter QueueIdempotencyManual Acknowledgment
0 likes · 19 min read
Spring Boot RabbitMQ Reliability: From RabbitTemplate to Dead Letter Queues in Production
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Nov 3, 2026 · Backend Development

Vending Machine System Design: 5 Questions Before Coding, State Machine, Anti-Overselling & Power-Failure Recovery

This article provides a comprehensive system design for a vending machine, covering requirement clarification, state machine modeling, concurrency control for overselling prevention, payment idempotency, hardware fault tolerance with MQTT and WAL-based power failure recovery, and engineering best practices for offline sales and reconciliation.

IdempotencyIoTconcurrency-control
0 likes · 34 min read
Vending Machine System Design: 5 Questions Before Coding, State Machine, Anti-Overselling & Power-Failure Recovery
Data Practical Notes
Data Practical Notes
Nov 3, 2026 · Big Data

Why Your Data Doubles: 5 Causes & Proven Deduplication Strategies

This article analyzes five root causes of data duplication, classifies duplicate types, compares SQL deduplication methods (DISTINCT, GROUP BY, ROW_NUMBER), covers source-level prevention with unique constraints and idempotency, explains real-time CDC deduplication strategies, and outlines a five-step process for building sustainable data quality governance.

CDCETLIdempotency
0 likes · 18 min read
Why Your Data Doubles: 5 Causes & Proven Deduplication Strategies
Data Bricklaying Diary
Data Bricklaying Diary
Nov 2, 2026 · Product Management

Ontology Built: Must AI Auto-Execute? Scoping Safe Procurement Automation

The article argues that building an ontology doesn't mandate full AI automation; instead, procurement automation should be scoped per task across four levels—query, suggest, per-order approval, and pre-authorized auto-execution—with rigorous checks on objects, data, permissions, quotas, idempotency, and exception handling, plus pause/resume procedures and holistic testing that counts rework and maintenance costs.

AI automationHuman-in-the-LoopIdempotency
0 likes · 14 min read
Ontology Built: Must AI Auto-Execute? Scoping Safe Procurement Automation
Data Practical Notes
Data Practical Notes
Nov 2, 2026 · Big Data

Exactly-Once Semantics: Why 'Processed Once' Isn't That Simple in Data Pipelines

This article explains exactly-once processing semantics in data engineering, contrasting it with at-most-once and at-least-once, detailing why retries cause duplicates, the roles of checkpoints, idempotency, and transactions, why technical exactly-once doesn't guarantee business correctness, and the four critical failure tests needed before production deployment.

Data ConsistencyData PipelineFault Tolerance
0 likes · 16 min read
Exactly-Once Semantics: Why 'Processed Once' Isn't That Simple in Data Pipelines
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Nov 1, 2026 · Backend Development

Designing Production-Grade APIs: Contracts, Security, Idempotency & Rate Limiting with Code

This comprehensive guide covers designing production-ready APIs from contract design and security (HMAC-SHA256 signatures, nonce replay protection) to idempotency (five patterns with Redis Lua), distributed rate limiting (token bucket, sliding window), observability (TraceID, logging, monitoring), and versioning strategies, with production-ready Java code examples.

API designIdempotencyJava
0 likes · 39 min read
Designing Production-Grade APIs: Contracts, Security, Idempotency & Rate Limiting with Code
Data Bricklaying Diary
Data Bricklaying Diary
Nov 1, 2026 · Backend Development

Why MCP and Workflows Aren't Enough: Defining Business Action Contracts

The article explains why Model Context Protocol (MCP) and workflows alone cannot enforce business rules like parameter provenance, approval validation, idempotency, and result verification, using a procurement example to illustrate the need for explicit Action contracts that define conditions, approvals, and error handling.

Business ActionIdempotencyMCP
0 likes · 16 min read
Why MCP and Workflows Aren't Enough: Defining Business Action Contracts
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Oct 29, 2026 · Backend Development

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

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

Backend ArchitectureDistributed SystemsIdempotency
0 likes · 45 min read
API Idempotency Deep Dive: 8 Patterns, 4-Layer Defense & Production Code
Ops Community
Ops Community
Oct 26, 2026 · Operations

Ansible for Batch Server Inspection, Config Management & Zero-Downtime Deployments

This article details using Ansible to automate server inspection, configuration convergence, and application deployment across 60 heterogeneous Linux nodes, covering inventory design, idempotency patterns, rolling deployments with health checks, drift detection, and production-grade practices for reliability and auditability.

AnsibleApplication DeploymentConfiguration Management
0 likes · 72 min read
Ansible for Batch Server Inspection, Config Management & Zero-Downtime Deployments
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Oct 25, 2026 · Databases

10B Rows into MySQL: From 231 Days to 3.5 Hours — The 6-Step Bulk Insert Playbook

This article details a six-step engineering playbook to bulk-insert 10 billion rows into MySQL, reducing time from 231 days to under 3.5 hours by combining sharding, true JDBC batching with rewriteBatchedStatements, LOAD DATA INFILE, temporary parameter tuning, parallel shard loading, idempotent checkpointing, and shadow-table swapping, while explaining B+ tree capacity math and common pitfalls.

B+ TreeBulk InsertIdempotency
0 likes · 42 min read
10B Rows into MySQL: From 231 Days to 3.5 Hours — The 6-Step Bulk Insert Playbook
Java Tech Workshop
Java Tech Workshop
Oct 25, 2026 · Backend Development

OpenFeign Timeout Retries Cause Duplicate Orders: Layered Retry Analysis & Idempotency Fix

This article analyzes how OpenFeign's default timeout and hidden retry layers (Feign, LoadBalancer, HttpClient, Nginx) cause duplicate requests, demonstrates a reproducible case where a 12-second downstream service triggers three retries creating duplicate orders, and presents a database unique-index idempotency pattern to prevent duplicates.

HttpClientIdempotencyOpenFeign
0 likes · 22 min read
OpenFeign Timeout Retries Cause Duplicate Orders: Layered Retry Analysis & Idempotency Fix
Cloud Architecture
Cloud Architecture
Oct 21, 2026 · Backend Development

Beyond Handlers: Reliable Order Services with Kratos — Layering, Idempotency, Consistency & Capacity Governance

This article details how to build a production-grade order service using Kratos v2, MySQL, Kafka, and Kubernetes, covering idempotency keys, outbox pattern, inventory reservation, state machines, context/timeouts, middleware, observability, Kubernetes probes, capacity planning for 8000 QPS, and automated fault-injection tests.

IdempotencyInventory ReservationKratos
0 likes · 63 min read
Beyond Handlers: Reliable Order Services with Kratos — Layering, Idempotency, Consistency & Capacity Governance
IT Architects Alliance
IT Architects Alliance
Oct 21, 2026 · Artificial Intelligence

AI Agent Harness Value: Correction Gains vs. Fixed Costs

This article analyzes the ROI of behavior harnesses for AI agents using a BFF timeout-retry case study, showing how harnesses turn omissions into fixable signals, distinguishing runtime recovery from development-time correction, and calculating break-even points where per-run savings offset fixed harness investment.

AI AgentBFFBehavior Harness
0 likes · 15 min read
AI Agent Harness Value: Correction Gains vs. Fixed Costs
Cilantro Loves Linux
Cilantro Loves Linux
Oct 18, 2026 · Backend Development

Batch Processing Scheduling Architecture: Reliability Beyond Scheduled Triggers

This chapter distinguishes scheduling from batch execution, covering single-machine, cluster, distributed, and pipeline batch patterns, emphasizing reliability through state tracking, idempotency, sharding, checkpoints, and explicit dependencies over fixed timing. It also outlines practical platform capabilities like versioned task definitions, unique run instances, state machines, leases, business idempotency keys, resource quotas, and end-to-end reconciliation.

Distributed SystemsIdempotencyPipeline
0 likes · 9 min read
Batch Processing Scheduling Architecture: Reliability Beyond Scheduled Triggers
Cambridge Mofang Notes
Cambridge Mofang Notes
Oct 15, 2026 · R&D Management

AI Generates an Order API in 30 Seconds — Why I Still Won't Merge It

The article demonstrates that while AI coding agents can produce functional order-API code in seconds, shipping reliable software still demands deep engineering judgment — around business rules, edge cases, consistency, concurrency, and operational constraints — that AI amplifies but cannot replace.

AI coding agentsAI-assisted developmentDistributed Systems
0 likes · 14 min read
AI Generates an Order API in 30 Seconds — Why I Still Won't Merge It
Cilantro Loves Linux
Cilantro Loves Linux
Oct 15, 2026 · Information Security

System Attack-Defense Architecture: Multi-Layer Security Patterns from CAPTCHA to Replay Prevention

This chapter from Yin Hongliang's Architecture Fundamentals details attack models like SMS abuse, brute force, and replay attacks, then explains layered defenses including risk-based CAPTCHA, distributed verification with one-time credentials, idempotency keys, signature validation, and multi-dimensional rate limiting with circuit breakers.

CAPTCHAIdempotencydefense in depth
0 likes · 9 min read
System Attack-Defense Architecture: Multi-Layer Security Patterns from CAPTCHA to Replay Prevention
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Oct 14, 2026 · Backend Development

Async Idempotency in Practice: Local Message Tables, Duplicate Deduction Fixes, and Layered Defense

A real-world postmortem of duplicate coupon deductions during a major promotion reveals how retries in local message tables cause duplicate execution; the article dissects four idempotency patterns, their trade-offs, and a layered defense architecture with a practical review checklist.

Architecture PatternsDistributed SystemsIdempotency
0 likes · 24 min read
Async Idempotency in Practice: Local Message Tables, Duplicate Deduction Fixes, and Layered Defense
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Oct 12, 2026 · Backend Development

Local Message Tables: Production-Hardened Alternative to Seata for E-Commerce Eventual Consistency

This article analyzes three production failures with local message tables in e-commerce systems — non-atomic writes losing messages, retry storms overwhelming databases, and missing idempotency causing duplicate operations — and provides a six-point production review checklist covering atomic writes, exponential backoff retries, idempotency keys, distributed scheduler locks, table archiving, and dead-letter alerting.

Dead Letter QueueIdempotencySeata
0 likes · 13 min read
Local Message Tables: Production-Hardened Alternative to Seata for E-Commerce Eventual Consistency
AI Engineer Programming
AI Engineer Programming
Oct 12, 2026 · Fundamentals

Reliability in Software Engineering: Definitions, Key Concerns, and Distributed Systems Reality

This article defines software reliability per ISO/IEC 25010, distinguishes it from availability and stability, and details five operational concerns — correct user-visible results, change management, blast radius, detection/recovery speed, and failure semantics — with concrete distributed-systems patterns like idempotency, fault domains, burn-rate alerting, and fault injection.

CAP theoremDistributed SystemsError Budget
0 likes · 34 min read
Reliability in Software Engineering: Definitions, Key Concerns, and Distributed Systems Reality
Architect
Architect
Oct 10, 2026 · Artificial Intelligence

Output Isn't Completion: The Verifiable Evidence Gap in AI Agents

This article argues that AI agents often mistake model output or tool calls for task completion, but real business completion requires verifiable read-back evidence, idempotency handling for timeouts, explicit acceptance criteria, and structured completion records — not just a 'final_output' signal.

AI agentsAWSIdempotency
0 likes · 18 min read
Output Isn't Completion: The Verifiable Evidence Gap in AI Agents
IT Architects Alliance
IT Architects Alliance
Oct 9, 2026 · Backend Development

API Timeout After Ticket Creation: Why Query-First Recovery Beats Blind Retries

When an API times out after creating a ticket, the system must treat the result as unknown rather than failed, using persistent operation IDs to query the business service, relying on idempotency contracts for safe retries, and escalating to manual review only after exhausting a time-bounded recovery budget.

API timeoutAgent RuntimeDistributed Systems
0 likes · 28 min read
API Timeout After Ticket Creation: Why Query-First Recovery Beats Blind Retries
Data Bricklaying Diary
Data Bricklaying Diary
Oct 7, 2026 · Backend Development

Agent Error Recovery: Why Retries Alone Fail — Idempotency & Reconciliation

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.

Distributed SystemsIdempotencyRetry Logic
0 likes · 17 min read
Agent Error Recovery: Why Retries Alone Fail — Idempotency & Reconciliation
IT Architects Alliance
IT Architects Alliance
Oct 7, 2026 · Information Security

Zero Trust Done: Build Control Plane Before Ticket Agent Write Access?

Article argues for read-first validation before enabling ticket-closing Agent write access, detailing five enforcement layers (identity, tool authorization, credentials, runtime isolation, audit), a dual-track transition with human-in-the-loop, idempotency and atomic state checks, and a seven-question launch review to ensure execution boundaries exist before any control-plane investment.

Credential ManagementIdempotencyaudit
0 likes · 15 min read
Zero Trust Done: Build Control Plane Before Ticket Agent Write Access?
liandk
liandk
Oct 5, 2026 · Backend Development

Root-Cause Analysis & Fixes for Production Dirty Data & Inconsistency

This article systematically analyzes six root causes of production data inconsistency, details fixes for five core scenarios (inventory, orders, funds, points, cache), reveals four hidden bugs, and provides a three-layer verification system, an 8-step repair SOP, and nine ironclad rules for data high availability.

Cache ConsistencyData ConsistencyIdempotency
0 likes · 16 min read
Root-Cause Analysis & Fixes for Production Dirty Data & Inconsistency
Yumin Fish Harvest
Yumin Fish Harvest
Oct 2, 2026 · Backend Development

Concurrent Write Correctness: Choosing Between Conditional Updates, Pessimistic/Optimistic Locks, and Distributed Locks

This article analyzes four concurrency control patterns — conditional updates, pessimistic locking, optimistic locking with version numbers, and distributed locks — using inventory deduction, order editing, and third-party push examples. It explains when each pattern applies, how to combine them with idempotency, and provides concrete SQL and Redis implementations.

Distributed LocksIdempotencyOptimistic Locking
0 likes · 32 min read
Concurrent Write Correctness: Choosing Between Conditional Updates, Pessimistic/Optimistic Locks, and Distributed Locks
ITPUB
ITPUB
Sep 30, 2026 · Artificial Intelligence

How AI Agents Handle High Concurrency: Admission, Backpressure, Async & Isolation

This article details a production-grade architecture for handling high concurrency in AI agent systems, covering real load estimation, admission control with bounded queues, async task processing, hierarchical concurrency budgets for models and tools, resource isolation via bulkheads, idempotency for state consistency, graded degradation strategies, and observability-driven capacity planning.

AI agentsConcurrency BudgetIdempotency
0 likes · 18 min read
How AI Agents Handle High Concurrency: Admission, Backpressure, Async & Isolation
LuTiao Programming
LuTiao Programming
Sep 29, 2026 · Backend Development

Spring Boot Retry Pitfall: Timeout ≠ Failure — Idempotency & Concurrency Fixes

The article explains why naive retries after timeouts cause duplicate orders in Spring Boot, demonstrating how to properly classify retryable exceptions, implement idempotency with stable request IDs, handle non-idempotent third-party APIs via query-before-retry, add concurrency limits with @ConcurrencyLimit, and separate concerns into Service, Gateway, and Client layers using Spring Framework 7's @Retryable.

Backend PatternsConcurrency LimitIdempotency
0 likes · 14 min read
Spring Boot Retry Pitfall: Timeout ≠ Failure — Idempotency & Concurrency Fixes
Ray's Galactic Tech
Ray's Galactic Tech
Sep 29, 2026 · Backend Development

Production-Grade LLM Annotation Pipeline: Pydantic, PostgreSQL & Kafka Patterns

The article details how a SaaS team evolved a fragile LLM ticket-classification script into a production-grade pipeline using strict Pydantic contracts, PostgreSQL state machines with atomic leasing, Kafka outbox patterns, immutable training snapshots, and metric-gated rollouts to handle model drift, replay, and human review safely.

Data EngineeringIdempotencyKafka
0 likes · 27 min read
Production-Grade LLM Annotation Pipeline: Pydantic, PostgreSQL & Kafka Patterns
Niu Liu
Niu Liu
Sep 25, 2026 · Backend Development

Exactly Once: What It Guarantees, Why Payments Double-Charge, and How to Fix It

This article explains that Exactly Once semantics in message queues like Kafka only guarantee exactly-once processing within the messaging system's transaction boundary, not for external side effects like payment APIs, and provides practical patterns using database unique constraints, idempotency keys, and timeout handling to achieve true end-to-end exactly-once behavior.

IdempotencyKafkaMessage Queue
0 likes · 9 min read
Exactly Once: What It Guarantees, Why Payments Double-Charge, and How to Fix It
Data Bricklaying Diary
Data Bricklaying Diary
Sep 25, 2026 · Backend Development

Beyond Retry: Designing Fault Tolerance from Failure Models to Disaster Recovery

This article explains why retry alone is insufficient for fault tolerance, detailing how to classify failures via fault models, apply appropriate mechanisms like timeouts and circuit breakers, design recovery paths targeting state convergence, define RTO/RPO for disaster recovery, and validate all assumptions through fault injection drills.

Distributed SystemsFault ToleranceIdempotency
0 likes · 23 min read
Beyond Retry: Designing Fault Tolerance from Failure Models to Disaster Recovery
Cloud Architecture
Cloud Architecture
Sep 24, 2026 · Backend Development

Scaling Spring Boot Sign-In to 100M Users: Distributed Architecture Evolution & Production Hardening

This article details the evolution of a Spring Boot daily sign-in system from 10K to 100M users, covering Redis bitmap sharding, Lua atomic operations, command outbox pattern, Kafka async reward processing, idempotency guarantees, fault tolerance strategies, and production-grade observability with real incident postmortems.

BitmapCommand OutboxDistributed Systems
0 likes · 36 min read
Scaling Spring Boot Sign-In to 100M Users: Distributed Architecture Evolution & Production Hardening
LuTiao Programming
LuTiao Programming
Sep 22, 2026 · Backend Development

Beyond Distributed Locks: Three-Layer Idempotency for Spring Boot Order APIs

The article demonstrates why distributed locks alone fail to guarantee idempotency in Spring Boot order APIs, and presents a three-layer solution combining Idempotency-Key with request fingerprinting, Redis SET NX for fast duplicate interception, and a database unique constraint as the ultimate safeguard against duplicate orders even after crashes or Redis failures.

API designDistributed LocksIdempotency
0 likes · 25 min read
Beyond Distributed Locks: Three-Layer Idempotency for Spring Boot Order APIs
Yumin Fish Harvest
Yumin Fish Harvest
Sep 21, 2026 · Backend Development

Idempotency Design for Write Services: 7 Patterns & Selection Guide

This article details seven idempotency patterns for backend write operations—including unique keys with database constraints, state machines, execution records, naturally idempotent actions, request fingerprinting, client-generated keys, and server-issued tokens—with concrete examples, SQL code, and a selection guide to match each pattern to specific business scenarios like payment callbacks, order cancellations, and duplicate purchases.

Distributed SystemsIdempotencybackend development
0 likes · 29 min read
Idempotency Design for Write Services: 7 Patterns & Selection Guide
Lobster Programming
Lobster Programming
Sep 21, 2026 · Backend Development

5 Ways to Prevent API Replay Attacks: From Nonces to Idempotency Keys

This article explains five practical solutions to prevent API replay attacks, including unique nonces with Redis storage, timestamp validation, combined signature-timestamp-nonce schemes, backend-issued one-time tokens, and business-level idempotency keys for critical operations like payments.

API SecurityIdempotencybackend development
0 likes · 6 min read
5 Ways to Prevent API Replay Attacks: From Nonces to Idempotency Keys
Java Tech Workshop
Java Tech Workshop
Sep 20, 2026 · Backend Development

Order Timeout Auto-Cancellation: RabbitMQ Delayed Queue + Scheduled Task Dual Insurance Pattern

This article details a production-ready dual-insurance pattern for e-commerce order timeout cancellation, combining RabbitMQ delayed message queues for real-time processing with scheduled database scans as a fallback, including Spring Boot implementation code, idempotent cancellation logic, and distributed deployment considerations.

Distributed SystemsIdempotencyMessage Queue
0 likes · 16 min read
Order Timeout Auto-Cancellation: RabbitMQ Delayed Queue + Scheduled Task Dual Insurance Pattern
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.

Distributed SystemsIdempotencyOutbox Pattern
0 likes · 17 min read
How to Guarantee Single Order Processing When Payment Callbacks Fire 10 Times
Xiaolin Talks Programming
Xiaolin Talks Programming
Sep 19, 2026 · Backend Development

Building a Multi-Channel Notification Center: Template Design, Async Processing & Reliable Retry Patterns

This article details the architecture and implementation of a production-grade notification center that abstracts channel differences, uses Thymeleaf for template rendering, employs Channel/Provider abstractions for multi-vendor support, handles async execution via thread pools and message queues, and ensures reliability through persistent task tracking, exponential backoff retries, rate limiting, idempotency, and audit logging.

IdempotencyMessage QueueRetry Pattern
0 likes · 24 min read
Building a Multi-Channel Notification Center: Template Design, Async Processing & Reliable Retry Patterns
Xiaolin Talks Programming
Xiaolin Talks Programming
Sep 18, 2026 · Backend Development

Engineering Large-Scale Excel Imports: Spring Boot + EasyExcel Streaming & Task Isolation

This article details a production-ready engineering approach for importing hundreds of thousands of Excel rows using Spring Boot and EasyExcel, covering streaming parsing, batch validation, async task isolation, idempotency, error reporting, and operational concerns like logging and temp file cleanup.

EasyExcelIdempotencyProduction Engineering
0 likes · 23 min read
Engineering Large-Scale Excel Imports: Spring Boot + EasyExcel Streaming & Task Isolation
Cloud Architecture
Cloud Architecture
Sep 17, 2026 · Databases

Indexes Aren't Free: Production Index Governance for High-Write Order Systems

This article presents a comprehensive index governance methodology for high-write MySQL order systems, demonstrating through a real incident how a read-optimized index caused write latency, replica lag, and timeouts, and detailing a reusable process covering query-driven design, cost measurement, validation, change buffer limits, index convergence, safe deletion, read-write routing, sharding, transactional outbox, idempotent consumers, online DDL safeguards, gating, and long-term ownership.

Change BufferDescending IndexesHigh-Write Systems
0 likes · 29 min read
Indexes Aren't Free: Production Index Governance for High-Write Order Systems
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Sep 15, 2026 · Backend Development

Distributed Timeout & Retry Deep Dive: Prevent Cascading Failures

This article analyzes three real e-commerce production incidents caused by misconfigured timeouts and uncontrolled retries, then provides a systematic framework for timeout calculation, call-chain layering, retry decision boundaries, MQ-specific rules, and a release-review checklist to prevent cascading failures in microservices.

Distributed SystemsIdempotencyMQ
0 likes · 27 min read
Distributed Timeout & Retry Deep Dive: Prevent Cascading Failures
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Sep 15, 2026 · Backend Development

RocketMQ Interview Deep Dive: 8 Core Topics from Architecture to Message Backlog

This comprehensive guide covers eight critical RocketMQ interview topics including architecture design, CommitLog storage, message sending/consumption modes, transaction messages, reliability mechanisms, duplicate consumption handling, and message backlog solutions with production-grade troubleshooting steps.

Distributed SystemsHigh AvailabilityIdempotency
0 likes · 40 min read
RocketMQ Interview Deep Dive: 8 Core Topics from Architecture to Message Backlog
Architect
Architect
Sep 13, 2026 · Artificial Intelligence

Multi-Agent Consistency: Distributed Systems Challenges Return with Autonomous Agents

The article explores four critical questions for multi-agent consistency: task decomposition rationale, structured handoffs with versioned snapshots, conflict resolution via evidence-based contracts, and verifiable completion criteria. It argues multi-agent systems reintroduce classic distributed systems challenges—identity, leases, idempotency, compensation—and require runtime proofs over model assertions.

Agent orchestrationConsistencyDistributed Systems
0 likes · 21 min read
Multi-Agent Consistency: Distributed Systems Challenges Return with Autonomous Agents
Random Bulletin
Random Bulletin
Sep 12, 2026 · Operations

Automatic Rollback at 10M QPS: Evidence, Scope, and Safe Recovery Loops

This article dissects why manual rollback breaks at 10M QPS and details a five-phase automatic rollback loop—context collection, health evaluation, traffic freeze, phased execution, and layered verification—emphasizing multi-signal decision rules, rollback-object dependency graphs, blast-radius control via canary, idempotent execution, and circuit-breaker governance to prevent automation-induced failures.

IdempotencyOperations Automationautomatic rollback
0 likes · 26 min read
Automatic Rollback at 10M QPS: Evidence, Scope, and Safe Recovery Loops
Data Bricklaying Diary
Data Bricklaying Diary
Sep 11, 2026 · Backend Development

Distributed Systems' Hardest Challenge: State Over Interfaces — Consistency, Idempotency & Async Tasks

This article explores why cross-service state management is harder than API design in distributed systems, using a refund example to illustrate how local transactions, idempotency, state machines, Outbox patterns, and manual intervention achieve recoverable convergence when operations span multiple services and external channels.

ConsistencyDistributed SystemsFault Tolerance
0 likes · 21 min read
Distributed Systems' Hardest Challenge: State Over Interfaces — Consistency, Idempotency & Async Tasks
LuTiao Programming
LuTiao Programming
Sep 10, 2026 · Backend Development

Spring Framework 7 Retry & ConcurrencyLimit: Avoiding the Traffic Amplifier Trap

The author migrates from hand-written retry code and Spring Retry to Spring Framework 7's built-in @Retryable and @ConcurrencyLimit, discovering that retry logic can amplify downstream traffic under virtual threads, and shares lessons on selective exception handling, jitter, idempotency for write operations, and the difference between local concurrency limits and distributed rate limiting.

ConcurrencyLimitIdempotencyResilience
0 likes · 16 min read
Spring Framework 7 Retry & ConcurrencyLimit: Avoiding the Traffic Amplifier Trap
Cloud Architecture
Cloud Architecture
Sep 7, 2026 · Backend Development

Why a Single Timeout Spawned Two Risk Reviews: Production MCP Server Patterns

The article analyzes a timeout-induced duplicate risk review incident, then presents a comprehensive production-grade MCP server design covering stateless protocol alignment, schema validation, dual-key idempotency (request_key + business_key), UNKNOWN state machine, recovery workers, MCP Tasks integration, concurrency control, observability, and fault-injection testing to ensure exactly-once business effects.

Distributed SystemsIdempotencyMCP
0 likes · 27 min read
Why a Single Timeout Spawned Two Risk Reviews: Production MCP Server Patterns
Cambridge Mofang Notes
Cambridge Mofang Notes
Sep 7, 2026 · Backend Development

Points System Architecture: Concurrency, Batch Expiration & Idempotent Reconciliation

This article walks through designing a points system architecture, starting from a concrete scenario of consuming 80 points across two batches with retries and refunds, covering data models, idempotency keys, local transactions, cache-aside, event-driven reconciliation, scaling strategies, and evolutionary deployment phases.

Cache AsideIdempotencyPoints System
0 likes · 27 min read
Points System Architecture: Concurrency, Batch Expiration & Idempotent Reconciliation
Open Source Tech Hub
Open Source Tech Hub
Sep 6, 2026 · Backend Development

Designing Reliable Failure Boundaries in PHP: Errors, Exceptions & Result Types

This article explores how to design robust failure boundaries in PHP payment systems by distinguishing validation errors, expected business declines, transient provider failures, and programming defects, using result types for normal outcomes, translated exceptions for integration failures, idempotent retries, and observability without sensitive data.

ExceptionsIdempotencyPHP
0 likes · 38 min read
Designing Reliable Failure Boundaries in PHP: Errors, Exceptions & Result Types
LuTiao Programming
LuTiao Programming
Sep 5, 2026 · Backend Development

Why @Scheduled Runs 3× in Kubernetes: Migrating to JobRunr for Distributed Tasks

After scaling a Spring Boot app to three Kubernetes replicas, @Scheduled tasks ran thrice, generating duplicate reports. The author evaluates distributed locks but adopts JobRunr for persistent, retryable, and monitorable background jobs, demonstrating integration with Spring Boot 4, code patterns for fire-and-forget, recurring, and delayed tasks, plus idempotency and deduplication strategies.

Background JobsDistributed Task SchedulingIdempotency
0 likes · 16 min read
Why @Scheduled Runs 3× in Kubernetes: Migrating to JobRunr for Distributed Tasks
Coder Trainee
Coder Trainee
Sep 3, 2026 · Mobile Development

Complete Guide: Integrating WeChat Virtual Payment for Individual Developers

This tutorial walks individual developers through the entire process of applying for and integrating WeChat Virtual Payment into a mini-program, covering eligibility checks, application steps, key configuration parameters, product creation, frontend and backend integration flows, iOS IAP considerations, a pre-deployment checklist, and two common pitfalls to avoid.

AppKeyIAPIdempotency
0 likes · 10 min read
Complete Guide: Integrating WeChat Virtual Payment for Individual Developers
Cloud Architecture
Cloud Architecture
Sep 3, 2026 · Backend Development

TCC Is Not a Silver Bullet: Engineering Go Microservice Distributed Transactions with Performance Tuning

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.

ConcurrencyGoIdempotency
0 likes · 33 min read
TCC Is Not a Silver Bullet: Engineering Go Microservice Distributed Transactions with Performance Tuning
Chengwu Tech Stack
Chengwu Tech Stack
Sep 3, 2026 · Artificial Intelligence

Designing a Resilient AI Runtime: Observability, Degradation, Takeover, Rollback

This article outlines a production-grade AI runtime architecture that separates processing state from business conclusions, enforces bounded model execution with retry budgets and circuit breakers, ensures idempotent external actions, defines explicit degradation paths, structures human-in-the-loop workflows, extends observability to judgment quality, and validates rollback and failure injection before launch.

AI productionHuman-in-the-LoopIdempotency
0 likes · 27 min read
Designing a Resilient AI Runtime: Observability, Degradation, Takeover, Rollback
Tech Ocean
Tech Ocean
Sep 3, 2026 · Backend Development

AI Coding Is Nearly Free — Why Does Delivery Still Cost So Much?

The article argues that while AI tools like Claude Code accelerate initial code generation, the real engineering effort lies in defining failure states, untangling legacy systems, ensuring idempotency, rigorous testing, safe rollbacks, and post-launch observability — illustrated through an order resubmission feature that requires six non-negotiable steps before production.

AI CodingBackend EngineeringIdempotency
0 likes · 12 min read
AI Coding Is Nearly Free — Why Does Delivery Still Cost So Much?
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Sep 2, 2026 · Backend Development

How to Build a Scalable Notification Service with Spring Boot

The article explains why notification services are hard—slow delivery, unreliable third‑party providers, and status tracking—and shows how to solve these issues by fully decoupling the API from workers using a message queue, with detailed Spring Boot code examples and scaling strategies.

IdempotencyJavaNotification Service
0 likes · 10 min read
How to Build a Scalable Notification Service with Spring Boot
LuTiao Programming
LuTiao Programming
Aug 31, 2026 · Backend Development

Why Disabled Buttons Still Produce Duplicate Orders – Rebuilding Idempotency in Spring Boot

The article examines a common duplicate‑order bug caused by client retries after network timeouts, explains why @Transactional alone cannot guarantee idempotency, critiques simple Redis SETNX solutions, and presents a robust Spring Boot design that stores idempotency records together with order data in a single MySQL transaction, uses request fingerprints, unique keys, and owner tokens to safely replay or reject retries while handling concurrency and cleanup.

@TransactionalAPI designConcurrency
0 likes · 19 min read
Why Disabled Buttons Still Produce Duplicate Orders – Rebuilding Idempotency in Spring Boot
Lakehouse Research Base
Lakehouse Research Base
Aug 31, 2026 · Big Data

Factory Lines & Data Pipelines: The Shared Orchestration DNA

This article reveals the deep structural isomorphism between manufacturing assembly lines and data pipeline orchestration, mapping five shared design philosophies, a 15-dimension logical correspondence, bidirectional lessons, and six practical mental models for data engineers to adopt factory-floor thinking.

Data EngineeringIdempotencyassembly line
0 likes · 22 min read
Factory Lines & Data Pipelines: The Shared Orchestration DNA
Ray's Galactic Tech
Ray's Galactic Tech
Aug 24, 2026 · Backend Development

Decoupling Payments and Wallets: From Order Domain to a Unified Accounting Center

The article walks through why embedding a wallet in the order service leads to boundary violations and failures under load, and presents a step‑by‑step evolution from an order‑centric wallet to a dedicated, event‑driven accounting center that ensures consistency, auditability, and high‑throughput scalability.

IdempotencyOutbox Patternaccounting
0 likes · 42 min read
Decoupling Payments and Wallets: From Order Domain to a Unified Accounting Center
Ray's Galactic Tech
Ray's Galactic Tech
Aug 22, 2026 · Backend Development

High-Concurrency Wallet Design: Hot Accounts, Idempotent Deductions, and Sharding Practices

The article analyses why wallet balance deduction is more error‑prone than inventory, outlines the root causes of a real‑world 60 k TPS outage, and presents a production‑grade architecture that separates strong‑consistent user deductions from asynchronous hot‑account crediting using idempotent requests, unique DB constraints, sharding, outbox messaging, and comprehensive monitoring to guarantee financial correctness under extreme load.

IdempotencyOutboxScaling
0 likes · 32 min read
High-Concurrency Wallet Design: Hot Accounts, Idempotent Deductions, and Sharding Practices
Data Bricklaying Diary
Data Bricklaying Diary
Aug 21, 2026 · R&D Management

Feature Complete ≠ Production Ready: Why AI Coding Demands Engineering Discipline

This article argues that AI can rapidly generate functional code but cannot lower the engineering bar for production readiness, which requires risk-matched baselines, independent verification, and accountable gates — illustrated through a batch-import example showing the gap between happy-path code and real-world constraints like retries, idempotency, observability, and rollback.

AI-assisted developmentIdempotencyProduction Readiness
0 likes · 21 min read
Feature Complete ≠ Production Ready: Why AI Coding Demands Engineering Discipline
LuTiao Programming
LuTiao Programming
Aug 20, 2026 · Backend Development

Recreating Taobao’s 30‑Minute Unpaid Order Auto‑Close in Spring Boot Without Redis or Minute‑by‑Minute Scans

The article explains how to replace the common @Scheduled per‑minute scan or Redis TTL approach for auto‑closing unpaid orders with JobRunr’s durable delayed‑job feature in Spring Boot, detailing the implementation steps, scalability benefits, idempotent handling, and distributed execution considerations.

Background JobsDistributed SchedulingIdempotency
0 likes · 11 min read
Recreating Taobao’s 30‑Minute Unpaid Order Auto‑Close in Spring Boot Without Redis or Minute‑by‑Minute Scans
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Aug 20, 2026 · Backend Development

Microservice Idempotency: 7 Production Patterns to Eliminate Duplicate Orders & Payments

This article presents seven production-ready idempotency patterns for microservices — frontend debounce, token mechanism, database unique indexes, state machine validation, Redis caching, MQ consumer deduplication, and distributed locks — organized as a layered defense from frontend to database, with code examples and a real duplicate-payment incident analysis.

Distributed SystemsIdempotencyMessage Queue
0 likes · 11 min read
Microservice Idempotency: 7 Production Patterns to Eliminate Duplicate Orders & Payments
Ray's Galactic Tech
Ray's Galactic Tech
Aug 20, 2026 · Backend Development

Why Wallet Balance Shouldn't Be Calculated On‑The‑Fly: Double‑Entry Accounting, Snapshots, and Immutable Ledger Practices

The article explains that a production‑grade wallet must store balance snapshots instead of summing transaction flows, using double‑entry bookkeeping, ACID guarantees, idempotent request handling, outbox messaging, sharding, and comprehensive reconciliation to ensure correctness and high‑throughput under heavy concurrency.

IdempotencyOutbox Patternbalance snapshot
0 likes · 43 min read
Why Wallet Balance Shouldn't Be Calculated On‑The‑Fly: Double‑Entry Accounting, Snapshots, and Immutable Ledger Practices
Ray's Galactic Tech
Ray's Galactic Tech
Aug 19, 2026 · Backend Development

Designing a 12‑State Payment System State Machine from Pending to Completed

This article presents a complete design for a 12‑state payment order state machine that handles high‑concurrency scenarios such as payment callbacks arriving after an order has been cancelled, using explicit state transitions, database CAS updates, Redis + DB idempotency, Outbox pattern and Kafka‑driven asynchronous processing to achieve reliable, auditable and compensatable order lifecycle management.

ConcurrencyIdempotencyKafka
0 likes · 39 min read
Designing a 12‑State Payment System State Machine from Pending to Completed
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Aug 18, 2026 · Backend Development

Local Message Tables: Production-Ready Microservice Async Consistency Solution

This article presents the local message table pattern as a lightweight, production-ready solution for achieving eventual consistency in microservice architectures, covering database schema design, transactional message persistence, scheduled retry mechanisms, idempotent consumption, and real-world incident resolution compared to heavier alternatives like Seata and TCC.

IdempotencyMessage Queuedatabase design
0 likes · 11 min read
Local Message Tables: Production-Ready Microservice Async Consistency Solution
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Aug 18, 2026 · Backend Development

How Alipay Ensures Payment Idempotency in High‑Concurrency Systems

The article explains why idempotency is critical for Alipay’s high‑concurrency, high‑reliability payment platform and outlines four key reasons—funds safety, handling network uncertainty, user experience, and distributed architecture—followed by concrete solutions such as unique business identifiers, database unique constraints, state‑machine control, and idempotent API design.

Distributed SystemsIdempotencybackend design
0 likes · 6 min read
How Alipay Ensures Payment Idempotency in High‑Concurrency Systems
Java Architect Handbook
Java Architect Handbook
Aug 18, 2026 · Backend Development

Why Misusing Spring Event Can Destroy Your Service Performance

The article analyzes common pitfalls of Spring Event—such as publishing during shutdown or early startup, unsuitability for strong‑consistency use cases, and the need for graceful shutdown, idempotent listeners, and extra reliability measures—while comparing it with message‑queue solutions.

IdempotencyPublish‑SubscribeSpring
0 likes · 12 min read
Why Misusing Spring Event Can Destroy Your Service Performance
SpringMeng
SpringMeng
Aug 18, 2026 · Operations

CFO’s No‑Code AI App Triggers a Month’s Server Bill in One Day

A CFO built a SaaS product in two days using Claude Code, but a missing database field caused the task queue’s automatic retries to re‑execute 21 LLM calls, turning a single day’s AI usage into a cost that exceeded the entire month’s server expenses.

AIDatabase MigrationIdempotency
0 likes · 11 min read
CFO’s No‑Code AI App Triggers a Month’s Server Bill in One Day
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 17, 2026 · Backend Development

RabbitMQ vs Kafka vs RocketMQ: Complete MQ Selection Guide with Code & Interview Answers

This article provides a comprehensive comparison of RabbitMQ, Kafka, and RocketMQ across core features, performance, and use cases, with production-ready code for transactional messaging, idempotent consumption, and zero-loss configurations, plus solutions for seven common production pitfalls and interview answer templates.

Distributed SystemsIdempotencyKafka
0 likes · 36 min read
RabbitMQ vs Kafka vs RocketMQ: Complete MQ Selection Guide with Code & Interview Answers
Ray's Galactic Tech
Ray's Galactic Tech
Aug 17, 2026 · Backend Development

From DB Row Locks to Redis + Lua: Evolving Flash‑Sale Inventory Deduction

The article walks through the evolution of a flash‑sale inventory‑deduction system, starting with simple database row‑locking SQL, exposing its scalability limits, and progressively adding transaction trimming, Redis pre‑deduction, Lua atomic scripts, async pipelines, idempotency, reconciliation and robust engineering practices to handle extreme concurrency.

AsyncProcessingHighConcurrencyIdempotency
0 likes · 40 min read
From DB Row Locks to Redis + Lua: Evolving Flash‑Sale Inventory Deduction
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 16, 2026 · Backend Development

Designing Robust External APIs: RESTful, Security, Idempotency & Rate Limiting

This comprehensive guide covers production-grade external API design including RESTful conventions, unified response structures, security mechanisms (HMAC signatures, replay prevention), idempotency patterns, rate limiting, circuit breaking, version management, and monitoring—with practical Java/Spring code implementations and interview-focused technical deep-dives.

API SecurityAPI VersioningCircuit Breaking
0 likes · 31 min read
Designing Robust External APIs: RESTful, Security, Idempotency & Rate Limiting
Ray's Galactic Tech
Ray's Galactic Tech
Aug 16, 2026 · Backend Development

Ditch Seata: Build a Production‑Ready SAGA Orchestrator with a 500‑Line Java State Machine

This article shows how to replace heavyweight distributed‑transaction frameworks such as Seata with a lightweight, production‑grade SAGA orchestrator built from a Java state machine, MySQL persistence and Spring Boot, covering architecture, state‑machine design, database schema, core orchestration logic, recovery, exception handling and practical deployment tips.

IdempotencyJavaSaga
0 likes · 46 min read
Ditch Seata: Build a Production‑Ready SAGA Orchestrator with a 500‑Line Java State Machine
Xike
Xike
Aug 16, 2026 · Backend Development

Idempotency Strategies for APIs: Preventing Duplicate Submissions

The article analyzes why network timeouts, client retries, user double‑clicks, and at‑least‑once MQ delivery cause duplicate intents, then details five practical idempotency techniques—conditional updates, unique constraints, Idempotency‑Key tokens, state machines with optimistic locks, and distributed locks—along with their trade‑offs and monitoring tips.

APIDistributed SystemsIdempotency
0 likes · 11 min read
Idempotency Strategies for APIs: Preventing Duplicate Submissions
Thought Artisan
Thought Artisan
Aug 16, 2026 · Artificial Intelligence

Designing Production-Grade AI Agents: Fault Tolerance, Recovery, and Idempotency Patterns

This article presents a systematic approach to building reliable AI agents by classifying faults into API, tool, context, and control-flow layers, detailing detection mechanisms like repeat-call fingerprints and watchdogs, and outlining recovery strategies including exponential backoff, model cascade degradation, tool-error virtualization, and idempotent pre-check-confirm patterns to prevent death spirals and ensure safe retries.

AI agentsError RecoveryFault Tolerance
0 likes · 10 min read
Designing Production-Grade AI Agents: Fault Tolerance, Recovery, and Idempotency Patterns
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 14, 2026 · Backend Development

API Flood Protection: Emergency Mitigation, Multi-Layer Defense & Rate Limiting Algorithms

This article provides a comprehensive guide to handling API abuse, covering emergency mitigation within three minutes, a multi-layer defense architecture, comparison of four rate limiting algorithms, practical implementations using Redis+Lua token bucket, Sentinel, and Guava Bloom filter, cache protection strategies, idempotency design, and a simulated interview scenario with code examples for distributed rate limiting and replay attack prevention.

API protectionBloom filterDistributed Systems
0 likes · 28 min read
API Flood Protection: Emergency Mitigation, Multi-Layer Defense & Rate Limiting Algorithms
Ray's Galactic Tech
Ray's Galactic Tech
Aug 14, 2026 · Backend Development

Payment Callback After Order Cancellation? 3 Consistency Challenges and Practical Engineering Solutions

The article examines why payment callbacks that arrive later than order cancellations cause money‑in‑order‑canceled anomalies, outlines the three core eventual‑consistency problems—message ordering, duplicate consumption, and message loss—and presents a complete engineering solution using business idempotency keys, a transactional outbox, state‑machine handling, and reconciliation compensation.

Distributed SystemsIdempotencyKafka
0 likes · 35 min read
Payment Callback After Order Cancellation? 3 Consistency Challenges and Practical Engineering Solutions