Switching to BigDecimal resolves production issue

At first I thought🤔do we really need transactions????? I mean, if the code runs fine, why add extra complexity? But then it hit me… what happens when half your operation succeeds and the other half fails? That’s where Transaction Management in Spring Boot becomes non-negotiable. Here’s what I explored 👇 🔷 @Transactional Annotation Creates a boundary where all operations either fully complete or fully rollback—ensuring data consistency. 🔷 ACID Properties in Action ✔ Atomicity – all or nothing ✔ Consistency – valid state always ✔ Isolation – transactions don’t interfere ✔ Durability – once committed, always saved 🔷 Automatic Rollback Spring intelligently rolls back changes on runtime exceptions—saving your database from inconsistent states. 🔷 Propagation Defines how transactions behave when methods call each other: ✔ REQUIRED – joins existing transaction or creates a new one ✔ REQUIRES_NEW – always starts a new transaction (suspends current) ✔ SUPPORTS – runs with or without a transaction ✔ MANDATORY – must run inside an existing transaction ✔ NEVER – throws error if a transaction exists 🔷 Isolation Levels Prevents issues like dirty reads, non-repeatable reads, and phantom reads. 💡 What changed my perspective: Transactions aren’t about making code work—they’re about making sure it never leaves your system in a broken state. A single annotation @Transactional: quietly ensures data integrity across your entire application. That’s powerful.🔥 #Java #SpringBoot #BackendDevelopment #Transactions #SoftwareEngineering #LearningJourney #Spring #Data #DatabaseManagement #Coding

𝗪𝗲 𝗯𝘂𝗶𝗹𝘁 𝟰𝟵 𝗔𝗜 𝘀𝗸𝗶𝗹𝗹𝘀 𝗮𝘁 𝗡𝗶𝗹𝘂𝘀. 𝗡𝗼𝗻𝗲 𝗼𝗳 𝘁𝗵𝗲𝗺 𝘄𝗿𝗶𝘁𝗲 𝗰𝗼𝗱𝗲.  𝘍𝘢𝘪𝘳 𝘸𝘢𝘳𝘯𝘪𝘯𝘨: 𝘶𝘯𝘢𝘣𝘢𝘴𝘩𝘦𝘥 𝘴𝘦𝘭𝘧-𝘱𝘳𝘰𝘮𝘰𝘵𝘪𝘰𝘯. 𝘐'𝘮 𝘱𝘳𝘰𝘶𝘥 𝘰𝘧 𝘵𝘩𝘪𝘴 𝘸𝘰𝘳𝘬 𝘢𝘯𝘥 𝘐'𝘮 𝘮𝘪𝘭𝘬𝘪𝘯𝘨 𝘺𝘰𝘶 𝘧𝘰𝘳 𝘭𝘪𝘬𝘦𝘴.   Nilus builds AI-agentic treasury management — forecast, reconciliation, payments across currencies and ERPs.  Our engineering team runs on Claude Code. Over the past few months, Boris Churzin and I have been encoding our team's hard-won investigation patterns into structured playbooks that the agent actually follows. Not documentation. Not a wiki. Executable knowledge.  The breakdown:  → 14 debugging skills (forecast issues, silent bugs, data quality)  → 13 ops playbooks (balance reconciliation, S3 recovery, trace analysis)  → 17 dev workflows (test runners, feature flags, SDK bumps)  → 4 testing skills (pod testing, N+1 detection)  Each one was born from a real incident. A real 3-hour investigation distilled into a repeatable procedure. You describe the problem in plain language — "endpoint is slow," "files in S3 but no data" — and the agent matches the pattern and runs the playbook.  Here's what got weird for me though. Halfway through building skill #30-something, I had this moment: wait — if I can extract and encode everything I know into repeatable procedures... what's left? Am I just a collection of skills in a mass of carbon? Is the sum total of my engineering value a trigger-map.json and some markdown files?  I sat with that for a minute. Then I wrote skill #31.  Because here's the thing — the skills that matter most are the ones you can't encode. Knowing when the playbook is wrong. Reading between the lines of a vague bug report. The instinct to check that one table nobody else would think to check. You can capture the steps. You can't capture the judgment that knows when to skip them.  Most engineering knowledge walks out the door on someone's last day. The rest fades when you move to a different part of the codebase. Skills are our attempt to make institutional memory durable. And the part that surprised me — the team started contributing their own without being asked. Turns out people want to codify what they know. They just need a format that respects their time.  49 skills for a complex fintech platform is a start. But it already crossed the threshold where the AI stopped being a code completion tool and became a teammate that remembers what we've collectively learned.  I cleaned up one of our skills to share — "Silent Bug Diagnosis," for when tests pass but production output is wrong. The hardest kind of bug because nothing throws an error. Take a look: https://lnkd.in/eKRPXRQc  So — what's the one skill you've built over the years that you're pretty sure no playbook could replace? The thing that makes you more than your procedures?

