The hidden cost of insecure code: More than just data breaches

When significant breaches like Equifax or Uber happen, it’s easy to focus on the huge reputation and financial damage from all that compromised user data. For sure – those headline costs are massive, no question.

The reality is that risky code has a second insidious cost beyond the breaches themselves. All those lingering vulnerabilities and quick fixes made under pressure create massive technical debt that keeps piling up.

Before you know it, your whole team is bogged down battling bug after bug. Months go by just treading water and fixing the latest outage. Your infrastructure bills keep creeping higher, too, from bloated systems no one dares refactor. And all those passionate side projects are gathering dust because keeping the lights on takes all your energy now.

Insecure code acts like a silent tax siphoning away time, money, and morale across engineering organizations, big and small. Stuff that slow burn costs don’t make headlines like significant breaches, but they add up in their own quiet way. Left unaddressed, that technical debt soon becomes its own unmovable mountain blocking innovation.

By quantifying the slow drain of technical debt, we make the case for incorporating better code security from day one. It’s the only way to sustain solid engineering velocity over the long haul.

When exploits strike: Calculating the tangible costs

Let’s say a hacker identifies a vulnerability in your code that gives them access to sensitive data in a database. They can exfiltrate user data and you are forced to deal with the breach fallout. In this worst-case scenario, a business immediately faces a lengthy list of clear-cut recovery expenses:

• Breach investigation: To understand the full scope of the compromise, you’ll need to launch a thorough forensic investigation spanning storage systems, networks, application code, etc. Depending on complexity, these assessments alone can run from six figures to seven plus, depending on the size of the business.
• Recovery and remediation: Now begins the hard work of restoring and patching compromised environments. Costs climb rapidly as you audit code, roll out security patches, reset user credentials across environments, and potentially notify parties impacted by lost data.
• Legal and regulatory expenses: Depending on the data lost and where you operate, businesses may face sizable GDPR, HIPAA, or PCI non-compliance fines. Uber’s 2018 breach resulted in a $148 million settlement for failing to disclose the impact in a timely manner.
• Lost customer business: Arguably most damaging is the permanent loss of customer trust and, by extension, revenue after security incidents. Many security-conscious customers will leave companies post-breach. This churn and negative brand impact cause considerable loss of business.

Given the scope, it’s obvious why data breaches dominate conversations about the cost of insecure code. The financial damages and customer impacts are immediate and substantial. But even before exploits strike, vulnerable and debt-ridden code actively works against developers and more subtly drags down engineering productivity.

The ongoing interest payments of technical debt

Insecure code ultimately creates technical debt, the implied cost of additional work needed to bring it up to production-grade standards in the future.

Think of each instance of technical debt like a small debt with its own interest payment. As these issues pile up from schedule pressure, outdated libraries, inadequate testing, etc., so does the monthly “interest” paid to carry that debt.

Without even realizing it, organizations get stuck bleeding precious engineering resources and money dealing with the downstream impacts of deficient code:

• Feature development slowdown: Engineering cycles get continually sucked into “interest payments” on technical debt. This directly drags velocity as teams struggle to keep pace while juggling legacy issues.
• Cloud bills run higher: Technical debt from inefficient code also manifests in higher cloud bills. Suboptimal usage of underlying infrastructure means you pay for excess capacity directly hitting your bottom line.
• More bugs and reliability issues: Insecure code is naturally lower quality. So applications wrestle with more defects, performance problems, and stability issues impacting end users. Lost productivity and frustration ensue.
• Revenue opportunities delayed or missed: The money, time, and attention required to manage insecure code actively takes away from business-driving initiatives engineering could otherwise fuel. Needy legacy systems meaningfully crimp their bandwidth for innovation.

Like credit card debt, those interest payments feel small at first, and it’s easy to kick the can down the road. But left unmanaged, compounding interest causes runaway unproductivity that can grind organizations to a halt. For the most part, the data confirms unhealthy levels of technical debt spectacularly throttle output. Like a rickety engine, organizations waste precious resources just struggling to keep older systems on the rails.

Even if you avoid high-profile breaches, vulnerable and messy code still finds ways to quietly degrade engineering productivity, cloud efficiency, and developer satisfaction over time.

Death by a thousand cuts is still death all the same.

Closing the gap requires change from within

Given the ballooning direct and indirect costs, insecure code poses an existential threat on multiple fronts. So, what proactive steps can developers take to course correct day-to-day?

1. Adopt security-minded development flows

• Make security reviews a mandatory phase in SDLC before any promotion to production.
• Introduce lightweight scanning as part of existing automated testing to uncover vulnerabilities early when easier to remediate.
• Require developers to complete regular AppSec training to stay up-to-date on the latest threats and mitigation techniques.
• Perform more rigorous, delayed production penetration testing on critical paths quarterly catching issues before public release.

2. Build skills via ongoing education

• Make secure coding fundamentals mandatory learning for all members of the engineering org. Refresh knowledge yearly.
• Offer lunch and learns, reviewing OWASP Top 10 risks developers face and prevention techniques they can implement directly.
• We send lead architects and key decision makers to intensive, immersive, secure coding camps yearly to relay their learnings and inform standards.

3. Incentivize and empower security excellence

• Praise secure coding best practices publicly in stand-ups, meetings, and newsletters. Recognize and reward those who prevented major exploits.
• Budget-dedicated monthly time is dedicated to engineers directly strengthening application code security with manager approval.
• Instill ownership by tying code quality and penetration testing results to performance across teams during annual review.

Final word

Transforming organizational processes takes a lot of effort. But given the multifaceted costs of vulnerable code extracted from businesses daily, securing our development foundations is simply non-negotiable.

The earlier we reorient workflows to catch issues at code creation, the less interest we pay on technical debt down the road. Just like financial health, consistently applying preventative best practices builds security muscle memory over time.

While no approach eliminates risk outright, baking rigorous security practices into our DNA goes a long way to avoiding catastrophic breaches. More importantly, it helps unlock engineering’s full business potential.