Cover illustration for “Rebuilding a System After a Volunteer-Built Tool Breaks in Production”

Essay Tech Governance

Rebuilding a System After a Volunteer-Built Tool Breaks in Production

A technical debt assessment shows what to keep before you rebuild.

Rebuilding a system after a volunteer-built tool breaks in production starts with recovering knowledge. Before hiring an engineering partner, a technical debt assessment should map actual workflows, essential data, architecture, tests, access, and ownership. That assessment should establish what can safely stay, what must change, and who will maintain the result, so the rebuild does not recreate the same dependence on one person.

Why volunteer-built tools break the way they do

The tool still runs without an error message. There is no crash, but no one on staff can safely change it. A capable volunteer built a membership database, dues tracker, or reconciliation workbook, then moved on. The organization’s process is now frozen at the moment its builder stepped away, even though the work around it has changed.

This is a structural problem: most small nonprofits employ no one whose title contains the word “technology,” so systems fall to whoever is closest. That might be an operations manager, a bookkeeper, or a board member with a technical day job. What they know takes the place of documentation and a clear record of who is in charge.

The resulting failures take three closely related forms. A volunteer-built system becomes unchangeable after its builder leaves. A single point of knowledge disappears when the person who knows the file location, working login, and reconciliation rules departs. An orphaned account remains tied to a former executive director’s personal card or sends bank login codes to a treasurer who rotated off. For the person inheriting any of these situations, changing nothing feels safest because the consequences are unknown.

Why these tools accumulate debt so quietly

That reluctance to touch the system also hides its cost. Without automated tests, each change needs manual checking because there is no safety net for unintended breakage. Hardcoded configuration and credentials make it hard to keep environments apart and to rotate credentials safely. When access rules are spread across screens, permissions are harder to manage, and as data grows, database shortcuts cause problems with how the system is built. With little error handling and logging, staff have little to go on when something goes wrong.

These shortcuts make equivalent work take progressively longer. Engineers must first understand undocumented behavior, work around earlier decisions, and check that nearby systems still function. The slowdown can make a cost inherited from the past look like a problem with the latest change. A newer version appears with AI-generated code, when a non-technical founder has no mental model of the architecture because they did not write it. Natural language prompts often cannot fix bugs deep in the system, such as a production database locking up or a memory leak crashing the server.

The money spent on technology is easy to see right away, but it is harder to show how cleaner systems pay off in a single figure. A board watching overhead ratios can find an upgrade difficult to justify. Meanwhile, a free tool may never have been compared with other tools. Years later, the organization has systems it chose because they were free, with little regard for how they fit together, and someone has to link them through CSV exports.

Leaving those systems is not free, either. Decades of donor records, pledge schedules, tribute gifts, and lapsed-donor flags are the real switching cost. Fields do not map cleanly, and custom fields may contain several conventions for the same information. Audit season, year-end appeals, and grant reporting impose genuine operating constraints on the time available for migration.

What the forcing event actually looks like

A key person leaves, data grows beyond what the original schema can handle, or a provider changes its policy or discontinues a free tier. A key person can leave just as the load grows, so the organization has neither room for more work nor the person who knew its limits.

The Microsoft OneDrive case illustrates the external version. A free-tier dependency can be wound down with little notice, leaving the nonprofit to bear the consequences for its data and operations. Dependency can make even a tool that still works untenable because of a decision outside the organization. When volunteers inherit undocumented workflows and scattered tools, responding to that decision turns their hours into unpaid IT support and makes technology a retention problem.

What to do before rebuilding anything: recovering the knowledge that walked out

The response should begin with a record of what the current system actually does, before an outside development team starts rebuilding. That work can feel like delay when staff need relief. Yet skipping it means the first undocumented behavior becomes a surprise inside an already agreed scope. The assessment is what makes a useful engineering brief possible.

Start with the people who know different parts. Interview whoever built the tool, whoever used it, and whoever inherited it. Even a brief conversation may explain why the March numbers have always been off by a particular amount, something a code review alone cannot reveal. Then document the workarounds, including the Monday CSV export, manually reconciled tab, and login that works only from one machine. These are part of the real system, even if they appear nowhere in its intended design.

Donor records, program participant histories, and grant tracking need an inventory before a migration plan is written. The same assessment should identify single points of dependency across people, accounts, subscriptions, credentials, and platform relationships. For each, write down who owns it and how to recover it. Access to an orphaned account needs resolving before rebuilding the tool that depends on it.

What should that assessment deliver before a contract is signed? A scored register can bring the findings together across workflow knowledge, data, architecture, tests, access, and ownership. Its useful content is the specific risk in each area, the evidence behind it, and whether it blocks the next change. A score alone cannot explain why a fragile component must be replaced while a working one can stay.

That might be an operations manager, a bookkeeper, or a board member with a technical day job.

Rewrite versus incremental remediation: how to choose