The real cost of a bad API integration is measured in pipeline failures, not API calls. I've integrated with 30+ APIs across Gulf fintech, retail, and logistics projects. The patterns that have saved me the most: 1. Always implement exponential backoff with jitter   → Not just retry 3 times — wait 2s, 4s, 8s + random noise 2. Store raw API responses before transformation   → If parsing logic has a bug, you re-process from storage — not from the API 3. Rate limit awareness by endpoint, not by total calls   → Different endpoints often have different rate limits 4. Build a dead letter queue for failed records   → Never silently drop a failed API record 5. Track API version in your metadata   → When the API deprecates v1, you know exactly which pipelines are affected API reliability is infrastructure. Treat it like infrastructure. #DataEngineering #API #Python #Reliability #DataPipeline

“But it was working on my machine…” Every developer has said this at least once. And every developer has regretted it later. It starts simple: You build a feature. You test it locally. Everything works perfectly. Smooth. Clean. Beautiful. You push to production… Boom. Suddenly: - API calls fail - Environment variables go missing - Case-sensitive file systems break imports - Database behaves… differently - And somehow, bugs appear that NEVER existed before Now you're stuck thinking: “Was I coding… or hallucinating?” The truth is: Your local machine is a comfort zone Production is reality Different OS Different configs Different data Different scale Same code. Completely different behavior. The best developers don’t trust “it works on my machine.” They ask: Did I test with real-like data? Are my env configs consistent? Did I handle edge cases? Is logging strong enough to debug remotely? Because in the end: Your code isn’t judged by your machine. It’s judged by production. What’s the weirdest “it works on my machine” bug you’ve ever faced? Follow Rahul Patil

☕ Understanding @Transactional in Spring Boot One annotation that quietly protects your data integrity: @Transactional It ensures multiple DB operations either: ✅ All succeed ❌ Or all rollback No partial data corruption. 🔍 Real Example @Transactional public void transferMoney(Account a, Account b, int amount) { withdraw(a, amount); deposit(b, amount); } If deposit fails → Spring rolls back withdraw automatically. 🧩 What Happens Under the Hood Spring creates a proxy around the method: 1️⃣ Start transaction 2️⃣ Execute method 3️⃣ Commit if success 4️⃣ Rollback if exception 🚨 Critical Rules Many Developers Miss • Works only on public methods • Works only on Spring-managed beans • Self-invocation bypasses transaction • RuntimeException triggers rollback by default 🧠 Production Insight Transactions define system consistency boundaries. Too large → locks & slow DB Too small → inconsistent state 💡 Best Practice Keep transactions: • Short • Focused • Database-only @Transactional is not just annotation magic — it’s a core reliability guarantee in backend systems. #SpringBoot #Java #BackendEngineering #Transactions #LearnInPublic

