Skip to content
Tagged articles

Idempotency

417 articles · Page 2 of 5
Data Bricklaying Diary
Data Bricklaying Diary
Aug 14, 2026 · Artificial Intelligence

Action ≠ API: Designing Business Execution Contracts for Enterprise Agents

This article explains why ontology Actions are not mere API wrappers but business execution contracts that bind semantics, decisions, evidence, permissions, idempotency, compensation, and audit receipts, detailing four Action forms, five boundary categories, common misconceptions, and a six-step implementation approach for enterprise agents.

Enterprise AgentIdempotencyMCP
0 likes · 20 min read
Action ≠ API: Designing Business Execution Contracts for Enterprise Agents
Ray's Galactic Tech
Ray's Galactic Tech
Aug 13, 2026 · Backend Development

Event Sourcing Primer: Rebuilding State Without a Database

This article explains how event sourcing replaces the traditional current‑state table with an immutable event log, allowing systems to reconstruct any state, handle concurrency, support auditing, and power flexible read models through projections, while outlining the necessary architectural components such as aggregates, event stores, snapshots, outbox, idempotency, and the natural transition to CQRS.

Backend ArchitectureCQRSIdempotency
0 likes · 32 min read
Event Sourcing Primer: Rebuilding State Without a Database
Niu Liu
Niu Liu
Aug 12, 2026 · Backend Development

WeChat Pay Service Provider: Entity-First Payment Routing for Multi-Store Systems

This article details a production-grade WeChat Pay service provider integration for multi-store, multi-entity scenarios, covering domain modeling, versioned payment routing, sub-merchant onboarding state machines, cashier configuration layers, callback verification, refund snapshot isolation, three-level reconciliation, and a 10-item launch checklist.

APIv3Cashier ConfigurationIdempotency
0 likes · 28 min read
WeChat Pay Service Provider: Entity-First Payment Routing for Multi-Store Systems
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 11, 2026 · Backend Development

Prevent Duplicate Orders: 4-Layer Idempotency Defense with Redis Tokens, DB Constraints & AOP

This article details a comprehensive four-layer strategy to prevent duplicate order submissions, covering frontend interception, distributed token mechanisms with Redis atomic operations, database unique constraints as ultimate fallback, scheduled reconciliation, and a reusable AOP-based annotation for zero-intrusion idempotency in Spring Boot applications.

AOPIdempotencySpring Boot
0 likes · 24 min read
Prevent Duplicate Orders: 4-Layer Idempotency Defense with Redis Tokens, DB Constraints & AOP
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 10, 2026 · Backend Development

Distributed Transactions: Theory, Seata AT/TCC, RocketMQ & Pitfalls Explained

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
0 likes · 35 min read
Distributed Transactions: Theory, Seata AT/TCC, RocketMQ & Pitfalls Explained
liandk
liandk
Aug 8, 2026 · Backend Development

Fixing MQ’s Four Major Issues: Loss, Duplication, Backlog, and Out‑of‑Order Messages

The article explains how to build a production‑grade MQ architecture by addressing the four critical pitfalls—message loss, duplicate consumption, backlog, and out‑of‑order delivery—through producer ACK retries, persistent storage, manual ACKs, idempotent business logic, dead‑letter queues, consumer scaling, and partitioned ordering.

Dead Letter QueueIdempotencyMQ
0 likes · 7 min read
Fixing MQ’s Four Major Issues: Loss, Duplication, Backlog, and Out‑of‑Order Messages
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 6, 2026 · Backend Development

MQ Duplicate Consumption: Three Idempotency Patterns with Code & Pitfalls

This article explains why MQ duplicate consumption occurs due to ACK loss, and details three idempotency solutions—database unique index, Redis atomic operations, and business state machines—with code examples, comparison tables, production pitfalls like race conditions and transaction boundaries, best practices, and interview-focused implementation insights.

Distributed SystemsIdempotencyMQ
0 likes · 24 min read
MQ Duplicate Consumption: Three Idempotency Patterns with Code & Pitfalls
Xiaolin Talks Programming
Xiaolin Talks Programming
Aug 6, 2026 · Backend Development

Spring Boot + Quartz: Production-Grade Scheduling with Dynamic Control, Cluster HA & Misfire Handling

This guide details building a production-grade Spring Boot Quartz scheduler covering JDBC persistence, cluster coordination via database locks, misfire policies, dynamic job management, execution logging via JobListener, idempotency patterns, monitoring metrics, and troubleshooting common pitfalls like transaction boundaries and clock drift.

ClusterIdempotencyPerformance Tuning
0 likes · 20 min read
Spring Boot + Quartz: Production-Grade Scheduling with Dynamic Control, Cluster HA & Misfire Handling
Data Bricklaying Diary
Data Bricklaying Diary
Aug 6, 2026 · Artificial Intelligence

From Ontology Semantics to Ontology Intelligence: Why Understanding Business ≠ Driving It

The article distinguishes ontology semantics (AI understanding business objects, states, rules) from ontology intelligence (explainable decisions, contract-constrained actions, auditable loops), outlining seven engineering capabilities needed to close the loop and emphasizing a minimal viable loop around high-value decisions.

Agent RuntimeDecision LayerGovernance
0 likes · 16 min read
From Ontology Semantics to Ontology Intelligence: Why Understanding Business ≠ Driving It
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Aug 5, 2026 · Backend Development

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

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

Distributed SystemsIdempotencyLocal Event Table
0 likes · 12 min read
Domain Event Reliability & Eventual Consistency: Production-Ready DDD Event-Driven Patterns
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 5, 2026 · Backend Development

MQ Ordered Consumption: Partial Order Patterns, Code Examples & Interview Guide

This article explains how to guarantee message ordering in message queues by comparing RocketMQ, Kafka, and RabbitMQ implementations, detailing partial ordering via business key hashing, providing production-ready code for producers and consumers, and covering business-level safeguards like state machines and idempotency to handle queue rebalancing and head-of-line blocking.

Head-of-line BlockingIdempotencyKafka
0 likes · 25 min read
MQ Ordered Consumption: Partial Order Patterns, Code Examples & Interview Guide
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 4, 2026 · Backend Development

MQ Message Backlog Crisis: 3-Phase Production Survival Guide (Mitigate → Diagnose → Prevent)

