Creative Engineer Spin

Severity Scoring Frameworks Your Studio Should Apply to Debt Before Outsourcing Begins

Assess and score technical debt across five dimensions before handing code to an external team.

· 9 min read
Cover illustration for “Severity Scoring Frameworks Your Studio Should Apply to Debt Before Outsourcing Begins”
Startup Technical Debt · November 2, 2026 · 9 min read · 1,950 words

Before hiring an engineering partner, a studio should assess technical debt across code quality and testing, deployment, security, architecture, and maintainability, then score each finding by its impact on handoff readiness. The deliverable is a scored register of prioritized risks tied to contract conditions. External teams inherit decisions they did not make, so undisclosed debt must become a priced, negotiable responsibility before outsourcing begins.

Why unscored debt is an outsourcing problem, not just a code quality problem

An incoming team inherits the consequences of architectural decisions without necessarily inheriting the reasons behind them. A shortcut may have been a prudent response to an early deadline, or it may hide a dangerous gap. The code alone cannot always show which kind of shortcut it is. Without that context, the new team cannot reliably distinguish a trade-off it can preserve from a risk it must address before changing anything.

The contract can deepen this information gap. When vendors are judged on delivery milestones, they have a reason to work around inherited debt rather than make the codebase healthier over time, especially under fixed scope. That makes pre-handoff scoring the handing-off studio’s responsibility. The framework must link three things that are often kept apart: how the debt affects operations, the evidence of how severe it is, and what another team needs to safely accept it.

How debt accumulates fastest in the codebases most likely to be outsourced

MVPs, deadline-driven projects, and nonprofit systems face pressure to ship with little room to write down what work has been put off. Edbert, Codabux, and Verdecchia’s EASE 2025 study found that, in some projects, more than 50% of releases showed increasing technical debt accumulation as deadlines approached. That pattern gives studios a reason to check whether rushed releases are ready to hand over.

For an MVP, architectural shortcuts, thin test coverage, and deferred infrastructure can be reasonable early trade-offs. Their cost changes when real users arrive and another team must extend the product. AI coding assistants can accelerate the same pattern when code generation outpaces review. Faster output can let unreviewed decisions accumulate faster.

Melin et al.’s PEARC '26 study found that rates at which self-admitted technical debt is resolved and removed in scientific software are below the averages for open-source software. Debt that appeared across comments, issues, and pull requests tended to get higher priority but was less likely to be resolved. Nonprofit systems add another source of opacity when budget constraints, junior administrators making architectural decisions, and staff turnover concentrate knowledge in one person. Studios outsourcing these kinds of systems should start by assuming there is a lot of debt, with no clear picture of where it lies, until an assessment shows otherwise.

What should a technical assessment cover before signing with a software development partner?

A useful assessment classifies what blocks an incoming team. Martin Fowler’s Technical Debt Quadrant distinguishes deliberate from inadvertent debt and reckless from prudent trade-offs. It explains how debt arose. Melin et al.’s taxonomy adds four relevant types, which are code/design, documentation, test, and requirement debt. Neither classification alone establishes handoff severity, because the same type of debt can have very different effects on an incoming team.

The handoff scorecard needs five dimensions, beginning with code quality and testing. This dimension covers automated tests for critical features and review practices before merging, because an incoming team needs a way to detect breakage before users do. DevOps and deployment form the second dimension. CI/CD maturity, production error monitoring, and alerting shape whether the team can release changes and spot failures as well as change code.

Security and dependencies are the third dimension, which checks whether dependencies are up to date and whether security reviews or vulnerability scans have been done. Architecture and scalability are the fourth, including whether growth requires fundamental architectural changes and whether performance is monitored. The fifth, maintainability, concerns whether a new developer can get the project running from its documentation and whether knowledge is distributed across multiple people.

Those dimensions should not all get the same weight by default. When only one person has the knowledge and cannot be reached, work can stop at once, while a missing performance dashboard may not hold it up. Severity must follow the effect on handoff readiness. The assessment should also read comments, commits, pull requests, and issues for self-admitted shortcomings that static analysis can miss. Melin et al. found higher priority for acknowledgments in comments, commits, and pull requests than in issues, with negative sentiment amplifying urgency.

The tools that produce scores an outsourcing contract can actually use

A studio needs at least two kinds of instrumentation, namely rule-violation scoring and behavioral signals. They answer different questions about the same codebase. Rule-based tools identify violations and can estimate remediation effort or produce grades, while behavioral analysis shows how people work with the code. A five-dimension self-assessment scorecard can give the studio a clear way to start before deeper automated analysis, but both kinds of tools are still needed.

SonarQube has severity categories that are easy to use as acceptance criteria. Its Standard Experience / legacy mode uses Blocker, Critical, Major, Minor, and Info, while current MQR mode uses Blocker, High, Medium, Low, and Info. The contract should name the mode it uses. Codacy scans commits for quality issues, security gaps, duplication, and complexity, while another code analysis tool serves.NET codebases with interactive web reports and PASS/FAIL quality gates that integrate into CI/CD pipelines.

Teamscale extends the assessment to architecture flaws, test gaps, and compliance risks. Its live quality gates fail pipelines when new code violates standards. Teamscale also links requirements, code, and tests, and creates verification matrices that show which requirements have no tests that pass. That makes it particularly relevant when suspected scope drift complicates handoff alongside code quality concerns.

