Person working at a terminal with multiple screens showing code and system output
Technology Oct 26, 2026 • 15 min read

DLL Hell Was Almost a Fairytale: Seven Hours Into a Thirty-Minute Build

From DLL Hell to npm, pinned runtimes, Docker, Kubernetes, and agentic coding: how modern software builds became a dependency trap.

Share:
Lee Foropoulos

Lee Foropoulos

15 min read

Continue where you left off?
Text size:

Contents

There was a time when software broke because a library was missing. Now it breaks because six pipelines disagree about which version of the universe they're running.

I'm on hour seven of deploying something that should have been a 30-minute build followed by a test. I'm writing this article while the deployment is still consuming my day.

To be clear, the application itself did not suddenly become seven hours more sophisticated. Most of the effort is outside the application: dependencies, runtime versions, build tooling, pipelines, environment parity, and the peculiar art of getting all of them to stop arguing long enough to produce a deployable artifact.

If you've been in this industry long enough to remember DLL Hell, congratulations. You survived the original.

The sequel has a larger cast, a distributed architecture, and monthly subscription fees.

A stylized missing-library error from the DLL Hell era beside a modern npm dependency-resolution failure and four disagreeing pipelines
Then: one missing file and an OK button. Now: a dependency tree that will not resolve and pipelines that disagree about the answer.
7
Hours into a deployment expected to be a 30-minute build and test. A firsthand account, not an industry benchmark

Once upon a time, in a Windows directory far, far away

In the 1990s and early 2000s, Windows applications commonly relied on shared Dynamic Link Libraries: DLLs. Sharing code saved memory and disk space, but it created a delightful problem. One application could install or overwrite a shared library with a version that another application could not use.

Install Program B. Break Program A. Reinstall Program A. Break Program B. Discover that the printer is now involved for reasons nobody can explain.

That was DLL Hell: incompatible shared components, version conflicts, missing files, and unpredictable application behavior when a seemingly unrelated installation changed the environment. Microsoft's own DLL documentation catalogs these failure modes.

Microsoft did not just shrug and tell everyone to reboot harder. Windows File Protection, private DLLs, assembly manifests, and side-by-side assemblies reduced shared-library conflicts by allowing applications to carry or select compatible components. The .NET and Windows isolation approaches were meaningful engineering improvements.

They did not make dependency management disappear. They made one particular category of dependency collision more manageable.

DLL Hell was a fight over which library lived on the machine. Modern dependency hell is a fight over which entire machine the build thinks it's on.

And then we moved more and more development onto package registries, application frameworks, automation platforms, and cloud infrastructure.

We solved the neighborhood dispute by building a city.

The package manager was supposed to save us

Enter package managers: npm for JavaScript, pip for Python, and a long supporting cast of ecosystems with their own resolvers and conventions. Instead of manually tracking every library, developers could declare dependencies and let software resolve the rest.

That was a huge improvement. A developer can now assemble capabilities in minutes that once demanded weeks of engineering.

There was just one small detail: your dependencies also have dependencies. And those dependencies have their own requirements, maintainers, release schedules, platform assumptions, and occasional existential crises.

A modest application can acquire an impressive transitive dependency graph without its author ever explicitly choosing most of the packages inside it. The machine resolves the graph; the team inherits it.

A dependency graph in which an application directly chooses three packages and inherits dozens more beneath them
Illustrative, not a real project. The three packages you chose are the visible tip of what the build has to resolve.

On March 22, 2016, a tiny JavaScript package called left-pad was unpublished from npm. The resulting failures cascaded through many thousands of projects, according to npm's own incident account. The registry later restored the package and changed its unpublishing rules.

The lesson was not that padding a string is technically difficult. It was that a tiny piece of software, buried deep in a dependency chain, had become critical infrastructure to people who did not even know it existed.

The left-pad moment

A dependency doesn't need to be important to your product to become important to your ability to ship your product. That's the difference between code complexity and dependency criticality.

Our first response to the problem was reasonable: add better version metadata, resolve dependencies more carefully, and lock known-good versions.

And then the locks became their own engineering discipline.

Pin everything. Then remember to unpin it. Then pin it again.

Semantic Versioning gives us major, minor, and patch numbers to express intended compatibility. The SemVer specification even calls out the two failure modes: constraints that are too tight create version lock; constraints that are too loose expose projects to unexpected incompatibilities.

In theory, an application states what it can accept, a resolver finds a valid combination, and everybody goes home.

In practice, package compatibility is a promise written by humans, interpreted by machines, and tested against reality on a Tuesday afternoon.

So we pin a dependency. Then we pin the package manager. Then the runtime. Then the operating-system image. Then the build action. Then a transitive package because one of the other pins no longer agrees with reality.