This article presents a three-phase framework for handling MQ message backlogs in production: immediate mitigation via consumer scaling, business degradation, and message dumping; systematic root cause analysis across producer, broker, and consumer layers; and long-term prevention through traffic control, async processing, monitoring, and automated dead-letter handling, with RocketMQ code examples.

Batch ConsumptionDead Letter QueueIdempotency
0 likes · 32 min read
MQ Message Backlog Crisis: 3-Phase Production Survival Guide (Mitigate → Diagnose → Prevent)
Data Integration and Governance
Data Integration and Governance
Jul 31, 2026 · Operations

Ensuring Data Sync Is No‑Duplicate, No‑Loss, Accurate – Full‑Load, Incremental, Validation, Exception Handling

The article explains why reliable data synchronization must answer three questions—preventing duplicates, avoiding missing data, and preserving correct content—and details practical solutions for full‑load and incremental sync, idempotent writes, CDC, handling late, out‑of‑order and breakpoint failures, multi‑layer validation, and categorized exception recovery.

CDCIdempotencydata synchronization
0 likes · 15 min read
Ensuring Data Sync Is No‑Duplicate, No‑Loss, Accurate – Full‑Load, Incremental, Validation, Exception Handling
Cloud Architecture
Cloud Architecture
Jul 26, 2026 · Backend Development

Seckill System Architecture: 7 Core Design Strategies for High-Concurrency Sales

This article presents a comprehensive, step‑by‑step analysis of building a flash‑sale (seckill) system that can survive instant traffic spikes, detailing seven essential design ideas such as static page delivery, token gating, Redis atomic decrement, asynchronous queuing, multi‑layer rate limiting, service isolation, idempotent processing, and end‑to‑end monitoring and recovery.

Distributed SystemsIdempotencyLua
0 likes · 28 min read
Seckill System Architecture: 7 Core Design Strategies for High-Concurrency Sales
Xiaolin Talks Programming
Xiaolin Talks Programming
Jul 24, 2026 · Backend Development

High-Availability Distributed Task Scheduling with Spring Boot & PowerJob: Production Hardening Guide

This guide shares a year of production experience migrating from basic @Scheduled to PowerJob for high-availability distributed task scheduling, covering Spring Boot integration, DAG workflow orchestration, MapReduce sharding, lease-based failover, JVM tuning, metadata DB protection, and idempotency patterns.

DAG WorkflowDistributed Task SchedulingHigh Availability
0 likes · 18 min read
High-Availability Distributed Task Scheduling with Spring Boot & PowerJob: Production Hardening Guide
LuTiao Programming
LuTiao Programming
Jul 24, 2026 · Backend Development

Why Scheduled Tasks Run Multiple Times in a Cluster – The Real Issue Isn’t Quartz but Poor Architecture

When a Java application that uses Spring’s @Scheduled moves from a single server to a cluster, the same job may execute on every node, causing duplicate orders, messages, and data; the article explains why this happens, examines common lock‑based fixes and their pitfalls, and proposes a robust, idempotent, sharded task architecture.

@ScheduledBackendIdempotency
0 likes · 15 min read
Why Scheduled Tasks Run Multiple Times in a Cluster – The Real Issue Isn’t Quartz but Poor Architecture
Ray's Galactic Tech
Ray's Galactic Tech
Jul 23, 2026 · Backend Development

How to Keep Billions of Order States In Order with RocketMQ’s Ordered Messaging

The article explains why order‑status updates can become out‑of‑order in high‑traffic systems, how RocketMQ’s ordered‑message feature guarantees per‑key sequencing while highlighting its trade‑offs, and provides concrete producer and consumer implementations, failure handling, scaling, and deployment guidelines to ensure reliable, idempotent order processing.

IdempotencyMessage QueueOrdered Messaging
0 likes · 27 min read
How to Keep Billions of Order States In Order with RocketMQ’s Ordered Messaging
Coder Life Journal
Coder Life Journal
Jul 20, 2026 · Backend Development

Redis Distributed Lock with Three Checks: Why Small Projects Should Rethink Its Use

The article analyzes Redis distributed locks—its three‑step verification, the limited guarantees it provides, and why small‑to‑medium projects should often prefer database constraints, idempotency keys, or state machines over adding a lock that introduces extra complexity and maintenance overhead.

Idempotencybackend developmentconcurrency-control
0 likes · 10 min read
Redis Distributed Lock with Three Checks: Why Small Projects Should Rethink Its Use
Cloud Architecture
Cloud Architecture
Jul 18, 2026 · Backend Development

RabbitMQ Idempotent Consumption: Keeping Duplicate Processing Within Business Limits

The article explains why RabbitMQ provides at‑least‑once delivery, how duplicate consumption arises in publish‑subscribe scenarios, and presents a step‑by‑step design—including deduplication keys, a deduplication table, transactional writes, proper ACK ordering, and a checklist of common pitfalls—to ensure idempotent processing stays within acceptable business tolerances.

Database TransactionIdempotencyJava
0 likes · 20 min read
RabbitMQ Idempotent Consumption: Keeping Duplicate Processing Within Business Limits
Ray's Galactic Tech
Ray's Galactic Tech
Jul 17, 2026 · Backend Development

Three Critical Guarantees for Message Queues: No Loss, No Duplicates, No Disorder – Deep Dive into Production‑Grade Solutions

This article dissects why modern systems must enforce three reliability guarantees—no message loss, no duplicate processing, and no out‑of‑order delivery—by examining real‑world order flows, outbox patterns, idempotent keys, partitioning strategies, consumer acknowledgments, and operational safeguards such as replay, dead‑letter handling, and monitoring.

Distributed SystemsIdempotencyKafka
0 likes · 28 min read
Three Critical Guarantees for Message Queues: No Loss, No Duplicates, No Disorder – Deep Dive into Production‑Grade Solutions
samdeepthink
samdeepthink
Jul 17, 2026 · Backend Development

Three Crucial Architecture Decisions for Building a Reliable Payment System

The article outlines three core architectural choices—channel isolation, a dedicated payment gateway, and robust callback handling with Redis and distributed locks—that together prevent a single payment channel failure from collapsing the entire payment platform.

Idempotencychannel isolationmicroservices
0 likes · 5 min read
Three Crucial Architecture Decisions for Building a Reliable Payment System
Xiaolin Talks Programming
Xiaolin Talks Programming
Jul 17, 2026 · Backend Development

Spring StateMachine in Production: Modeling, Redis Persistence & High-Concurrency Anti-Duplication Patterns

