13 posts tagged with "financial-analytics"

A 30-day Q1 2026 dataset from a 14-engineer team: 187 tickets touched a legacy authentication component over the year, average cost $1,820 per ticket at 18 hours each. The same team's greenfield onboarding component handled tickets of comparable type and severity at $640 per ticket in 6 hours. The gap is the tech debt tax. Multiplied through, that single legacy component leaks $220K per year the CFO has been signing off on without ever seeing it as a line item. Stripe's Developer Coefficient report (2024 update) puts engineer time lost to "bad code" at roughly 17 hours per week per developer, about 42% of declared work. That's the global average. The number above is what it looks like when you finally measure it locally.

This article is for the engineering manager whose CEO has asked for "the business case to refactor" and who has nothing concrete to put in the spreadsheet. Formula is dull. The data plumbing is the actual work.

You open the Q3 Plan-vs-Actual report. Planned engineering spend: $1.8M. Actual: $2.34M. Variance: +30%. The CFO wants to know why by Friday.

The textbook answer says "investigate any line where |actual − plan| > 10%". That's where most engineering variance reviews stop, and where they go wrong. A 30% gap on engineering cost has at least 5 distinct causes. Each one leaves a different signature in the data. If you don't decompose the variance, you end up firing the project manager when the real culprit was a retroactive raise round in August.

CIMA's variance analysis framework treats variance as a tree: rate variance × volume variance × mix variance. Engineering cost is messier, because labor isn't a uniform commodity. Below is the version that actually fits how dev teams burn money.

In Q1 2026 we instrumented an engineering organization that reported a healthy "$340K spent on Project X this quarter." Drilling down, the top five tickets told a different story. PROJ-1245 refactor auth: $4,820. PROJ-1281 date-format bug: $3,140. A two-hour bug fix that cost more than half of an architectural refactor. Six engineers had touched it across three weeks because nobody owned it.

You cannot have that conversation with a project-level number. You can have it with a ticket-level number. That is the entire argument of this post, and the reason most engineering finance tools are debating the wrong layer.

A team of 8 engineers logged 1,280 hours in March 2026. That is exactly what a 160-hour-per-FTE month should produce. The spreadsheet looked clean. Two engineers were three weeks from quitting. The hours number hid that completely; FTE utilization showed it on day five.

This is the gap between an attendance metric and an engagement-against-baseline metric. Microsoft Research's 2022 WorkLab study on the "triple peak workday" documented a third evening productivity spike pushing knowledge workers past sustainable hours, and that signal stays invisible if you only count totals. Hours don't tell you who is sprinting and who is coasting. FTE utilization does.

Jellyfish is good at what it was built for: portfolio-level visibility for VPs of Engineering at 200+ developer organizations. It surfaces "what percentage of engineering effort goes to growth vs. maintenance" in a board-deck-ready format. That's a real problem at real scale, and Jellyfish solves it.

The friction is the price tag and the fit. Public references and customer reports place Jellyfish contracts in the $50K-$250K/year range, with most deals near or above $100K. For a 60-engineer company that wanted "DORA + a bit of resource allocation", that's the wrong shape and the wrong invoice.

If you're searching "Jellyfish alternative" you're usually in one of two camps. Either you piloted Jellyfish and the price didn't survive procurement, or you're at 30-150 engineers and the platform is overbuilt for your actual question. Both are common. Here's the honest landscape in 2026.

Four dashboards. One platform. From a single engineer's day to organisation-wide cost. Below — what each view shows, in screenshots.

Your product team just shipped a new reporting dashboard. It took three sprints, involved four developers, a designer, and a QA engineer. How much did it actually cost?

If your answer is "I don't know" or "somewhere between $20K and $80K," you're not alone. Most engineering organizations cannot answer this question with any precision. According to Stripe's Developer Coefficient report, companies collectively spend over $300 billion annually on developer time — yet few can attribute those costs to individual features. That disconnect turns every product decision into a guess.

Every quarter, CTOs face the same uncomfortable meeting. The CEO asks: "We spent $2.4M on engineering last quarter. What did we get for it?" And the answer is usually a list of shipped features — not a financial return.

Engineering is the largest cost center in most technology companies, yet it's the one with the least financial accountability. Marketing can show customer acquisition cost. Sales can show revenue per rep. Engineering shows... velocity points? McKinsey's analysis of software developer productivity highlights this gap: engineering output is measurable, but most organizations haven't built the systems to do it.

It's time to change that.

Your engineering team has 40 developers across three offices, a mix of full-time employees and contractors, salary ranges from $60K to $190K, and contractor rates from $45/h to $150/h. Someone asks: "How much did Project X cost last month?"

You open a spreadsheet. You check Jira. You send three Slack messages. An hour later, you have a rough guess. With global IT spending projected to exceed $5 trillion in 2025, that level of imprecision is expensive at any scale.

A Series B SaaS company with a 35-person engineering team was spending nearly $800K per month on software delivery. The CEO wanted to cut costs. The board suggested reducing headcount. The CTO proposed a different approach: find the waste first, then eliminate it.

Six months later, monthly delivery cost dropped to roughly $540K — a reduction of more than 30% — while deployment frequency actually increased. No layoffs. No quality regression. McKinsey's research on developer productivity supports this pattern: the biggest efficiency gains come from eliminating process friction, not cutting headcount.

Here's the playbook.