The fiscal edge cases Romanian payroll software gets wrong (and how I modeled them in TypeScript)

Știuriuc Sorin-Marian — Thu, 02 Jul 2026 18:24:45 +0000

Three weeks ago I wrote about modeling Romania's salary taxes in TypeScript for salariile.ro. Since then, Romania's minimum wage changed (July 1st: 4,050 → 4,325 lei gross), and I shipped a payslip generator on top of the same fiscal engine: salariile.ro/fluturas-salariu.

Building it forced me to confront edge cases that, as far as I can tell from comparing outputs, even commercial payroll software gets wrong. Here are three of them.

1. The tax-free allowance survives bonuses (up to a ceiling)

Romania gives minimum-wage earners a fixed tax-free slice: 200 lei/month is exempt from all contributions and income tax (OUG 89/2025). The naive implementation:

const facilitate = (functieDeBaza && brut === SALARIU_MINIM) ? 200 : 0;

That was literally my first version. It's wrong. The actual rule: the allowance applies when the base salary equals the minimum wage AND total gross income (excluding meal vouchers) stays under a ceiling — 4,600 lei since July. So minimum wage + a 200 lei bonus = allowance stays. Minimum wage + a 400 lei bonus = allowance gone, on the entire amount.

const salariuDeBaza = input.salariuDeBaza ? parseFloat(input.salariuDeBaza) : brut;
const facilitate =
  (functieDeBaza && salariuDeBaza === SALARIU_MINIM && brut <= PLAFON_FACILITATE)
    ? DEDUCERE_MINIM
    : 0;

The difference is 80–100 lei/month in the employee's pocket. I've seen real payslips where software silently dropped the allowance the moment any bonus appeared.

2. Personal deduction rounding changed in 2023 — some software never noticed

The personal deduction (a progressive tax shield for lower salaries) used to be rounded up to the nearest 10 lei. Since 2023, the Fiscal Code says you apply the exact computed amount, rounded to the leu.

For a 4,425 lei gross salary: 19% × 4,325 = 821.75 → 822 lei. A well-known Romanian calculator still shows 800 for this case — the old rounding, cascading into a wrong income tax.

How do I know mine is right? I validate against ANAF's own D112 declaration validator (DUKIntegrator) — the same software employers' declarations run through. If my numbers diverge from the official validator, my tests fail.

3. There is no such thing as a 168-hour month

Hourly rate = base salary ÷ monthly working hours. The lazy constant is 168 (21 days × 8h). But Romanian months have 19–23 working days once you subtract weekends and legal holidays. July 2026 has 23 → 184 hours → 23.51 lei/hour at minimum wage, not 25.74.

I generate the working-hours calendar from a single source of truth (a map of legal holidays, shared between the public holidays page and the payslip PDF), so overtime pay is computed on the real month, not an average.

export function zileLucratoareLuna(an: number, luna0: number): number {
  const zileInLuna = new Date(Date.UTC(an, luna0 + 1, 0)).getUTCDate();
  let lucratoare = 0;
  for (let d = 1; d <= zileInLuna; d++) {
    const dow = new Date(Date.UTC(an, luna0, d)).getUTCDay();
    const weekend = dow === 0 || dow === 6;
    const sarbatoare = an === 2026 && Boolean(SARBATORI_LEGALE_2026[`${luna0 + 1}-${d}`]);
    if (!weekend && !sarbatoare) lucratoare++;
  }
  return lucratoare;
}

The meta-lesson

Fiscal law is a spec written in prose, full of exceptions that only surface when real people hit them. The only defense I've found: one pure calculation module as the single source of truth, tests pinned to the official validator's output, and treating every divergence from another calculator as a research task — sometimes they're wrong, sometimes I am.

The whole thing is open source: github.com/xsagul/salariile-ro. If you're Romanian and want to check your own payslip against the law, the generator is free, no account: salariile.ro/fluturas-salariu.

If you've built payroll or tax tools for other countries — do you also validate against the government's own software, or is that a Romanian luxury?

Modeling Romania's salary taxes in TypeScript: lessons from building salariile.ro

Știuriuc Sorin-Marian — Fri, 12 Jun 2026 18:36:15 +0000

I spent the last few weeks building salariile.ro, a salary calculator for Romania. It sounds like a weekend project: take the gross salary, subtract three percentages, show the net. It was not. Here is what made it interesting, and what I would tell anyone who needs to model payroll or tax rules in code.

The domain is the hard part

Romanian salary math in 2026 looks simple on paper: 25% pension contribution (CAS), 10% health insurance (CASS), 10% income tax after deductions, plus 2.25% paid by the employer on top (CAM). The complexity hides in the details:

The personal deduction is not a constant. It is a curve that depends on income and the number of dependents, and it phases out completely above a threshold.
Meal vouchers are taxed differently from cash. CASS and income tax apply to their value, but the tax money is withheld from your cash salary while the full nominal value lands on the card. Many calculators get this subtly wrong, and people then wonder why the payslip does not match the estimate.
Sector rules (construction, agriculture) and the minimum wage facility change the formula depending on contract details.
The rules change constantly. The minimum wage changes again on July 1, 2026, and several thresholds are indexed to it.

My main takeaway: encode rules as data, not as ifs. Every fiscal period is a config object with rates, thresholds, deduction tables and links to the legal source. The calculation engine is a pure function from (config, input) to a payslip breakdown. When the July 2026 rules land, that will be a new config entry plus a set of tests, not a refactor.

Test against official examples

The Romanian tax authority publishes norms for Declaration 112 with worked examples. Every rule I implement gets a test case traced back to an official source, and where two sources disagree, a comment links the exact article of law I followed. For a YMYL topic this is the only thing that keeps the project honest.

The web part: boring on purpose

Next.js 16 App Router, React 19, TypeScript, deployed on Vercel. Server Components everywhere, with the calculator as the only real client component. No cookies, no ads, no tracking scripts. For search visibility the unglamorous things mattered most: correct JSON-LD (Person, FAQPage), a sitemap that actually updates, llms.txt for AI crawlers, and pages that each answer one question instead of one page trying to answer everything.

What surprised me

While researching the niche I found that the sites ranking top 3 for "calculator salariu" include one with almost zero backlink authority and another still showing rules that expired in 2024. In this niche, search engines seem to reward being current and precise more than raw link mass. Encouraging, if you are building something accurate.

The calculator is live at salariile.ro and I am happy to answer questions about modeling tax rules in TypeScript. It is a surprisingly fun domain once you accept the chaos.

DEV Community: Știuriuc Sorin-Marian