liveBook · Manning

Overproduction waste

As explained in Build High Value Software Systems

Lean waste caused by producing more, earlier, or sooner than demand requires.

Overproduction waste is building more software than is needed, earlier than needed, or faster than it can be used. It can look like progress: code is written, cases are covered, and the system appears more complete. But unused features, speculative abstractions, and extra infrastructure still have to be understood, tested, secured, and maintained. The waste is often a matter of timing, not engineering skill. section 2.4.5

The boundary is current demand. A price formatter that handles EUR and USD may be sufficient when those are the only requirements; a general formatting interface adds paths and concepts whose value depends on future demand. Ask what the extra structure solves today and what evidence supports the anticipated use. section 2.4.5

Listing 2.5 Overproduction example
// Simple requirement: format prices for EUR and USD
export function formatPrice(amount: number, currency: "EUR" | "USD"): string {
  const symbol = currency === "EUR" ? "€" : "$";
  return `${symbol}${amount.toFixed(2)}`;
}
 
// Contrast this with a future-proofed abstraction created in anticipation of broader needs:
 
//  future-proof abstraction
interface MoneyFormatter {
  format(amount: number, currency: string): string;
}
 
class IntlFormatter implements MoneyFormatter {
  constructor(private locale: string) {}
  format(amount: number, currency: string): string {
    return new Intl.NumberFormat(this.locale, {
      style: "currency",
      currency,
    }).format(amount);
  }
}

Compare the two-currency function with the general formatter; the latter is technically sound, but its additional structure needs a present justification. section 2.4.5

Overproduction is not a label for every complex solution. Overprocessing describes unnecessary sophistication in work that actually gets used; overproduction concerns output not yet needed. Other wastes can accompany it: unused logic becomes inventory to remember, while invented rules can become defects. Treat these categories as diagnostic lenses, not absolute judgments. section 2.4.6 section 3.3.2

Look for the same timing mismatch across the workflow:

  • In AI-assisted implementation, compare generated behavior line by line with the contract. An order endpoint that invents validation, business rules, or response structures leaves reviewers with decisions nobody requested. section 3.3.2 section 4.5.3
  • In code review, question major unspecified additions such as caching infrastructure; distinguish them from minor additions that may warrant a suggestion rather than a blocked merge. section 4.4.3
  • In testing, prefer checks that protect user-facing contracts over tests that merely pin implementation details or raise coverage numbers. section 5.5
  • In architecture, question services, endpoints, and infrastructure built for hypothetical scale. An unused endpoint still incurs testing, documentation, and security-review costs. section 11.7

Scaling before demand

A four-developer team splits one product into twelve microservices for 200 users, then spends three months on service discovery, gateways, tracing, and authentication without shipping a feature. Clear module boundaries in a monolith could provide separation without twelve deployable units. Extract services when observed needs justify the operational cost. section 11.7

The practical test is not whether an addition is clever or might someday help. Ask: Is it required by the current contract? What evidence says it is needed now? What will it cost to review, change, and operate if that future never arrives? Build to demonstrated demand, then expand when the demand appears. section 2.4.5 section 11.10

How Build High Value Software Systems covers it

How deep it goes
Defines the timing mismatch and works through code, review, test, and architecture examples rather than prescribing a universal size limit.
Examples
Contrasts price formatters, invented order-endpoint rules, implementation-pinning tests, and a twelve-microservice product serving 200 users.
What it assumes
Assumes familiarity with functions, tests, pull requests, and services; defines the Lean waste in software terms.
What you can do after
Diagnose/debug with it by comparing additions against current contracts and observed demand, then challenging unsupported code or infrastructure.
How it connects
Connects overproduction to overprocessing, inventory, defects, code review, contract testing, and architectural demand.

Related concepts

This explainer was generated by Manning's knowledge graph from the text of Build High Value Software Systems. The section links point to the parts of the book it draws on.