This article shares real-world experience using Spring StateMachine to replace sprawling if-else logic in order systems, covering state/event/guard modeling, Redis-backed persistence, a three-layer concurrency control pattern (distributed lock + optimistic lock + event idempotency), async decoupling, timeout handling, and compensation strategies with concrete code templates.

IdempotencyOptimistic LockRedis Persistence
0 likes · 17 min read
Spring StateMachine in Production: Modeling, Redis Persistence & High-Concurrency Anti-Duplication Patterns
Random Bulletin
Random Bulletin
Jul 16, 2026 · Backend Development

Task Queues at Ten‑Million QPS: From Synchronous Processing to Queue‑Based Architecture

The article explains how moving non‑critical actions in a high‑traffic e‑commerce order flow to a task queue separates core work from optional work, solving delivery guarantees, idempotency, backlog management, and ordering challenges while dramatically reducing latency and fault contagion.

Asynchronous ProcessingIdempotencyTask Queue
0 likes · 17 min read
Task Queues at Ten‑Million QPS: From Synchronous Processing to Queue‑Based Architecture
Xiaolin Talks Programming
Xiaolin Talks Programming
Jul 16, 2026 · Backend Development

CDC + Outbox Pattern: Production-Grade Cross-Database Sync with Spring Boot & Kafka

This article details a production-ready cross-database synchronization architecture using CDC and Outbox pattern with Spring Boot, Debezium, and Kafka, covering schema design, connector configuration, transaction boundaries, ordering guarantees, idempotent consumption, dead-letter queues, and monitoring strategies.

CDCCross-Database SyncData Consistency
0 likes · 20 min read
CDC + Outbox Pattern: Production-Grade Cross-Database Sync with Spring Boot & Kafka
Cloud Architecture
Cloud Architecture
Jul 14, 2026 · Backend Development

Building a Billion‑Message, Millisecond‑Scale Private Messaging System with Spring Boot, RabbitMQ & Redis

This article presents a production‑grade design for a social private‑messaging system that handles billions of messages with millisecond latency, detailing how MySQL serves as the message fact store, RabbitMQ provides low‑latency distribution, Redis manages online state and indexes, and Outbox plus idempotent consumption ensure reliability and ordering.

IdempotencyOutboxRabbitMQ
0 likes · 35 min read
Building a Billion‑Message, Millisecond‑Scale Private Messaging System with Spring Boot, RabbitMQ & Redis
Cloud Architecture
Cloud Architecture
Jul 13, 2026 · Backend Development

Production-Grade Payment System Guide: Java Implementation for Alipay & WeChat All-Channel Integration

This article explains why a payment system is more than a simple SDK integration, presents a four‑layer architecture (access, state, event, governance), details state machines, idempotent callbacks, outbox pattern, reconciliation, high‑concurrency handling, observability, security, and provides Java code examples for integrating Alipay and WeChat across all channels.

AlipayIdempotencyJava
0 likes · 29 min read
Production-Grade Payment System Guide: Java Implementation for Alipay & WeChat All-Channel Integration
Random Bulletin
Random Bulletin
Jul 13, 2026 · Backend Development

Why Simple Retry Triggers Avalanches and How Smart Strategies Save 10M‑QPS Systems

The article explains how a naïve ‘retry three times’ default can amplify a minor 200 ms latency spike into a full‑scale outage in a 10 million‑QPS system, and walks through a progressive design—from identifying retry‑eligible transient faults, adding exponential backoff with jitter, enforcing idempotency, applying token‑bucket retry budgets, integrating circuit breakers, to using hedged requests—showing how each layer prevents traffic amplification and ensures reliable high‑throughput services.

IdempotencyJitterbackoff
0 likes · 18 min read
Why Simple Retry Triggers Avalanches and How Smart Strategies Save 10M‑QPS Systems
Xiaolin Talks Programming
Xiaolin Talks Programming
Jul 13, 2026 · Backend Development

CQRS & Event Sourcing in Spring Boot: Read/Write Separation, Snapshots & Compensation

This guide details implementing CQRS and Event Sourcing in Spring Boot, covering command/query separation, event bus choices (Outbox pattern, Kafka), projection idempotency, state snapshots for performance, Saga-based compensation for distributed transactions, and practical tuning tips for production workloads.

CQRSEvent BusIdempotency
0 likes · 14 min read
CQRS & Event Sourcing in Spring Boot: Read/Write Separation, Snapshots & Compensation
ThinkingAgent
ThinkingAgent
Jul 10, 2026 · Artificial Intelligence

Securing AI Agents: L5 Tool Execution Layer – Sandboxes, MCP, and Execution Boundaries

The article analyzes two 2026 incidents where agents breached sandbox and permission boundaries, explains the L5 execution layer’s role in defining what agents can do, how to isolate code with microVM or gVisor sandboxes, enforce network and resource limits, and implement MCP‑based tool calls with strict access control and audit trails.

AI agentsIdempotencyMCP Protocol
0 likes · 26 min read
Securing AI Agents: L5 Tool Execution Layer – Sandboxes, MCP, and Execution Boundaries
IT Services Circle
IT Services Circle
Jul 4, 2026 · Operations

When a Non‑Engineer Deploys with Claude Code, a Hidden Bug Makes One Day of AI Cost a Month of Server Fees

A CFO used Claude Code to launch a SaaS product in two days, but a missing database field combined with an automatic retry mechanism caused a single day's AI API calls to generate costs equivalent to a whole month's server expenses, prompting a detailed post‑mortem on the root causes and preventive measures.

Claude CodeCloud OperationsDatabase Migration
0 likes · 10 min read
When a Non‑Engineer Deploys with Claude Code, a Hidden Bug Makes One Day of AI Cost a Month of Server Fees
Xiaolin Talks Programming
Xiaolin Talks Programming
Jul 2, 2026 · Backend Development

Building High-Reliability Message-Driven Architecture with Spring Boot: Preventing Loss, Duplicates & Backlogs

This article details production-hardened patterns for building reliable message-driven systems with Spring Boot, covering MQ selection, producer confirmations, local message tables, manual acknowledgment, retry with backoff, dead-letter queues, idempotency strategies, backlog monitoring, ordered messaging, distributed tracing, and JVM/OS tuning parameters.

Backpressure HandlingDead Letter QueueIdempotency
0 likes · 20 min read
Building High-Reliability Message-Driven Architecture with Spring Boot: Preventing Loss, Duplicates & Backlogs
Cloud Architecture
Cloud Architecture
Jun 30, 2026 · Backend Development