Most backend systems don’t fail because of “bad code.” They fail because of data consistency decisions. In the beginning, it’s a fairy tale. One request + One database = One clean COMMIT Then reality hits You add services, external APIs, async workers… …and suddenly you’re forcing distributed transactions like you’re trying to make “fetch” happen. Spoiler: It doesn’t scale. ⚠️ The Consistency Trap We once tried to keep everything perfectly in sync. Looked great on paper. In production? ✔️ Latency skyrocketed ✔️ Failures cascaded ✔️ Debugging felt like a forensic investigation 🔄 The Pivot: Controlled Chaos We stopped chasing perfection and embraced eventual consistency. It feels like breaking the rules, until you see the results. The Playbook ✔️ Accept the lag: 500ms of inconsistency won’t break the system ✔️ Design for recovery: Assume failure, build self-healing logic ✔️ Idempotency is king: 10 retries should still equal 1 outcome The hard truth: Perfect consistency is a luxury. But, Controlled inconsistency is a design choice. Where do you stand? Strict consistency, Or the eventual consistency side? #BackendDevelopment #SoftwareArchitecture #DistributedSystems #EventualConsistency #SystemDesign #ScalableSystems #DataConsistency #Microservices #PerformanceOptimization #TechDiscussion

Multi-threading can silently corrupt your data. 💀 The worst bugs don’t crash your server. They just quietly bankrupt your logic while you sleep. Imagine this: 100% uptime. Lightning-fast latency. Every monitor is green. Then the audit hits. 10,000 transactions were processed, but only 9,920 were recorded. Where did the other 80 go? They weren't "lost." They were murdered by a Race Condition. In high-concurrency systems, like a massive data pipeline, your code starts lying to you. When two threads fight for the same piece of state without proper orchestration, "Lost Updates" happen. No stack trace. No error log. Just a silent, brutal drift in your data that no compiler will ever catch. The amateur move? Panic and slap a global synchronized lock on the logic. The result: You just turned your 10-lane highway into a single-track dirt road. You "fixed" the bug by killing the performance. That isn't engineering, it’s a surrender. If you want to build for scale, you have to move past basic locking and master Atomic Contention. By leveraging the java.util.concurrent toolkit, you stop fighting threads and start orchestrating them: - Atomic State: Swap standard Maps for ConcurrentHashMap. Use .merge(). It handles the "check-then-act" logic at the hardware level. No manual locks. No performance death-spiral. - Managed Execution: Stop spawning raw threads. Use an ExecutorService. Control your resources before they crash your JVM. The result ? A system that is both bulletproof and blazing fast. Zero data loss. 4x throughput improvement. And most importantly, data you can actually trust. The Reality Check: A fast system that gives the wrong answer isn't a "performance win." It’s a liability. If you aren't thinking about atomicity and thread contention, you aren't building a system; you're playing Russian Roulette with your data. #Java #SoftwareEngineering #BackendDevelopment #SystemDesign #Concurrency #HighPerformance #CleanCode #Programming

Most developers fix bugs. Few actually understand why the bug exists. Recently, I debugged a simple issue: Two currencies (COP, PEN) were missing from a dropdown. At first, it looked like a UI problem. But digging deeper revealed something more interesting. What was happening? * Dropdown values were coming from a transaction table * Selected value was inserted back into the same system * Which again fed the dropdown DB ->Dropdown ->Insert -> DB The problem: This created a circular dependency.🥲 * If a currency doesn’t exist in the DB * It won’t appear in the dropdown * If it’s not in the dropdown * It can’t be inserted * If it’s not inserted * It will never exist in the DB New data becomes impossible to introduce. Hidden issue: tight coupling The UI was tightly coupled with the transaction database. Meaning: UI behavior depended directly on the current state of the DB. Why this is a problem: * Any DB limitation immediately affects the UI * Introducing new values becomes difficult * Changes in one layer impact multiple parts of the system * The system becomes fragile and harder to scale Example: Allowed roles dropdown = SELECT DISTINCT role FROM user_table Now try adding a new role: ADMIN * Not in DB * Not in dropdown * Cannot be assigned * Never gets into DB Same circular problem. Key learning: UI should be driven by master or configuration tables, not transactional data. Ideal approach: Master Table → UI → Insert → Transaction Table 📝Takeaways * Separate master data from transaction data * Avoid tight coupling between UI and database state * Watch for circular dependencies in legacy systems Debugging is not just about fixing errors. It is about understanding systems. #SoftwareEngineering #Debugging #SystemDesign #Backend #Java #designpatterns #microservices #springboot