A full rewrite is expensive, slow, and capable of introducing new problems while recreating things that already work. Under deadline pressure, it can also reproduce the shortcuts it was meant to remove. Most technical debt can instead be addressed in targeted passes, focusing on what blocks a scaling event, integration, or staff transition while other work continues.

The distinction is between visible and invisible debt. Deliberately postponing tests on a billing flow, while recognizing that they must be added before growth, is different from not knowing whether the flow is safe to change. The first is a named compromise. The second makes it hard to judge how much work lies ahead. An assessment should uncover those unknowns rather than treat every untidy component as grounds for replacement.

There are cases where a rebuild is justified. If there are no tests, no documentation, no one who understands the architecture, and no safe route to incremental change, remediation may be slower and riskier than a clean start. A data model that is structurally wrong for current volumes or query patterns can require rebuilding in practice, whatever the project is called. Labarna Rescue starts with a full codebase review, then keeps the parts that work and rebuilds the fragile ones. Assessment precedes the commitment.

The decision therefore turns on a few concrete questions. Can a competent engineer read the code and understand it, or is substantial archaeology required? Is the data model sound at current scale? Can tests be added safely, or must the architecture be restructured first? The answers also need a deadline, determined by the runway before the next fundraising push, staff transition, or platform change.

What production-grade looks like for a nonprofit-scale system

Production-grade does not have to mean enterprise-grade complexity. For a nonprofit, it means the system runs reliably for real users and remains maintainable after its builders leave. That gives staff a more useful question than whether the replacement uses impressive technology. Can someone else operate it, change it, and recover access without finding the original developer?

The answer should be visible in specific properties. Automated tests protect critical flows such as donations, member records, and grant tracking, so staff have less to check by hand after a change. Configuration and credentials sit outside the code, with secrets in a managed store so credential rotation does not require a developer. Centralized authentication makes offboarding a departing staff member or volunteer a single action. Error logging and alerting tell someone when something goes wrong before a user does.

Documentation must also say what the system actually does, including workarounds and known edge cases, as well as how it is meant to work. Accounts, subscriptions, and credentials belong to the organization. These are concrete requirements for continuity after departure. Even without knowing how a test suite is built, staff can tell whether critical workflows are protected or whether access to an account depends on a former colleague.

Code for the Community built the United2Heal Inventory App, which launched in 2018, has processed over half a million donated medical items, and remains actively in use. An AI upgrade shipped in Winter 2026. Its unusual longevity illustrates the value of disciplined scope, production shipping from the start, and ongoing stewardship. Reliability also supports growth because a failed donation form or member portal can lose a donor or program participant whose relationship took years to build.

The tool choices that reduce rebuild risk going forward

The maintenance requirements should shape the choice of platform. The easiest tool to start using is not necessarily one the organization can own, maintain, or leave when its provider changes terms. The assessment therefore needs to connect each option to a plausible owner. “Who will maintain this?” belongs before adoption.

Baserow is an open-source, no-code database with an Airtable-like interface that can be self-hosted, giving the organization full control over its data. That control comes with work attached to it. Someone must be in charge of configuration and maintenance, or the organization risks ending up with another single point of knowledge. NocoDB, also an open-source Airtable alternative, gives the organization the same control over its data along with the work of running it.

Noloco turns existing databases into custom applications, allowing a tailored solution. Zeffy focuses on nonprofit fundraising, with free donations, CRM, and events tools and no technical setup required. Its fit is strongest where fundraising is the core workflow. Those differences make the workflow inventory useful both when comparing products and when planning custom code.

With hosted tools, there is less work to do to keep infrastructure running. They also retain a dependency on the provider, while self-hosting shifts operational responsibility to the organization. Controlling its own data removes the particular exposure created by relying on a provider’s free tier, but does not remove the need for maintenance. The choice is between responsibilities the organization can name and accept.

The ongoing ownership question: who maintains it after the rebuild

Code for the Community can ship production software for nonprofits at no cost, while Develop for Good connects nonprofits with volunteer student engineers and aims to reduce costs without fully eliminating them. Both show why volunteer engineering deserves consideration. Cohort-based work is time-bounded, however, so someone must still maintain the system when the cohort ends.

The durable United2Heal example has a distinguishing feature. Its active stewardship includes the program’s founder, a Meta Senior Android Engineer. The strongest objection to volunteer-built tools is that maintenance costs can fall permanently on people who lack the context, compensation, or time to meet them.

An ongoing partner relationship should make those responsibilities explicit. Living documentation must travel with the codebase, while account and credential ownership stays with the organization. A defined handover protocol must explain how knowledge transfers if the relationship ends. Those arrangements need to exist before the engagement closes, while the people who understand the system are still available.

Notes

  1. Code for the Community

    Supplied the United2Heal Inventory App example: its 2018 launch, volume of donated items processed, and continued use and stewardship.

  2. Connecting nonprofits with technology volunteers - Develop for Good

    Described how Develop for Good connects nonprofits with volunteer student engineers, which informed the discussion of cohort-based volunteer work and maintenance.

Tobias Wrenfield

← Back to Mission Critical