Why Casting Double to Decimal Won't Save Your Financial Data 💸 (A Bug Hunt Story)

Yahya LAZREK — Wed, 11 Mar 2026 14:08:58 +0000

Today at work, I was deep in the trenches of a large legacy codebase, tracking down a weird bug. The application handles a lot of financial data, and at a certain point in the logic, an account balance was supposed to be exactly 0.

Instead, the system was throwing errors because the value was something like 0.000000000000000014.

Ah, yes. The dreaded floating-point noise.

When I dug into the source code, I found the culprit. A previous developer had used a double to calculate the financial values, and then, right at the end, did something like this to "fix" it:

decimal finalBalance = (decimal)calculatedDoubleBalance;

Spoiler alert: This does not work.

Here is why casting a Double to a Decimal won't save you, and why you need to understand the difference between the two when dealing with money.

🥊 Double vs. Decimal: What’s the difference?

To understand the bug, we have to look at how computers store numbers under the hood.

The `Double` (Floating-Point)

A double (short for double-precision floating-point) represents numbers using Base-2 (binary) fractions.
Because it uses binary, it can't perfectly represent all Base-10 (decimal) fractions. Just like 1/3 results in 0.333333... in our normal math, fractions like 0.1 result in an endlessly repeating binary fraction for a computer.

To make it fit into memory, the computer cuts it off, resulting in a tiny loss of precision.

Pros: Blazing fast, uses less memory, and can store astronomically large or microscopic numbers. Perfect for physics, graphics, and scientific calculations.
Cons: 0.1 + 0.2 equals 0.30000000000000004.

The `Decimal`

A decimal represents numbers using Base-10 math. It was specifically created to handle money and financial calculations. It stores exact decimal fractions. If you tell it to store 0.1, it stores exactly 0.1.

Pros: 100% precision for decimal numbers. No floating-point noise.
Cons: Slower to compute and takes up more memory (usually 128-bit vs a double's 64-bit).

🔍 Why the cast failed

In the bug I found today, the developer knew that the final output needed to be a Decimal. But because the math leading up to that point was done using Doubles, the precision was already lost.

Casting a corrupted Double into a Decimal is like taking a blurry, low-resolution photo and saving it as a massive 4K PNG. It doesn't magically restore the lost details; it just gives you a very high-resolution, blurry photo.

When you cast a double with floating-point noise to a decimal, the decimal faithfully records that exact noise.

Let's see it in action (C# example):

double deposit = 0.1;
double anotherDeposit = 0.2;
double doubleBalance = deposit + anotherDeposit; 
// doubleBalance is now 0.30000000000000004

// Let's try to "fix" it by casting!
decimal decimalBalance = (decimal)doubleBalance;

Console.WriteLine(decimalBalance); 
// Output: 0.30000000000000004 ❌ We just preserved the error!

Because the math was already executed as a double, the damage was done. When subtracting values later down the line, instead of hitting exactly 0, the system was left with microscopic pennies, breaking the business logic.

🛠️ How to handle this properly

If you are working with money, currencies, or any system where exact Base-10 precision is required, follow these rules:

1. NEVER use Double or Float for money.
Not in your database, not in your API payloads, and not in your code.

2. Use Decimal from start to finish.
Declare your variables as decimal right away.

decimal deposit = 0.1m;
decimal anotherDeposit = 0.2m;
decimal decimalBalance = deposit + anotherDeposit; 

Console.WriteLine(decimalBalance); 
// Output: 0.3 ✅

3. What if you have to deal with a legacy Double?
If you are consuming a legacy API or database that gives you a double, and you need to convert it to a decimal to do financial math, you need to use rounding.

double legacyValue = 0.30000000000000004;

// Round it to the precision of your currency (e.g., 2 decimal places) 
// BEFORE or DURING the transition to Decimal.
decimal cleanDecimal = Math.Round((decimal)legacyValue, 2); 

Console.WriteLine(cleanDecimal); // Output: 0.30 ✅

Final Thoughts

Finding this bug today was a great reminder that types matter. Double is great for calculating the trajectory of a rocket, but it's terrible for calculating someone's paycheck.

Have you ever spent hours chasing down a floating-point bug in your codebase? Let me know in the comments! 👇

Stop relying on Regex for Email Validation (Here is a drop-in React component)

Yahya LAZREK — Sun, 08 Mar 2026 14:29:32 +0000

If you are building a SaaS, you know the pain of fake signups.

Standard email regex (^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,4}$) is no longer enough. It passes temp-mail.org, yopmail, and fat-finger typos like user@gmil.com. This leads to a database full of garbage and high bounce rates that ruin your email deliverability.

I only have a couple of hours a day to work on my side projects, so I got tired of dealing with this. I spent the weekend building a "Smart" Email Input component in React that actually does deep validation.

What it does differently:

Live DNS/MX Check: It pings the domain to ensure it actually has active mail servers.
Burner Block: It checks against a constantly updated list of disposable email providers.
Typosquatting Autocorrect: It detects typos on major providers and prompts the user (e.g., "Did you mean user@gmail.com?").
Saves API calls: It only triggers on onBlur (when the user clicks out of the input).

The Code (Open Source)

I styled it with Tailwind, so it's super easy to drop into your Next.js or React forms.

You can grab the full SmartEmailInput.jsx file from my GitHub repository here:
👉 https://github.com/yahyalazrek/react-smart-email-input
🌐 Website: https://emailguard.lazrek.net

(Note: The logic runs on an edge-optimized Cloudflare Worker I deployed to RapidAPI. The GitHub Readme has a link to grab a free API key with 100 requests/mo so you can test the component instantly).

How do you handle validation?

Let me know what you think of the code! Do you guys use double opt-in, or do you block fake domains at the form level? Would love to hear how other devs are handling this!

DEV Community: Yahya LAZREK