RocketMQ Transactional Messaging in Practice: From Half Message to Production‑Grade Consistency

The article analyses why sending a message is easy but guaranteeing end‑to‑end consistency across databases, brokers, networks and services is hard, explains the exact problems RocketMQ transactional messages solve, compares them with Outbox and CDC, and provides a complete production‑grade design, implementation, monitoring and tuning guide.

CDCConsistencyIdempotency
0 likes · 44 min read
RocketMQ Transactional Messaging in Practice: From Half Message to Production‑Grade Consistency
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 29, 2026 · Backend Development

4 Advanced Techniques for Designing Spring Boot Controllers

This article examines four common shortcomings in typical Spring Boot controller APIs—lack of idempotency, misuse of PUT for partial updates, missing optimistic concurrency control, and always returning full objects—and demonstrates concrete solutions using Idempotency-Key headers, PATCH with JsonMergePatch, ETag handling, and sparse field selection.

ControllerETagIdempotency
0 likes · 12 min read
4 Advanced Techniques for Designing Spring Boot Controllers
Coder Life Journal
Coder Life Journal
Jun 28, 2026 · Backend Development

Idempotency vs Duplicate Orders: 5 Reliable Solutions After a Double‑Charge Mishap

The article explains that idempotency prevents the same operation from being executed twice, illustrates a real double‑charge bug, evaluates five concrete approaches—including Redis check‑then‑set, DB unique index, optimistic lock, Redis distributed lock, and a message deduplication table—details their failure conditions and suitable scenarios, and recommends combining Redis lock with a database unique index for the most robust protection.

IdempotencyOptimistic Lockdatabase
0 likes · 10 min read
Idempotency vs Duplicate Orders: 5 Reliable Solutions After a Double‑Charge Mishap
Random Bulletin
Random Bulletin
Jun 26, 2026 · Operations

Message Duplication Is Inevitable: Building a Multi‑Layer Idempotency Middleware for Ten‑Million QPS

Message queues guarantee at‑least‑once delivery, making duplicate messages a normal feature; the article examines a real coupon‑distribution incident, critiques business‑level idempotency approaches, and outlines a layered platform‑wide middleware design—including unique keys, state machines, storage choices, and TTL strategies—to achieve reliable processing at ten‑million QPS scale.

Distributed SystemsIdempotencyMessage Queue
0 likes · 19 min read
Message Duplication Is Inevitable: Building a Multi‑Layer Idempotency Middleware for Ten‑Million QPS
Cloud Architecture
Cloud Architecture
Jun 24, 2026 · Backend Development

Spring Boot Alipay Integration: A Production-Ready Solution for High Concurrency and Financial Consistency

This article explains how to build a production‑grade Alipay payment subsystem with Spring Boot that goes beyond simple API calls, covering asynchronous flow, idempotent notification handling, state‑machine design, outbox event delivery, high‑concurrency safeguards, and end‑to‑end reconciliation.

AlipayIdempotencyOutbox
0 likes · 32 min read
Spring Boot Alipay Integration: A Production-Ready Solution for High Concurrency and Financial Consistency
ZhiKe AI
ZhiKe AI
Jun 23, 2026 · Backend Development

Duplicate Requests Aren’t Bugs: 5 Idempotency Solutions for Distributed Systems

When network timeouts or retries cause the same payment request to be processed multiple times, duplicate requests become a common failure mode in distributed systems; this article explains five practical idempotency strategies—unique DB indexes, token checks, state machines, Redis SETNX, and downstream dedup tables—and offers guidance on choosing the right approach.

BackendDistributed SystemsIdempotency
0 likes · 16 min read
Duplicate Requests Aren’t Bugs: 5 Idempotency Solutions for Distributed Systems
ZhiKe AI
ZhiKe AI
Jun 22, 2026 · Fundamentals

Message Queues: Power When Correct, Disaster When Wrong – 3 Scenarios & Tips

The article explains how message queues can dramatically improve response time, decouple services, and smooth traffic spikes, outlines seven advantages and eight drawbacks, and provides concrete guidelines on when to adopt them, how to prevent loss, duplication, and ordering issues, and how to ensure end‑to‑end reliability.

Asynchronous ProcessingIdempotencyKafka
0 likes · 15 min read
Message Queues: Power When Correct, Disaster When Wrong – 3 Scenarios & Tips
Xiaolin Talks Programming
Xiaolin Talks Programming
Jun 18, 2026 · Backend Development

Spring Boot Scheduled Tasks: Dynamic Cron & Cluster Duplicate Prevention

This article explores production-grade Spring Boot scheduled tasks, covering dynamic Cron hot-reloading via configuration listeners, cluster duplicate prevention using distributed locks, framework selection between Quartz and XXL-JOB, data sharding strategies, observability, timeout handling, and retry mechanisms with dead-letter queues.

Cluster Duplicate PreventionDynamic CronIdempotency
0 likes · 18 min read
Spring Boot Scheduled Tasks: Dynamic Cron & Cluster Duplicate Prevention
LuTiao Programming
LuTiao Programming
Jun 17, 2026 · Backend Development

Why Salesforce’s $3.6B AI Customer Service Bet Highlights the Real Opportunity for Java Back‑End Developers

The article explains how Salesforce’s $3.6 billion acquisition of Fin signals a shift from simple chatbot answers to AI agents that execute end‑to‑end business actions, and why Java/Spring Boot developers must expose secure, auditable services rather than merely wrapping large‑model APIs.

AI Customer ServiceAI agent architectureIdempotency
0 likes · 21 min read
Why Salesforce’s $3.6B AI Customer Service Bet Highlights the Real Opportunity for Java Back‑End Developers
Subtle Storm
Subtle Storm
Jun 15, 2026 · Backend Development

Caching, Rate Limiting, Smoothing, and Idempotency: Solving Concurrency Problems

The article breaks down how caching reduces repeated slow‑resource access, rate limiting protects systems from overload, smoothing (peak shaving) buffers burst traffic with queues, and idempotency prevents duplicate operations, using a milk‑tea shop analogy to illustrate each technique’s role in high‑concurrency environments.

BackendIdempotencyPeak Shaving
0 likes · 7 min read
Caching, Rate Limiting, Smoothing, and Idempotency: Solving Concurrency Problems
Random Bulletin
Random Bulletin
Jun 15, 2026 · Backend Development