CodeScene addresses a different blind spot through CodeHealth, a metric validated by engineering outcomes, and analysis of actively deteriorating code. Its Knowledge Island detection identifies code written mostly by one developer. Static violations cannot reveal that handoff risk. DORA metrics add deployment frequency, lead time for changes, change failure rate, and mean time to restore, making debt visible through delivery behavior. The prioritization rule is to measure cost through signals such as lead time, failures, and dependency age, rather than rely on lines of code or one aggregate score.

No single tool covers the whole assessment. Behavioral signals do not replace security-focused scanning, just as rule-based scoring does not reveal every knowledge silo.

How security debt specifically behaves as a handoff risk category

Security debt differs from maintainability debt because its consequences can reach users before the incoming team has resolved its understanding of the codebase. A difficult module slows development, while an exploitable weakness can cause a trust-destroying failure after transfer. The distinction is more than a higher score. It changes whether the risk can reasonably remain in a backlog when responsibility passes between teams.

Díaz Ferreyra et al. found 25 Common Weakness Enumeration types across self-admitted technical debt artifacts, of which 8 appear among MITRE’s Top-25 most dangerous. Developer acknowledgments can therefore point to exploitable weaknesses. Those pointers have two possible audiences. They help peers recognize fragile code, but can also help bad actors if changes to access controls or repository visibility make the artifacts accessible after handoff.

Old dependencies and skipped security reviews require explicit attention, including OWASP and dependency currency checks rather than an assumption that a general rule scan covers them. Nonprofit systems face compounded consequences through donor trust loss, regulatory exposure, and disruption during recovery. With little capacity to recover, these systems need security to come first in scoring. The contractual consequence is that security items rated Critical or Blocker in SonarQube’s Standard Experience / legacy terminology should block handoff, rather than enter an undisclosed backlog that the incoming team never priced.

Translating severity scores into handoff conditions the contract must enforce

To turn the assessment into protection, studios should map severity levels to acceptance criteria, milestone gates, and payment conditions. The contract should make tests, linting, performance budgets, and security scans formal requirements. The scoring vocabulary must be explicit. SonarQube’s named severity tiers and Teamscale’s live quality gate PASS/FAIL outputs provide concrete formats, but the agreement still needs to state which results prevent acceptance.

Milestones should measure maintainability as well as feature completion. Test coverage thresholds, cyclomatic complexity limits, and delivered documentation make codebase health part of the accepted work. Feature completion alone leaves accumulated debt invisible. Each milestone review should also require a written debt summary that lists what was addressed, what was put off, and the current risk level of the highest-risk modules. Growth in debt then becomes a reason for escalation rather than a footnote attached to otherwise successful delivery.

Knowledge transfer needs its own enforcement mechanism because a static scan cannot establish whether another team can operate the system. Studios should hold back part of the payment until a knowledge-transfer audit passes. Payment makes that obligation harder to defer. Combined with debt-specific milestone criteria, it gives the vendor a reason to surface inherited problems and address knowledge concentration rather than work around both to meet a feature deadline.

There is a serious limit to any pre-engagement assessment. The most expensive findings may emerge only when engineers have code access and can speak directly with the people who built the system. A report cannot substitute for that investigation. Studios should treat the initial audit as a baseline and include mid-engagement debt review checkpoints in the contract. Later discoveries then have a governance mechanism instead of becoming arguments about whether they were included in the original scope.

What the scoring process looks like in practice for an MVP or nonprofit codebase

For an MVP, the scorecard should show how weaknesses connect as well as list individual defects. Thin test coverage, manual deployment, and missing error monitoring often come from the same pressure to keep shipping before the foundations are ready. These findings affect one another during handoff. Tests show whether a change seems safe, deployment practices shape how it gets to production, and monitoring lets the incoming team spot trouble afterward.

The MVP assessment should flag automated test coverage below 60% on core business logic as a warning threshold. It should also identify the absence of CI/CD as a release-process cost that needs estimating and disclosure before new feature work begins. Security needs a separate pass. AI-generated and no-code MVPs can contain exposed credentials, insufficient authentication, and dependency currency gaps, which call for explicit OWASP and dependency scanning in addition to general static analysis.

For a nonprofit system, the same assessment should check whether only one current or former staff member knows the critical logic. CodeScene’s knowledge silo detection is directly relevant to that risk. Yet code is not the whole system. Over-customization by early-career administrators may embed architectural choices in configuration, where a requirement audit can expose problems that rule-violation scanning misses. GDPR, data retention, and sector-specific regulatory gaps can also block work on affected modules until the exposure is remediated.

The output for either setting should be a scored register that prioritizes remediation by what prevents safe operation in the first sprint. Missing CI/CD must be disclosed as release-process work, knowledge concentration must be addressed as a condition of transfer, and high-severity security debt must block handoff. That changes the negotiation before work starts. Pricing known debt before work starts can prevent later contract disputes over its cost.

Even that register remains a point-in-time assessment. A long-term engineering partner who keeps working in the codebase is better able to judge how debt behaves under pressure to change than a vendor who works on it only at handoffs. Ongoing assessment gives the original scores a way to evolve.

Sources

  1. Racing Against the Clock: Exploring the Impact of Scheduled Deadlines on Technical Debt
  2. Different Debt: An Addition to the Technical Debt Dataset and a Demonstration Using Developer Personality
  3. What Can Self-Admitted Technical Debt Tell Us About Security? A Mixed-Methods Study
  4. Self-Admitted Technical Debt in Scientific Software: Prioritization, Sentiment, and Propagation Across Artifacts

More in Startup Technical Debt