Thread pool types : 1. Fixed Thread Pool (This has a fixed number of threads.) Method: Executors.newFixedThreadPool(int n) :- internally LinkedBlockingQueue data Structure uses. Example:- steady load where you want to strictly limit resource usage. 2. Cached Thread Pool : (creates new threads as needed but reuses existing threads if available . If thread is idle for 60 seconds, it is terminated). Method: Executors.newScheduledThreadPool(int corePoolSize) :- internally SynchronousQueus data Structure uses. Example:- Applications with many short-lived asynchronous tasks. (Push Notifications & SMS Alerts) 3. Scheduled Thread Pool : This pool can schedule to run after a given delay or to execute periodically. Method: Executors.newScheduledThreadPool(int corePoolSize) Example: Background cleanup tasks, heartbeat signals, or polling. Example:- Tasks that must be processed one at a time in a specific order (e.g., event sequencing). 4. Single Thread Executor : single worker thread to execute all tasks. It guarantees that tasks are executed sequentially Method: Executors.newSingleThreadExecutor() :- internally LinkedBlockingQueue data Structure uses. (Ledger Accounting) #Java #BackendDevelopment #SoftwareEngineering #MultiThreading #Concurrency #JavaPerformance #CodingTips #Programming #SystemDesign

🚀 𝗜𝘀 𝘁𝗵𝗲 "𝗙𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸 𝗔𝗴𝗲" 𝗼𝗳 𝗝𝗮𝘃𝗮 𝗲𝗻𝗱𝗶𝗻𝗴? For years, we’ve been told to hide our data behind layers of "magic" ORMs and complex abstractions. We traded control for convenience, but in high-integrity industries, that convenience often comes with a hidden tax: unpredictable state and opaque execution. Lately, I’ve been exploring a different path: 𝗗𝗮𝘁𝗮-𝗢𝗿𝗶𝗲𝗻𝘁𝗲𝗱 𝗦𝗼𝘃𝗲𝗿𝗲𝗶𝗴𝗻𝘁𝘆. Instead of fighting framework proxy logic or complex lifecycle management, what happens when you treat SQL as a first-class citizen and generic data structures as the ultimate source of truth? The results are striking: ✅ Zero-Dependency Architecture. ✅ Total control over the physical metal (SQL). ✅ Immutable state transitions that are actually auditable. I’m often asked: "𝘉𝘶𝘵 𝘸𝘪𝘵𝘩 𝘗𝘳𝘰𝘫𝘦𝘤𝘵 𝘓𝘰𝘰𝘮 𝘢𝘯𝘥 𝘝𝘪𝘳𝘵𝘶𝘢𝘭 𝘛𝘩𝘳𝘦𝘢𝘥𝘴, 𝘸𝘩𝘺 𝘣𝘰𝘵𝘩𝘦𝘳 𝘸𝘪𝘵𝘩 𝘙𝘦𝘢𝘤𝘵𝘪𝘷𝘦 𝘱𝘳𝘰𝘨𝘳𝘢𝘮𝘮𝘪𝘯𝘨 𝘢𝘯𝘺𝘮𝘰𝘳𝘦?" The answer isn't about thread-blocking. It’s about 𝗙𝗹𝗼𝘄 𝗜𝗻𝘁𝗲𝗴𝗿𝗶𝘁𝘆. Virtual threads handle concurrency, but Reactive (Mutiny) handles 𝗟𝗼𝗴𝗶𝗰. It’s the difference between a "Precision Hammer" and a "High-Velocity Turbine." It’s about building systems that don't just "run," but "react"—handling backpressure, stream composition, and circuit-breaking as fundamental laws of the engine, not as afterthoughts. We are moving away from "Disposable Grade" software. The future belongs to "Industrial Grade" systems where the architect owns the perimeter, not the framework. Who else is stripping back the abstractions to get closer to the metal? ⚔️ #Java #SoftwareArchitecture #ReactiveProgramming #DataOriented #BackendDevelopment #CleanCodeented #BackendDevelopment #CleanCode