From Auto to Manual: Mastering Consumer Offsets for Ten‑Million QPS Systems

The article examines a real payment loss incident caused by Kafka's default automatic offset commit, explains why automatic commits become a hidden trap at high traffic, and provides a step‑by‑step guide to switching to manual commits with async‑first, sync‑fallback, idempotency, dead‑letter handling, batch strategies, and concurrency controls for reliable ten‑million QPS consumption.

IdempotencyKafkaMessage Queue
0 likes · 15 min read
From Auto to Manual: Mastering Consumer Offsets for Ten‑Million QPS Systems
Java Architect Handbook
Java Architect Handbook
May 26, 2026 · Backend Development

How to Prevent Duplicate Consumption in RabbitMQ? 5 Practical Solutions for Interviews

The article explains why RabbitMQ may deliver the same message multiple times, emphasizes that business‑level idempotency is required, and compares five concrete deduplication approaches—unique message ID with a dedup table, database unique constraints, Redis SETNX, optimistic locking, and state‑machine design—detailing their implementation, suitable scenarios, and trade‑offs.

IdempotencyOptimistic LockRabbitMQ
0 likes · 13 min read
How to Prevent Duplicate Consumption in RabbitMQ? 5 Practical Solutions for Interviews
Linyb Geek Road
Linyb Geek Road
May 15, 2026 · Backend Development

8 Practical API Idempotency Solutions to Eliminate Duplicate Requests (Pitfall Guide)

The article explains the causes of duplicate requests in distributed systems, defines idempotency, and presents eight concrete implementation strategies—including token mechanisms, unique database indexes, optimistic and pessimistic locks, distributed locks, state machines, request serial numbers, and MQ‑based handling—each with code samples, advantages, drawbacks, and usage guidelines.

API designDistributed SystemsIdempotency
0 likes · 35 min read
8 Practical API Idempotency Solutions to Eliminate Duplicate Requests (Pitfall Guide)
Linyb Geek Road
Linyb Geek Road
May 15, 2026 · Backend Development

Idempotency in Practice: Handling the Same Key with Different Parameters

The article explains why simple key‑based idempotency fails when a second request carries different parameters, and demonstrates how to use database row locks, request fingerprinting, state machines, and explicit error handling to guarantee safe, non‑duplicate execution in payment‑critical APIs.

API designDistributed SystemsIdempotency
0 likes · 13 min read
Idempotency in Practice: Handling the Same Key with Different Parameters
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 13, 2026 · Backend Development

Beyond try‑catch: 3 Elegant Fault‑Tolerance Patterns Every Senior Developer Needs

The article explains why simple try‑catch is insufficient for production stability and introduces three advanced fault‑tolerance patterns—retry with exponential back‑off, circuit breaker using Resilience4j, and idempotency design—each illustrated with concrete Spring Boot 3.5.0 code examples and best‑practice guidelines.

IdempotencyResilience4jRetry
0 likes · 12 min read
Beyond try‑catch: 3 Elegant Fault‑Tolerance Patterns Every Senior Developer Needs
Java Tech Workshop
Java Tech Workshop
Apr 29, 2026 · Backend Development

Mastering SpringBoot Transactional Messaging for Distributed Consistency

This article explains how SpringBoot handles transactional messaging to achieve distributed data consistency, covering the concept of transaction messages, CAP theory, final consistency, and three practical implementations using a local message table, Kafka transactions, and RocketMQ, plus idempotency and compensation strategies.

CAP theoremDistributed ConsistencyIdempotency
0 likes · 17 min read
Mastering SpringBoot Transactional Messaging for Distributed Consistency
LuTiao Programming
LuTiao Programming
Apr 20, 2026 · Backend Development

Why Your REST API Gets Complaints? 4 Advanced Design Patterns Senior Engineers Use

Many developers think a REST API is complete after versioning, pagination, and validation, but real‑world production exposes hidden issues such as unsafe retries, concurrent updates, undocumented deprecations, and missing contracts; this article explains four senior‑engineer‑approved patterns—idempotency, optimistic locking, lifecycle management, and contract‑first design—to build APIs that survive production.

API Lifecycle ManagementIdempotencyOptimistic Locking
0 likes · 8 min read
Why Your REST API Gets Complaints? 4 Advanced Design Patterns Senior Engineers Use
Coder Trainee
Coder Trainee
Apr 14, 2026 · Operations

5 Production Nightmares in an Education Mini‑Program and How to Avoid Them

The author recounts five critical production incidents that crippleed an education mini‑program—Redis connection‑pool exhaustion, duplicate bookings, double refunds, mis‑firing no‑show jobs, and inventory oversell—detailing root causes, concrete fixes, and hard‑won lessons for building resilient backend services.

IdempotencyOptimistic LockSpring Boot
0 likes · 10 min read
5 Production Nightmares in an Education Mini‑Program and How to Avoid Them
Cloud Architecture
Cloud Architecture
Apr 12, 2026 · Backend Development

How to Build an Atomic‑Level RocketMQ Transactional Message Wrapper for Production

This article explains why traditional distributed transactions fail, then details the core principles, state flow, and practical Java/Spring Boot implementation of an atomic‑level RocketMQ transactional message wrapper, covering schema design, idempotency, high‑concurrency handling, monitoring, and deployment for production‑grade microservices.

IdempotencyJavaRocketMQ
0 likes · 39 min read
How to Build an Atomic‑Level RocketMQ Transactional Message Wrapper for Production
Architect Chen
Architect Chen
Mar 3, 2026 · Backend Development

Preventing Kafka Duplicate Consumption with Idempotent Design

This article explains practical strategies to avoid duplicate message consumption in Kafka, covering business idempotency with unique IDs, database or Redis deduplication tables, enabling producer idempotence, consumer-side checks, and Kafka's transaction-based exactly‑once semantics, along with their trade‑offs and suitable scenarios.

BackendIdempotencyKafka
0 likes · 4 min read
Preventing Kafka Duplicate Consumption with Idempotent Design
Architect
Architect
Feb 23, 2026 · Backend Development

Why OpenClaw’s Control Plane Uses a Two‑Phase Protocol and runId for Reliable Agent Jobs

The article explains how OpenClaw’s control plane guarantees reliable, idempotent, and observable agent execution by enforcing a two‑phase protocol, strict handshake, role‑based authorization, layered deduplication, gap‑recovery mechanisms, and schema‑driven validation, turning a simple message flow into a production‑grade job system.

