HN Debrief

Choose Boring Technology (2015)

  • Programming
  • Startups
  • Developer Tools
  • AI
  • Infrastructure

The post is a classic startup engineering essay: spend your scarce novelty budget on the parts of the business that actually differentiate you, and keep the rest of the stack as familiar and proven as possible. In 2015 that meant warning teams away from piling multiple fresh bets on top of each other just because they were fashionable. Reading it in 2026, people mostly felt the advice has aged well, especially after a decade of JavaScript churn, microservice sprawl, and infra choices that created operational drag without creating product advantage.

Treat “boring tech” as a budgeting tool, not a doctrine. When you do make a novel bet, be explicit about where the upside is, what new failure modes you are buying, and which parts of the stack must stay stable to absorb that risk.

Discussion mood

Mostly positive and nostalgic, with a pragmatic tone. People broadly agreed that the essay captured hard-won startup wisdom about limiting operational risk, though many were irritated by how easily “boring tech” becomes a lazy slogan or a blanket veto against justified change.

Key insights

  1. 01

    Risk budget beats fixed tokens

    The useful part of “innovation tokens” is the reminder that teams have limited capacity for surprise, not the idea that novelty comes in neat discrete units. Thinking in debt and risk fits real decisions better because adopting a new runtime is a huge bet while swapping an email provider may be trivial. That framing also exposes the weak point in the slogan. Teams still need to define what counts as non-boring and how much downside they can carry.

    Model technical novelty as a portfolio with different bet sizes, not as a binary allowed or forbidden choice. In planning reviews, force each proposed tool to carry an explicit risk estimate and rollback story.

      Attribution:
    • tshaddox #1
    • NickNaraghi #1
  2. 02

    Boring stack can still fail on workload

    Familiar technology is not a free pass if you push it outside the use case it handles well. The Cassandra example is a sharp warning here. It worked as a distributed append-only log, then caused pain when reused for authentication and key-value workloads just because the team already knew it. The lesson is that operational familiarity and technical fit are separate constraints, and both have to hold.

    When reusing an existing platform, evaluate the workload as aggressively as the tool choice. Add a review step that asks whether the system is staying inside the technology’s proven operating envelope.

      Attribution:
    • jason_oster #1
  3. 03

    Kubernetes is the modern false default

    Kubernetes was the clearest present-day example of “boring” being misapplied. It is common, but for many companies it still adds cryptic failure modes, configuration hazards, and a constant tax on product momentum. The sharpest comments argued that teams obsess over shaving infrastructure spend while ignoring far larger costs in engineering time and organizational complexity. A platform only counts as boring if it disappears into the background. For most startups, Kubernetes still does the opposite.

    Price infrastructure decisions against loaded engineering cost, not cloud line items alone. If a platform needs constant specialist attention and causes outages through misconfiguration, treat it as a high-novelty choice no matter how mainstream it looks.

      Attribution:
    • asa400 #1
    • rzerowan #1
    • Krei-se #1
  4. 04

    LLMs reward conventional stacks

    AI changed the meaning of boring in a concrete way. Widely used frameworks with stable conventions, uniform style, and excellent documentation are easier for models to work with, which can outweigh small language-level advantages elsewhere. Django was cited because benchmark pressure keeps vendors strong on it. Go got praise because code from different eras still looks similar. Elixir got praise because its community patterns are consistent. The underlying point is not that one language wins. It is that agent productivity tracks data density and convention quality.

    If you expect heavy AI assistance, add “model familiarity” to your stack selection checklist. Prefer ecosystems with consistent idioms, good docs, and lots of public code over stacks that are fragmented, trend-driven, or heavily customized.

      Attribution:
    • theptip #1
    • epolanski #1
    • infamia #1
    • michaelchisari #1
    • bluehatbrit #1
    • pianopatrick #1
    • westoque #1
  5. 05

    Incentives still favor shiny over stable

    A lot of bad technology choice is not ignorance. It is incentives. Resume building, status, and the visibility of heroic rescue work all push teams toward novelty, while solid infrastructure work is invisible when it succeeds. That explains why the essay keeps resurfacing. It gives managers and senior engineers a language for pushing back on career-driven or fashion-driven choices that look rational to individuals but expensive to the company.

    Do not rely on individual prudence alone. Build hiring, promotion, and architecture review criteria that visibly reward boring reliability work, not just new stack adoption or firefighting heroics.

      Attribution:
    • cliche #1
    • geodel #1
    • andai #1
    • abirch #1