The fix becomes a fossil record of every environment that ever successfully completed the build.

A pinned dependency tree can be reproducible, secure, insecure, broken, or obsolete. Reproducible only means you can get the same result again.

Take npm's package-lock.json. It is useful: it records a dependency tree and its resolved versions. The official npm ci command is designed for automated, frozen installs and fails instead of silently rewriting an inconsistent lockfile.

That's a feature, not a bug. But a lockfile cannot promise that every locked package is safe, that every build tool agrees on the runtime, or that tomorrow's security requirements will let you keep the same dependency versions forever.

Pinning reduces surprise today. Maintaining those pins becomes tomorrow's work.

Welcome to the runtime witness protection program

Here is where the issue stops resembling an installation problem and starts resembling an organizational structure.

A team might have a frontend build that expects one Node.js runtime, a test suite using another, an older deployment action coupled to a third, and a Python service whose native dependencies were built for a different interpreter or Linux library stack.

Individually, the choices can be defensible. Compatibility testing across versions is important. Maintaining an older production runtime during a planned migration can be responsible engineering.

The problem emerges when nobody owns the combined compatibility contract.

You end up with pipelines named things like:

  • build-current. Works with the current runtime if the lockfile is untouched.
  • test-legacy. Runs on an older runtime because a plugin hasn't migrated.
  • deploy-prod. Requires a separate container base image.
  • deploy-staging. Nearly identical, except it uses a different action version and an environment variable from an archaeological era.

The deployment is no longer a single repeatable process. It is a collection of historical truces.

Four example pipelines named build-current, test-legacy, deploy-prod and deploy-staging, each resting on different runtime, image or action assumptions
Each pipeline is defensible on its own. The failure is that nobody owns the combined compatibility contract.

One pipeline goes green; another fails. Somebody upgrades the runner and the install changes. The application passes local tests, but the production container cannot load a native module. An emergency fix works until the next pipeline run rebuilds an artifact from a different combination of tools.

You are not debugging the application anymore. You are debugging the lineage of its environment.

A successful build is not a universal compatibility certificate

A green pipeline proves something about the source, dependencies, tools, and environment used in that run. It doesn't prove that a different runner, runtime, image, architecture, or deployment target will behave identically.

Python developers know their version of the story. pip's documented resolver can backtrack through package candidates when version constraints conflict. That's legitimate solving behavior, not necessarily a broken installer; it's also a useful reminder that dependency resolution is real computational work, not a ceremonial progress bar.

We put the problem in containers. Then we orchestrated the containers.

Virtual environments and containers were major improvements. They helped isolate application dependencies, package runtimes with software, and make deployments more consistent.

They were also an invitation to expand the stage.

A container can package an application and its userspace dependencies, but the build still has inputs: base images, registries, build tools, architecture, secrets, and network-accessible packages. A container does not repeal the kernel, the host, or upstream dependency maintenance.

Even a version-looking image tag can move. Docker recommends pinning images to immutable digests for stronger reproducibility, while explicitly noting the tradeoff: now you must actively update those digests to receive fixes.

And when one container becomes a fleet of containers, Kubernetes adds a very real operating environment with API versions, cluster components, operators, manifests, charts, and upgrade ordering. Its official version-skew policy specifies which component versions can safely coexist.

This is important infrastructure that solves important problems at scale.

It is also infrastructure that has to be maintained even when the feature request was simply, "Can we change the color of that button?"

Docker made an application portable. Kubernetes made a collection of applications manageable. Neither promised that the entire software supply chain would stop evolving.

The same dependency can now break your build and compromise your machine

In the old days, a DLL conflict might prevent an application from launching. Modern supply-chain exposure can be much worse than a missing-file dialog.

On March 31, 2026, attackers used a compromised maintainer account to publish malicious versions of the widely used Axios npm package: 1.14.1 and 0.30.4. The releases introduced a malicious dependency named plain-crypto-js designed to deploy a remote-access trojan across operating systems.

The facts are documented in the Axios maintainer's postmortem and CISA's alert.

Nobody needed to intentionally install a package called "please compromise my workstation." The harmful behavior arrived inside what appeared to be a routine package update.

2
malicious Axios versions, 1.14.1 and 0.30.4, published on March 31, 2026 through a single compromised maintainer account

Reproducible does not mean trustworthy

A perfectly repeatable build can repeat a vulnerable or malicious dependency. Integrity checks, dependency review, trusted publishers, isolated CI, and restricted credentials address different risks than merely freezing versions.

So the modern dependency debate isn't only about developer frustration. It includes operational resilience, developer-machine security, build-system trust, and the ability to patch a problem without breaking a dozen adjacent things.

That's considerably more responsibility than figuring out which copy of foo.dll Windows decided to load.