BackendIdempotencyOpenClaw
0 likes · 20 min read
Why OpenClaw’s Control Plane Uses a Two‑Phase Protocol and runId for Reliable Agent Jobs
ITPUB
ITPUB
Feb 11, 2026 · Backend Development

How to Guarantee Zero Message Loss in MQ Systems: A Full‑Lifecycle Design

This guide explains why guaranteeing 100% message reliability in MQ is a critical system‑design interview topic and presents a three‑layer architecture—production, storage, and consumption—detailing ACK settings, local message tables, broker replication, leader election safeguards, manual offset commits, and idempotent processing to prevent any message loss.

Distributed SystemsIdempotencyKafka
0 likes · 11 min read
How to Guarantee Zero Message Loss in MQ Systems: A Full‑Lifecycle Design
Ray's Galactic Tech
Ray's Galactic Tech
Jan 18, 2026 · Backend Development

Designing a Robust Transaction System: From Domain Modeling to Distributed Consistency

This article explores how to build a reliable, scalable transaction module for e‑commerce and finance, covering business requirement analysis, domain modeling, state‑machine design, layered microservice architecture, order creation and payment flows, idempotency, anti‑oversell mechanisms, performance tuning, monitoring, and evolution strategies.

BackendDistributed ConsistencyIdempotency
0 likes · 10 min read
Designing a Robust Transaction System: From Domain Modeling to Distributed Consistency
LuTiao Programming
LuTiao Programming
Jan 8, 2026 · Backend Development

Spring Boot Advanced Trick: Proper Way to Make RequestBody Readable Multiple Times

The article explains why Spring Boot's RequestBody can only be read once due to servlet stream constraints, and provides a complete solution using a custom HttpServletRequestWrapper and a high‑priority filter to cache and replay the body for annotations, validation, logging and other pre‑processing steps.

HttpServletRequestWrapperIdempotencyJava
0 likes · 8 min read
Spring Boot Advanced Trick: Proper Way to Make RequestBody Readable Multiple Times
Ray's Galactic Tech
Ray's Galactic Tech
Dec 20, 2025 · Backend Development

Production-Ready Idempotency for RocketMQ Duplicate Consumption (Full Code)

To reliably handle RocketMQ's at-least-once delivery semantics, this guide explains why duplicate consumption is inevitable, outlines three defensive layers—Redis‑based idempotency, database unique constraints, and state‑machine checks—provides production‑grade Java code, and details ACK/retry strategies and monitoring practices for robust systems.

IdempotencyJavaRocketMQ
0 likes · 9 min read
Production-Ready Idempotency for RocketMQ Duplicate Consumption (Full Code)
Java Companion
Java Companion
Nov 27, 2025 · Backend Development

Interview Question: How to Handle a Crashed Scheduled‑Task Server? Most Miss It

When a scheduled‑task server crashes, simply restarting it is insufficient; a robust solution must combine clustering, distributed locks, idempotent designs, checkpointing, and monitoring to ensure tasks resume correctly across non‑runtime and runtime failures, as detailed with SpringTask‑Redis and XXL‑JOB implementations.

BackendIdempotencySpringTask
0 likes · 28 min read
Interview Question: How to Handle a Crashed Scheduled‑Task Server? Most Miss It
Architect's Guide
Architect's Guide
Nov 12, 2025 · Backend Development

Four Practical Ways to Ensure Idempotency in High‑Traffic APIs

To prevent duplicate operations caused by network glitches, user errors, or retries, this article explains four common idempotency strategies—token, database unique index, distributed lock, and request payload hashing—providing clear concepts, key considerations, and ready‑to‑copy Java/Spring code examples.

Idempotencydatabase-indexdistributed-lock
0 likes · 9 min read
Four Practical Ways to Ensure Idempotency in High‑Traffic APIs
Architect
Architect
Nov 10, 2025 · Backend Development

How to Build Secure, Idempotent APIs: Keys, Tokens, and Anti‑Replay Strategies

This article explains how to design secure and reliable APIs for third‑party integration by covering API key generation, AK/SK authentication, callback URLs, permission models, token mechanisms, signature creation, replay‑attack prevention, HTTPS encryption, rate limiting, logging, data masking, idempotency, versioning, standardized response formats and documentation tools.

API designAuthenticationIdempotency
0 likes · 28 min read
How to Build Secure, Idempotent APIs: Keys, Tokens, and Anti‑Replay Strategies
Top Architect
Top Architect
Nov 9, 2025 · Backend Development

Mastering Idempotency: 4 Proven Techniques for Reliable Backend Operations

This article explains four common idempotency strategies—token, database unique index, distributed lock, and request‑body digest—detailing their core ideas, key concepts, and providing ready‑to‑copy Spring/Redis code examples to prevent duplicate requests in high‑traffic backend systems.

IdempotencySpringUnique Index
0 likes · 10 min read
Mastering Idempotency: 4 Proven Techniques for Reliable Backend Operations
Architect
Architect
Nov 7, 2025 · Backend Development

Mastering Idempotency: 4 Proven Strategies for Reliable APIs

This article explains four practical idempotency solutions—token tokens, database unique indexes, distributed locks, and request content digests—detailing their concepts, core keywords, and providing ready‑to‑copy Spring Boot code examples, along with implementation tips and a comparison table to help you choose the right approach for high‑concurrency APIs.

IdempotencySpring Bootdatabase-index
0 likes · 10 min read
Mastering Idempotency: 4 Proven Strategies for Reliable APIs
Top Architect
Top Architect
Oct 30, 2025 · Backend Development

How to Prevent Duplicate Submissions in Java APIs with Redis and Redisson

This article explains the concept of debounce for backend APIs, identifies which endpoints need it, and provides two distributed solutions—shared Redis cache and Redisson lock—complete with annotations, key generation logic, code examples, testing results, and tips for achieving true idempotency.

IdempotencyJavabackend development
0 likes · 16 min read
How to Prevent Duplicate Submissions in Java APIs with Redis and Redisson
Architect-Kip
Architect-Kip
Oct 28, 2025 · Operations

Mastering Failure Recovery: Fast‑Fail, Auto‑Retry, and Resilience Patterns for Distributed Systems

This guide outlines core principles and practical solutions for building resilient backend systems, covering fast‑failure handling, automatic retries with exponential back‑off, circuit‑breaker usage, idempotency, batch job strategies, online transaction patterns, and robust message‑queue processing.

