Code is a liability

Published:

The feature needs a reminder email.

A customer submits a request. If it remains unanswered after two days, the system should notify the person responsible. The application already has a background worker, and the team knows how to send email from it.

During design, someone suggests a more interesting approach. Requests could publish events. A workflow engine could interpret configurable rules. A plugin interface could support future notification channels. The reminder becomes the first consumer of a platform that might eventually coordinate many kinds of work.

The idea has appeal. It is coherent, flexible, and enjoyable to discuss. Engineers can see where each piece belongs. The implementation offers a chance to build something more satisfying than another scheduled job.

The team builds it. The reminder works. The feature ships.

Months later, a new developer needs to change when the reminder is sent. They have to understand the event schema, the workflow definition, the retry behavior, and the relationship between the application database and the engine's stored state. A dependency upgrade changes how workflows resume. Support needs a way to explain why one customer's reminder was delayed. Someone must decide whether old workflows should use the new rule.

The feature still sends one reminder email.

The team now owns a workflow system.

Code is a liability in the sense that keeping it useful creates a continuing obligation. Someone must understand it, verify its behavior, operate it, secure it, and adapt it as the surrounding world changes. Eventually, someone may have to migrate or remove it.

The capability can make that obligation worthwhile. A reliable reminder may prevent missed requests, reduce support work, and help customers trust the service. A workflow engine may earn its place when the product genuinely needs durable, configurable processes. The engineering decision concerns the capability gained and the responsibility accepted together.

Trouble begins when the idea itself supplies enough justification to build it.

The team wants to try event sourcing. A developer likes the elegance of a general rules engine. A new framework promises a cleaner way to organize the application. A plugin system feels like the proper architecture for a product that may someday have many integrations.

Each idea can solve real problems. Its usefulness depends on the problem the team actually has, the constraints around it, and the people who will maintain the result.

In this pattern, those questions receive less attention than the attraction of the design. Future possibilities become reasons to introduce machinery now. The discussion moves quickly from “Do we need this?” to “How should we implement it?” Once the second conversation becomes detailed, the first can feel settled without anyone having answered it.

Technical enthusiasm is productive. It gives engineers the energy to investigate, learn, and improve systems that would otherwise remain awkward. It also creates a particular risk: the experience of building an idea can be immediately rewarding while the cost of owning it arrives later and falls on other people.

The engineer who enjoys designing the workflow engine may move to another project. The person on support duty inherits the failed workflow. A future hire inherits the unfamiliar model. Another team inherits the upgrade deadline because the original owner has more urgent work.

The original implementation can be excellent and the decision can still be expensive.

Good naming, careful tests, and clean interfaces help people maintain a system. They do little to establish whether the system needed to exist at that level of complexity. A well-built abstraction still needs an explanation. A dependable service still needs deployment, monitoring, access controls, and an owner. Every supported extension point creates behavior that future changes must respect.

The obligation survives the quality of the first implementation.

Organizations often make that obligation difficult to see.

A project has a budget, a team, and a delivery date. The estimate includes designing the engine, integrating it, and getting the reminder into production. Once the project closes, the work appears complete. Its continuing costs enter different queues under different names.

An upgrade becomes platform maintenance. A delayed reminder becomes an incident. An explanation becomes onboarding. A change to workflow behavior becomes a feature estimate. An investigation into an abandoned integration becomes support. The organization pays for the original decision in fragments, and those fragments rarely return to the conversation that approved it.

That separation makes building look cheaper than owning.

Even a system with little new development can keep consuming attention. Dependencies change. Credentials expire. Infrastructure is replaced. Security expectations evolve. Customers rely on behavior that nobody remembers promising. The code continues to participate in the product, so changes elsewhere must account for it.

Some obligations are small and stable. Others grow as more parts of the business depend on the implementation. A reminder platform can become important to billing, onboarding, and account closure. Its flexibility attracts consumers, and every new consumer increases the consequence of changing it.

Reuse can justify a shared system. It also creates a need for shared ownership. The benefit of centralizing a capability comes with decisions about compatibility, support, and how changes reach the people who depend on it.

Code volume gives a poor account of this burden.

A small custom scheduler can demand more attention than a much larger piece of straightforward business logic. A configuration language may contain few lines while allowing combinations that are expensive to understand and test. A managed service can remove substantial operational work while leaving the team responsible for its integration and the behavior it exposes to customers.

The useful question is what the team must keep knowing and doing because this implementation exists.

Look for that question in design discussions. Can the team explain the current need that makes the additional machinery worthwhile? Which likely change becomes easier? What evidence supports that expectation? Who will handle failures, upgrades, and questions once the project ends?

Listen to how alternatives are described. A simple approach may be dismissed as inelegant before anyone examines its limits. A more elaborate approach may be called future-proof without naming a plausible future requirement. The team may spend an hour comparing frameworks and only a few minutes establishing whether the feature needs one.

The warning signal is a decision whose strongest arguments describe the attractiveness of the implementation while its ownership remains vague.