And now the agents are writing more of the infrastructure

This is the part that deserves a longer conversation.

Agentic development has remarkable potential. An AI coding agent can implement a feature, create tests, modify configuration, wire up services, and iterate against failures much faster than a human typing every line.

But increasing the rate at which we create software does not automatically increase the rate at which we can safely understand and maintain its dependencies.

An agent can introduce a new library because it makes the task easier. A second agent can add a service to accommodate the library. A third can add a container because the service wants its own runtime. A fourth can create a new pipeline to deploy the container. Then another agent maintains all of it because the human team is now too busy managing the outputs to keep up with the internals.

What began as automation becomes an expanding dependency on the automation itself.

The danger is not that machines can write code. It's that machines can generate infrastructure obligations faster than organizations establish the boundaries for owning them.

There is already a measurable class of risk in this area. A 2025 USENIX Security study examined 576,000 code samples from 16 language models and documented package hallucinations: model-generated recommendations for packages that did not exist. Those names can become attractive targets for attackers who publish packages under them. The measured rates varied by model and experimental setting; they are not a prediction about every agent or every development team.

576,000
code samples from 16 language models examined for package hallucinations in a 2025 USENIX Security study

Agents can help audit dependency graphs, identify upgrades, and enforce constraints. The issue is what happens when we authorize them to expand a system faster than we can validate its shape, necessity, and trust boundaries.

The result can be a self-reinforcing loop:

  1. Faster code generation produces more integrations and infrastructure.
  2. More integrations create more version, security, and runtime constraints.
  3. More constraints justify additional automation to maintain them.
  4. The organization becomes increasingly dependent on the machines that built the complexity in the first place.
The agentic dependency loop: faster code generation creates more integrations, which create more constraints, which justify more automation, which deepens dependence on the machines
A loop that feeds itself. The way out is not fewer agents, it is boundaries on what they may add.

That's not an argument against agentic engineering. It's an argument against mistaking machine-managed complexity for reduced complexity.

The agentic paradox

A machine can keep a sprawling system running long after its operators have stopped being able to explain all the moving parts. That may feel like scalability. Right up to the moment the machine cannot repair the thing it created.

The state of things: faster creation, slower confidence

The modern toolchain is genuinely powerful. Open-source package ecosystems, containers, reproducible builds, automation, and orchestrators are why small teams can deliver systems that were once the exclusive territory of very large organizations.

But every abstraction creates a contract with the layer below it. More layers mean more contracts to coordinate, update, secure, and eventually retire.

The actual cost is not just install time. It's the hours spent rehearsing compatibility: holding back one runtime, pinning another, splitting CI workflows, promoting an artifact that was built somewhere different from where it was tested, and investigating why a dependency update changed behavior in a service that nobody touched.

Worse, the maintenance work rarely announces itself when a dependency is introduced. It shows up months later as a supposedly simple deployment that has transformed into a full-day expedition.

We made writing software easier. We did not make owning every piece of software we depend upon free.

Best practices, or at least a smaller blast radius

There isn't one magic flag that ends dependency hell. --force is especially not a governance strategy. A few habits do, however, prevent an inconvenient update from becoming an unplanned archaeological dig.

Dependency-Hell Damage Control 0/8

Those practices don't eliminate the underlying problem. They make the problem visible enough that someone can manage it before it manages the organization.

A thirty-minute build, seven hours later

I started today expecting to build something, deploy it, run a test, and get back to the real work.

Instead, I'm on the seventh hour of persuading an ecosystem of runtimes, dependency versions, and pipelines to recognize a valid configuration.

It's almost funny when you remember the old days.

Back then, you could spend hours looking for a missing DLL.

Today, you can spend hours proving that you have exactly the right versions of everything. And still discover that the wrong pipeline built the thing you're trying to deploy.

We've accomplished extraordinary things in software engineering. We've also built systems where it takes remarkably little effort to create a dependency and a remarkable amount of effort to escape one.

DLL Hell was almost a fairytale. We didn't eliminate dependency hell. We distributed it, containerized it, orchestrated it, and started assigning AI agents to keep the lights on.

So, developers: what's been worse in your experience. Classic DLL Hell, npm, Python packaging, container builds, or the CI/CD and Kubernetes layers above them? And at what point did your deployment tooling start taking longer to maintain than the application?. Thesecretchief


Sources and further reading

How was this article?

Share

Link copied to clipboard!

You Might Also Like

Lee Foropoulos

Lee Foropoulos

Business Development Lead at Lookatmedia, fractional executive, and founder of gotHABITS.

🔔

Never Miss a Post

Get notified when new articles are published. No email required.

You will see a banner on the site when a new post is published, plus a browser notification if you allow it.

Browser notifications only. No spam, no email.

0 / 0