Against the grain

  1. 01

    The phrase hides weak reasoning

    The strongest dissent was that “boring technology” is a sloppy proxy that encourages teams to stop thinking. A useful architecture conversation should say what is actually meant: tested, documented, familiar to the team, easy to operate, easy to migrate from, or suited to the workload. Collapsing all of that into “boring” lets people smuggle in personal preference or habit without defending it. That objection matters because vague heuristics often survive precisely when they should be challenged.

    Ban “boring” as a final justification in design docs. Require teams to translate it into concrete properties and evidence before approving a choice.

  2. 02

    Overcaution can block real learning

    A credible minority argued that strict adherence to this advice can become complacency. New tools sometimes deliver obvious capability gains, and discovering that a bet failed is still valuable information if the system is built to pivot. That view also points out that the essay has been used for years as a reflexive anti-innovation argument, long after its original context changed.

    When a new technology offers a specific advantage, run a bounded experiment instead of defaulting to no. Put time and blast-radius limits around the trial so you learn without turning the whole product into a bet.

      Attribution:
    • jason_oster #1
    • rienbdj #1
    • threethirtytwo #1
  3. 03

    Dogma can become a career trap

    Choosing familiar tools is not always the locally rational move for an individual or even for a startup trying to catch a wave. One commenter regretted turning down Node and Mongo opportunities during their growth period because of a rigid commitment to Ruby and other “boring” choices. The point is not that hype was right. It is that sometimes the market, hiring demand, or product shape changes faster than your internal rule of thumb.

    Separate company architecture policy from personal career strategy and market timing. Revisit your defaults regularly so yesterday’s prudence does not become today’s blind spot.

      Attribution:
    • insanitybit #1
    • dzonga #1

In plain english

AI
Artificial intelligence, software systems that perform tasks such as analyzing code or generating text.
append-only log
A data structure where new records are only added to the end, rather than updated or deleted in place.
Cassandra
Apache Cassandra, a distributed NoSQL database designed for high availability and large-scale writes across many servers.
Django
A Python web framework for building server-rendered and database-backed applications.
Elixir
A programming language built on the Erlang virtual machine, known for concurrency and fault tolerance.
Go
A programming language from Google focused on simplicity, fast builds, and concurrency.
Kubernetes
An open source system for deploying and managing containerized applications across clusters of machines.
PHP
A widely used server-side programming language for building web applications.
Ruby
A programming language known for developer-friendly syntax and its use with the Ruby on Rails web framework.
TypeScript
A typed superset of JavaScript that adds compile-time checks and tooling for larger codebases.

Reference links

Related essays and posts

  • Getting Freaky in the Age of AI
    Offered as a direct counterpoint that rethinks the “choose boring technology” idea in the AI era.
  • grugbrain.dev
    Shared as a related resource with a similar pragmatic, anti-complexity theme.
  • Taco Bell Programming
    Referenced as another classic essay about choosing simple, readily available tools over elaborate solutions.
  • Weirdness Points
    Linked as a parallel concept to “innovation tokens” for budgeting unusual or risky choices.

Examples and analogies

  • Beans and Noses
    Brought up during a side discussion about older metaphors for limited decision budgets.
  • Coffin corner (aerodynamics)
    Used in an aviation analogy about risky versus conservative design choices.
  • B-36 video
    Part of a long analogy contrasting conservative and high-risk engineering paths.
  • B-47 video
    Part of the same aviation analogy about ambitious but difficult designs.
  • B-52 video
    Used to illustrate a high-risk design that ended up succeeding for decades.