This differs from an expanding refactor. There, a bounded improvement widens as the engineer discovers more dependencies. Here, the team can deliver exactly the architecture it originally intended, on schedule, and still accept far more continuing responsibility than the feature warrants. Successful delivery can hide the poor trade.

Recognition helps preserve it.

A new platform gives someone a visible achievement. They can demonstrate its design, explain the difficult parts, and describe the opportunities it opens. Choosing the existing worker produces a quieter story. The reminder ships, the familiar operational path continues, and the team has fewer new things to maintain.

If career progress follows visible construction, engineers have a reason to make their work architecturally substantial. A useful feature becomes a vehicle for demonstrating technical scope. Simpler choices can look like missed ambition even when they serve the organization better.

Managers contribute when they celebrate launches and treat upkeep as work that should fit around the roadmap. The same organization can reward the creation of a shared platform and repeatedly decline the maintenance needed to keep it healthy.

Eventually, engineers learn that building earns attention and ownership consumes it.

That lesson reaches the code. Teams introduce replacements while older paths remain active. Optional abstractions become permanent because someone might use them. Experimental integrations survive long after their experiment has ended. Each addition had a sponsor; the accumulated system has whoever happens to be available.

Retirement becomes difficult because its benefit is spread across future work. Removing an unused extension point may save small amounts of understanding on dozens of later changes. Those savings are hard to put beside a feature with a customer waiting today.

The longer the code remains, the less certain people become about whether it is safe to remove.

A team dependent on manual QA feels this particularly sharply. Consolidating two paths or removing obsolete behavior requires verification capacity. Features and defects already occupy that capacity, so the structural improvement waits. The team carries more code, which increases what people need to check, which makes the next improvement harder to schedule.

Ownership costs begin to protect the implementation that creates them.

A useful intervention starts while the team still has choices.

Ask for a concrete account of the capability and its demands. For the reminder, the team needs to send one message after an unanswered request reaches a certain age. Discuss timing accuracy, delivery failures, duplicate messages, and what support needs to see. Those concerns establish the problem an implementation must solve.

Then compare plausible approaches through their whole working life. The existing worker may already supply the required scheduling and operational visibility. A workflow engine may offer durable execution that would otherwise be costly to build correctly. The comparison should include those benefits alongside the new knowledge, dependencies, and operational responsibilities each option introduces.

The smallest diff can conceal substantial risk. An existing service can be unsuitable. A new abstraction can remove repeated complexity across several real consumers. Good judgment requires examining these consequences rather than choosing by novelty, familiarity, or line count alone.

Make the proposed benefit specific enough to revisit.

“The engine will let three existing processes recover safely after interruption” gives the team something to assess. “We may need workflows later” leaves the benefit open while making the cost immediate. Where demand is uncertain, the team can often preserve a clear boundary and defer a larger mechanism until there is evidence for it.

Learning deserves a deliberate place too. Engineers need opportunities to explore unfamiliar tools and ideas. A bounded experiment can answer whether an approach fits, what operating it involves, and where it fails. Give that experiment an explicit purpose and an ending. Production use should follow from what the team learned about the product's needs and its ability to own the result.

For the implementation that does proceed, ownership needs to be part of delivery.

Name the team that will operate it. Include the checks, diagnostics, documentation, and upgrade work needed to keep it useful. Make room for people beyond the author to understand its behavior. If several teams will depend on it, agree on how support and changes will work before those dependencies become difficult to unwind.

These decisions commit capacity. Recording an owner without allowing time for ownership leaves the original problem intact.

After launch, bring recurring costs back into planning. A workflow engine that repeatedly delays unrelated features deserves a fresh assessment. It may need investment, simplification, replacement, or retirement. Past implementation effort explains how the system arrived; the next decision depends on what keeping it will provide and require from here.

Give removal a credible route as well. Confirm who uses the behavior, identify what must be preserved, and retire old paths with appropriate checks. Completing a replacement includes closing the obligations attached to its predecessor. Otherwise, a successful new design leaves the team supporting both.

Recognition should include the work that reduces what the team has to carry.

A developer who uses the existing worker and meets the reminder's needs has made a design decision worth explaining. A colleague who removes an abandoned integration has reduced future upgrade and investigation work. A team that consolidates competing access rules has made later changes easier to reason about. These outcomes deserve concrete credit alongside launches and new systems.

Back at the reminder, the team examines what the workflow proposal would actually buy. The other imagined consumers have no committed requirements. The existing worker can handle the timing, and the application already records enough state to prevent duplicate sends and investigate failures.

They implement the reminder there. The tests capture the agreed behavior. Support can see when a message was attempted and what happened. The developer records the limitations that would justify revisiting the design if the product changes.

The feature delivers its value, and the team accepts an obligation it understands.

Useful software earns the effort required to keep it useful. A team that remembers this gives technical ideas a demanding and practical test: what will this enable, and what will we have to carry because we built it?