IdempotencyMessage Queuebatch processing
0 likes · 17 min read
Mastering Failure Recovery: Fast‑Fail, Auto‑Retry, and Resilience Patterns for Distributed Systems
Ubiquitous Tech
Ubiquitous Tech
Oct 15, 2025 · Backend Development

Java Interview Simulation: Solving the Architecture Challenges of a Hotel Pricing System

This article walks through a detailed Java interview simulation where the candidate designs a high‑throughput hotel pricing service, covering business decomposition, Kafka event‑driven pipelines, cache‑aside consistency, HikariCP tuning, fault‑tolerant microservices, multi‑region disaster recovery, and AI recommendation gray‑release strategies.

IdempotencyJavaKafka
0 likes · 43 min read
Java Interview Simulation: Solving the Architecture Challenges of a Hotel Pricing System
Tech Freedom Circle
Tech Freedom Circle
Sep 24, 2025 · Backend Development

Designing a US Presidential Election Voting System: 1M TPS, 10M QPS, Immutable and Non‑Duplicate Votes

This article presents a comprehensive architectural design for a high‑throughput US presidential voting platform that must handle 1 million transactions per second and 10 million queries per second while guaranteeing vote immutability, one‑person‑one‑vote enforcement, real‑time result aggregation, and scalable storage using microservices, Kafka, Redis, Bloom filters, and blockchain anchoring.

BlockchainBloom filterDistributed Systems
0 likes · 32 min read
Designing a US Presidential Election Voting System: 1M TPS, 10M QPS, Immutable and Non‑Duplicate Votes
Architecture Digest
Architecture Digest
Sep 19, 2025 · Backend Development

Mastering Message Idempotency: From Simple Checks to State‑Machine Solutions

This article explores the challenges of duplicate message consumption in distributed systems, explains why naive de‑duplication fails under high concurrency, and presents four progressively robust idempotency strategies—from database pessimistic locks and local message tables to a state‑machine approach with Redis or MySQL, highlighting their trade‑offs.

Distributed SystemsIdempotencyMessage Queue
0 likes · 11 min read
Mastering Message Idempotency: From Simple Checks to State‑Machine Solutions
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 21, 2025 · Backend Development

Mastering Idempotent Payment APIs: From Pitfalls to Distributed‑Lock Solutions

This article walks through the evolution of a payment API’s idempotency design—from an initially flawed implementation, through naive Redis deduplication and token‑based approaches, to a robust solution that combines distributed locks, double‑checked caching, and state management for reliable, concurrent processing.

IdempotencySpringdistributed-lock
0 likes · 13 min read
Mastering Idempotent Payment APIs: From Pitfalls to Distributed‑Lock Solutions
Su San Talks Tech
Su San Talks Tech
Jul 13, 2025 · Backend Development

8 Proven Retry Strategies to Prevent Costly Failures in Distributed Systems

Discover why improper retry logic can cause massive financial losses, learn eight practical retry solutions—from simple loops to advanced Resilience4j and distributed lock techniques—and see how to avoid retry storms, ensure idempotency, and protect resources in high‑traffic backend services.

Distributed SystemsIdempotencyResilience
0 likes · 13 min read
8 Proven Retry Strategies to Prevent Costly Failures in Distributed Systems
Su San Talks Tech
Su San Talks Tech
Jul 11, 2025 · Backend Development

Mastering Idempotency in Java Microservices: 6 Proven Strategies

This article explains the concept of idempotency in Java backend services, why it is essential for reliable microservice interactions, and presents six practical implementation schemes—including unique indexes, token mechanisms, pessimistic and optimistic locks, distributed locks, and state‑machine constraints—along with code examples and integration tips for Spring Boot projects.

Idempotencydatabasedistributed-systems
0 likes · 21 min read
Mastering Idempotency in Java Microservices: 6 Proven Strategies
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 9, 2025 · Backend Development

How to Prevent Duplicate Consumption in Kafka: Practical Strategies

This article explains why Kafka’s at‑least‑once delivery can cause duplicate message processing, outlines the business risks of such duplicates, and presents four practical solutions—including idempotent design, manual offset commits, exactly‑once semantics, and dead‑letter queues—to ensure reliable consumption.

Dead Letter QueueIdempotencyKafka
0 likes · 6 min read
How to Prevent Duplicate Consumption in Kafka: Practical Strategies
Big Data Technology Tribe
Big Data Technology Tribe
Jul 9, 2025 · Backend Development

Mastering Idempotency: Design Patterns & Best Practices for Reliable Distributed Systems

This comprehensive guide explains the concept of idempotency, why it is essential in distributed and micro‑service architectures, and provides practical patterns, code examples, and best‑practice recommendations for HTTP, databases, messaging, caching, and service‑mesh implementations.

BackendDesign PatternsDistributed Systems
0 likes · 21 min read
Mastering Idempotency: Design Patterns & Best Practices for Reliable Distributed Systems
Architecture & Thinking
Architecture & Thinking
Jun 30, 2025 · Backend Development

Mastering RocketMQ Retry: Producer & Consumer Strategies for Reliable Messaging

This article deeply explores Apache RocketMQ's retry mechanisms, detailing producer and consumer retry strategies, flow control handling, dead‑letter queue management, advanced configurations, best practices, and comparisons with Kafka and RabbitMQ, providing practical code examples and monitoring recommendations for building highly reliable distributed systems.

Dead Letter QueueDistributed SystemsIdempotency
0 likes · 8 min read
Mastering RocketMQ Retry: Producer & Consumer Strategies for Reliable Messaging
Architect
Architect
Jun 22, 2025 · Backend Development

Mastering Idempotency: Ensure Reliable Operations in Distributed Systems

Idempotency ensures that repeated service calls or user actions produce the same effect without unintended side effects, a critical concern in distributed and microservice architectures; this article explains its principles, SQL examples, HTTP semantics, token strategies, lock handling, and message‑queue solutions.

IdempotencyMessage Queuetoken
0 likes · 13 min read
Mastering Idempotency: Ensure Reliable Operations in Distributed Systems
Java Tech Enthusiast
Java Tech Enthusiast
Jun 3, 2025 · Backend Development

Understanding the TCC (Try‑Confirm‑Cancel) Pattern for Distributed Transactions in Microservices

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.

