
Essay Tech Governance
What Nonprofit Legacy Codebases Reveal During a Pre-Engagement Technical Review
A pre-hire code review should price what to fix, keep, or replace.
A technical debt assessment before hiring an engineering partner should cover undocumented architecture, code quality, unsupported dependencies, integrations, and operational risk. For a nonprofit legacy codebase, the review should turn those findings into priced, prioritized decisions about what to repair, retain, or replace. Its purpose is not simply to find bugs, but to expose the liabilities already taxing mission delivery and establish what an outside team can safely build on.
Why nonprofit codebases carry a different kind of technical debt than commercial ones
Nonprofit funding often rewards program delivery over infrastructure, while small teams contend with chronic under-resourcing and high staff turnover. A volunteer builds the first version, a junior hire extends it, or a one-time vendor delivers a system and leaves. The launch gets funded, but the revisit does not. What was “good enough for launch” can therefore harden into permanent architecture without anyone deciding that it should.
These pressures create debt when people leave and upkeep stops, as well as through poor engineering. By the time a reviewer arrives, the original developer may be gone, taking the reasons for architectural decisions with them. The system remains, but its explanation has disappeared. That lost knowledge can make software hard to maintain safely even when it seems to work.
The inheritance also extends beyond a single application. Nonprofits routinely manage five or more platforms simultaneously, each with its own schema and integration surface, and that number has grown in recent years. Each platform adds connections that someone needs to know how to manage. A reviewer is therefore examining both accumulated code and the organizational conditions that allowed its upkeep to fall behind.
What should a technical assessment cover before signing with an engineering partner?
Given that inheritance, what does a reviewer actually need to establish? The reviewer first needs to establish a current-state baseline, including the dependency graph, test coverage, change hotspots, and areas engineers are afraid to touch. This separates evidence about the system from assumptions that have become accepted through repetition.
Anderson Technologies’ case illustrates what current-state capture means in organizational terms. A nonprofit CEO’s understanding of the technology department rested on institutional guesswork. The review replaced that uncertainty with a defensible picture of the department, which informed the organization’s next leadership decision.
For a codebase review, that same discipline includes capturing knowledge that exists only in the software. BRACKETS describes the audit’s task as locating debt that a team knows exists but cannot yet point to. The review must distinguish code that is safe to extend from code that needs repair first. Until that distinction is clear, proposed scope and pricing rest on an uncertain foundation.
The invisible debt layer: undocumented architecture and vanished context
The hardest finding to see is often working architecture that nobody currently on staff understands. Nothing needs to be visibly broken for this to create risk. A module may look clean, yet depend on a deprecated framework that the team no longer knows. Its weakness lies partly outside the code.
This is knowledge debt, which includes how many people understand a system, whether reliable documentation exists, and how long someone takes to learn it. In nonprofit builds, the departure of a volunteer or short-term vendor can leave that debt concentrated in essential modules. Onboarding then slows, incident response takes longer, and routine changes become risk events. What looks like an isolated maintenance problem is also a continuity problem.
Reviewers recover context from more than the source files. PropelCode calls this “context mining,” drawing on version control history, recent incident tickets, and architecture diagrams, even outdated ones, before reading a diff. Those records help show why a component is there and where changes have caused trouble. Without that history, replacing a module can lose hidden business logic that the new module needs to keep.
What code-level metrics actually reveal when reviewers run them
Missing context becomes more consequential when it sits beside measurable code-quality problems. Reviewers examine cyclomatic complexity, duplication, dependency violations, security vulnerabilities, and test coverage to locate work that is difficult or unsafe to change. The benchmarks in the legacy debt framework include cyclomatic complexity under 15 per function, low duplication, zero critical security vulnerabilities, and strong unit test coverage on core business logic. The benchmarks provide reference points within a broader assessment of the whole system.
A reviewer still needs to understand which business logic a complex function contains and whether tests protect it. When knowledge debt is already high, weak coverage gives the team one less way to know whether a change is safe. Together, these findings make it harder to estimate a proposed change than either would on its own.
Time to merge a feature, rollback frequency, and sprint capacity spent on bug fixes show where code quality becomes development friction. Missing health checks, manual deployment steps, limited observability, and databases without backups reveal another category, operational debt. Software can keep shipping while the conditions for running it safely deteriorate.
Unsupported dependencies and the security exposure they create
Unsupported dependencies deserve separate attention because their risks extend beyond slow development. They leave an attack surface that can go unnoticed until someone exploits it. For a lean nonprofit IT team without dedicated security staff, that exposure competes with immediate demands to keep programs running. An overdue upgrade can remain postponed because nobody has the time or confidence to undertake it.
Bhaskar Jayakrishnan, senior vice president of engineering for customer experience at Cisco, explains the danger at the edges of a system. “In a modern threat landscape, attackers do not just target the core database; they exploit the weakest link at the periphery.” He adds, “An unpatched mobile device or an outdated field-reporting app provides the initial access needed to launch complex, multistage attack chains.”
Without tests, an upgrade risks regressions, and when context and money for migration are also scarce, leaving the dependency alone can seem safer. That choice preserves exposure. For nonprofits, a breach can bring regulatory consequences, disrupted operations, and lost donor trust, so dependency maintenance is also a question of data stewardship.
These pressures create debt when people leave and upkeep stops, as well as through poor engineering.
Fragile integrations: how the multi-platform stack becomes a liability
A dependency can create a point vulnerability, while a fragile integration can expose a weakness across the operating system of the organization. Many nonprofit codebases are chiefly integration architectures connecting an existing CRM, payment processor, email tool, and accounting system. Reviewing it means establishing how those connections were built, documented, and maintained.
That work reaches into everyday operations. Reviewers look for custom integrations with brittle dependencies, manual workarounds, and repeated data entry caused by systems that do not communicate properly. BRACKETS calls the custom layer around each tool debt too, including data shaped by its schema and workflows that depend on keeping the tool in place. Replacing the tool does not make that layer disappear.
Salesforce provides a consequential example in 2026. Moving from Nonprofit Success Pack, or NPSP, to Salesforce Nonprofit Cloud, or NPC, launched in 2023, is described as a complete re-implementation involving a new org, manual data migration, and fresh integrations. It is not simply an upgrade. Deep NPSP dependencies can therefore signal a migration event rather than routine maintenance, with the choice turning on which debt the organization wants to own and when.
How AI-assisted development has introduced a new strain of legacy code
A review of a nonprofit codebase built or extended in the past two years may encounter plausible-looking AI-generated modules that nobody on the current team fully understands. Some have never received proper review and are already outdated. Their recent origin does not establish that they are safe to extend.
Unmanaged AI generation can reproduce the same missing context that makes older vendor code difficult to maintain. If the person who prompted the tool has left, the next team inherits both undocumented logic and uncertainty about how carefully it was examined. Clean presentation can conceal that gap.
Legacy fragility also limits what organizations can safely automate. Undocumented systems constrain agents that would need to interact with them, even as rapid generation adds more code to understand. AI-generated modules warrant the same scrutiny as inherited vendor code, including tracing the logic, assessing test coverage, and documenting actual behavior before treating them as a sound foundation.
What the debt costs in operational terms — before any remediation
Jayakrishnan calls technical debt a “hidden tax on mission delivery.” These costs are visible in day-to-day work and have no separate budget item. Staff struggle with slow systems, fix broken integrations, and repeat manual workarounds because the technology does not work as it should. The organization is already paying before any cleanup begins.
Time spent navigating complexity or fixing recurring bugs is time unavailable for planned improvements. In a resource-constrained nonprofit, this maintenance trap diverts funds and attention from programmatic impact. A review makes that diversion visible without pretending that every maintenance task is avoidable.
When the current state is poorly documented, an organization cannot confidently judge what it can change or what a proposed project really requires. That uncertainty becomes expensive as it shapes scope, staffing, and budget choices while the software is still running.
What a reviewer's findings should actually produce: from map to prioritized plan
The move from diagnosis to direction requires a sequenced set of decisions with repair costs attached. BRACKETS sets out three choices: fix what may break, leave stable code alone, and rewrite what costs more to keep than to replace. Not every finding deserves immediate work. A useful plan makes the reasons for those different treatments visible.
Integration decisions need both sides priced. Staying means continuing to service vendor lock-in and switching costs, while replacing means extracting data, rebuilding connections, and absorbing new learning curves. Security and dependency work needs sequencing too. Jayakrishnan’s approach begins with visibility and stabilization, moves through strategic alignment, and continues into proactive lifecycle management, turning an inventory into risk-based priorities and a staggered refresh schedule.
The baseline metrics then provide a way to track incremental progress. Deferred work also needs a durable record. PropelCode recommends filing intentionally deferred debt as explicit tickets before closing a review, so postponement does not become another undocumented decision. With costs, priorities, and timing visible, unpredictable crisis risk becomes a manageable investment spread over time.
What a pre-engagement review reveals about the right kind of engineering partner
Who is equipped to execute that plan? The review helps distinguish a partner prepared to stay through remediation from one whose work ends with a report. A rushed pre-engagement stage leaves scope, pricing, and staffing built around unresolved assumptions. Those ambiguities become part of the project whether the proposal acknowledges them or not.
Sustained attention can take different forms. The Nonprofit Open Source Partnership 2026, launched by Bloomberg, Develop for Good, CodeDay, and Fast Forward, structures engagements around dedicated teams of eight vetted and trained college student volunteer developers working for 16 weeks. That structure illustrates a commitment beyond a one-off deliverable. For a prospective partner, the corresponding questions concern continuity, limited budgets, mission-first choices, and staff already wearing multiple hats.
A concrete proposal-stage test is whether the partner can explain how it would connect to the existing CRM, payment processor, and reporting tool, and which review findings change that plan. Its answer should make debt quantifiable without treating it as a moral failing or an excuse to rewrite everything. The Anderson case shows why documented clarity is useful beyond the report. It gives an organization a defensible basis for its next decision, including who should be trusted to do the work.