IdempotencyTCCbackend development
0 likes · 8 min read
Understanding the TCC (Try‑Confirm‑Cancel) Pattern for Distributed Transactions in Microservices
Su San Talks Tech
Su San Talks Tech
May 30, 2025 · Backend Development

How to Build Secure, Reliable API Controllers: Signatures, Encryption, Rate Limiting and More

This article explains how to design robust API controller interfaces by covering signature verification, RSA encryption, IP whitelisting, rate limiting, parameter validation, unified response formats, exception handling, request logging, idempotency, record limits, stress testing, asynchronous processing, data masking, and comprehensive documentation.

API designBackendIdempotency
0 likes · 15 min read
How to Build Secure, Reliable API Controllers: Signatures, Encryption, Rate Limiting and More
Java Architect Essentials
Java Architect Essentials
May 20, 2025 · Backend Development

Ensuring Idempotency with Distributed Locks: Adjusting Aspect Order in Java Backend

This article explains how using a custom @DistributeLock annotation together with @Transactional can cause idempotency issues due to aspect execution order, and demonstrates how to prioritize the lock aspect using @Order to ensure the lock is applied before the transaction, with code examples and best‑practice recommendations.

Aspect OrderIdempotencyJava
0 likes · 6 min read
Ensuring Idempotency with Distributed Locks: Adjusting Aspect Order in Java Backend
Java Tech Enthusiast
Java Tech Enthusiast
May 17, 2025 · Backend Development

How to Implement Distributed API Debounce in Java with Redis and Redisson

This article explains why API debounce is needed in web back‑ends, identifies the types of endpoints that require it, outlines how to detect duplicate requests, and provides two concrete distributed solutions—shared Redis cache and Redisson lock—complete with annotation design, key generation logic, and full Java code examples.

API DebounceIdempotencyJava
0 likes · 15 min read
How to Implement Distributed API Debounce in Java with Redis and Redisson
JD Tech
JD Tech
Apr 27, 2025 · Backend Development

A Lightweight Mock/Spy Tool for Data Consistency in RPC Timeout Scenarios

The article analyzes data‑consistency challenges caused by RPC timeouts, especially when interfaces lack idempotency or idempotency fails, and presents a lightweight mock/spy utility that can intercept, mock, or spy on service calls to quickly restore consistency in distributed systems.

Data ConsistencyIdempotencyMock
0 likes · 11 min read
A Lightweight Mock/Spy Tool for Data Consistency in RPC Timeout Scenarios
IT Services Circle
IT Services Circle
Apr 18, 2025 · Backend Development

Preventing Duplicate Orders under 100k QPS: Full‑Stack Strategies

This article explains how to prevent duplicate orders in a high‑traffic system handling 100,000 QPS by combining frontend safeguards such as button disabling and token mechanisms with backend techniques including NGINX rate limiting, gateway token validation, idempotent database design, sharding, distributed locks, optimistic locking, and comprehensive logging and monitoring.

Idempotencybackend designdistributed-lock
0 likes · 7 min read
Preventing Duplicate Orders under 100k QPS: Full‑Stack Strategies
FunTester
FunTester
Apr 13, 2025 · Frontend Development

Mastering Timed Tasks in Chrome Extensions: From Persistent Background to On‑Demand Execution

This guide explains how to implement reliable scheduled tasks in Chrome extensions under Manifest V3, covering the shift from persistent background scripts to service workers, three practical approaches—including chrome.alarms, content script timers, and event‑driven simulations—plus best‑practice tips for idempotency, logging, and state persistence.

Chrome extensionIdempotencyServer Push
0 likes · 12 min read
Mastering Timed Tasks in Chrome Extensions: From Persistent Background to On‑Demand Execution
Java Tech Enthusiast
Java Tech Enthusiast
Apr 11, 2025 · Backend Development

Ensuring Message Processing Once in High-Concurrency Scenarios

The article explains how to guarantee that messages are processed only once in high‑concurrency environments by combining production‑side idempotent publishing, broker‑level deduplication with unique IDs, and consumption‑side business idempotency such as database constraints or distributed locks, while also recommending monitoring, metrics, and reconciliation as safety nets.

Distributed SystemsIdempotencyRocketMQ
0 likes · 6 min read
Ensuring Message Processing Once in High-Concurrency Scenarios
Java Backend Full-Stack
Java Backend Full-Stack
Mar 18, 2025 · Backend Development

18 Essential Practices for Designing Robust Backend APIs

The article outlines eighteen critical considerations for designing backend interfaces, ranging from documentation format and unified parameter schemas to encryption, idempotency, versioning, and monitoring, providing interview-ready insights that can impress hiring managers.

API designBackendIdempotency
0 likes · 5 min read
18 Essential Practices for Designing Robust Backend APIs
Su San Talks Tech
Su San Talks Tech
Mar 14, 2025 · Backend Development

Ensuring Idempotency in Distributed Systems: Patterns, Code, and Best Practices

This article explains the concept of idempotency, outlines scenarios where it is essential, analyzes common causes of idempotency problems, and presents a comprehensive set of solutions—including unique constraints, optimistic and pessimistic locks, distributed locks, token mechanisms, state machines, deduplication tables, and global request IDs—accompanied by practical code examples and database design guidelines.

BackendDistributed SystemsIdempotency
0 likes · 14 min read
Ensuring Idempotency in Distributed Systems: Patterns, Code, and Best Practices
Senior Tony
Senior Tony
Feb 1, 2025 · Backend Development

How to Eliminate Duplicate and Missed Messages in Kafka Consumers

This article explains Kafka's push/pull consumption models, the impact of enable.auto.commit and auto.commit.interval.ms on offset handling, and presents practical configurations and code patterns plus MySQL and Redis based deduplication techniques to prevent both duplicate and missing message processing.

IdempotencyMessage Queueduplicate consumption
0 likes · 8 min read
How to Eliminate Duplicate and Missed Messages in Kafka Consumers
Programmer XiaoFu
Programmer XiaoFu
Dec 26, 2024 · Backend Development

Avoid Misusing Spring Event: 6 Hard‑Earned Best Practices from a Real‑World Failure

The article recounts a production incident caused by improper use of Spring Event, explains why graceful shutdown, correct startup timing, suitable business scenarios, and reliability measures such as retries and idempotency are essential, and presents six concrete best‑practice recommendations to prevent similar failures.

IdempotencyKafkaRetry
0 likes · 11 min read
Avoid Misusing Spring Event: 6 Hard‑Earned Best Practices from a Real‑World Failure