pnpm vs npm vs Yarn vs Bun: Speed, Disk Use and CI Gotchas (2026)

Devops & Infrastructure, Node, Tips & Tricks, and What Is

pnpm vs npm vs Yarn vs Bun: Speed, Disk Use and CI Gotchas (2026)

Short answer: pnpm is the best default for most Node.js teams in 2026, Bun is the fastest installer if you're happy adopting its runtime, npm is the zero-setup choice, and Yarn 4 makes sense mainly for teams already running Plug'n'Play. Most npm vs pnpm vs Yarn vs Bun posts stop at install speed. Speed matters, but the decision usually turns on three less obvious things: how each manager handles monorepos and workspaces, how it behaves inside a CI/CD pipeline, and what changed in the last year. npm 12, pnpm 11 and 12, and Bun 1.4 all shipped breaking defaults that can fail a build that worked last month.

If you're short on time: pnpm 12 gives you the best balance of speed, disk efficiency and Node.js compatibility. Bun 1.4 installs faster still, but treat it as a runtime decision, not a drop-in. npm 12 is the safe default that ships with Node.js, and it now blocks dependency install scripts unless you approve them. Yarn 4 is solid if you already use Plug'n'Play, and harder to justify for a new project. If you deploy through an automated deployment tool like DeployHQ, your package manager also sets the first command in your build pipeline. That's why what's fastest in CI matters more than what's fastest on my laptop.

The rest of this guide explains those tradeoffs with current version numbers, published benchmarks and the deployment gotchas we see most often.

Quick Comparison

Feature npm (v12) Yarn (v4) pnpm (v12) Bun (v1.4)
Speed Slowest of the four in vendor benchmarks Varies (PnP is fast, node_modules mode is slower) Fast Fastest in Bun's own benchmarks
Disk efficiency Copies per project PnP eliminates node_modules; node_modules mode copies Content-addressable store with hard links Global cache, hard links on Linux/Windows, clonefile on macOS
Monorepo support Workspaces Workspaces (native) Workspaces with filtering and catalogs Workspaces (isolated linker by default for new workspaces)
Lockfile package-lock.json yarn.lock pnpm-lock.yaml bun.lock
Runtime requirement Ships with Node.js; npm 12 supports Node ^22.22.2, ^24.15.0 or >=26 Node.js Node.js 22+ (since pnpm 11) None (standalone runtime)
Dependency install scripts Blocked by default since npm 12 (allowScripts) Run by default Not run unless allowed (allowBuilds since pnpm 11) Only for a default trusted list or trustedDependencies
Maturity 2010, most widely used 2016 (Classic) / 2020 (Berry) 2017 v1.0 in Sep 2023

What Changed in 2026 (and Why Your Build Might Break)

This is the section most comparisons are missing. If you last looked at package managers in 2025, these are the defaults that changed underneath you:

  • npm 12 (July 2026) blocks dependency lifecycle scripts by default. Dependencies' preinstall, install and postinstall scripts only run if the root package's allowScripts policy allows them. After installing, run npm install-scripts approve to record approvals and npm rebuild to run the newly approved scripts. Any package that compiles or downloads a native binary in postinstall will silently skip that step until you approve it. npm 12 also defaults allow-git and allow-remote to none, so Git and tarball-URL dependencies fail until you opt back in. It removes npm shrinkwrap, and unknown CLI flags now throw instead of warning.
  • pnpm 11 (April 2026) requires Node.js 22+. A build server pinned to Node 20 will fail before installing anything. It also turns on supply-chain protection by default: minimumReleaseAge is one day, so a package version published in the last 24 hours won't resolve. That's good against compromised releases, and surprising when you're hot-fixing your own package. .npmrc is now only for auth and registry settings. Everything else (hoisting, linker mode, build allow-lists) moves to pnpm-workspace.yaml.
  • pnpm 12 (August 2026) changes Git dependencies. Dependencies on GitHub, GitLab and Bitbucket now resolve through the host's canonical HTTPS URL, and the lockfile never records an SSH URL. For a private repository over SSH, you configure the machine with git config --global url."git@github.com:".insteadOf https://github.com/ rather than the project. It also flags unrecognized settings in pnpm-workspace.yaml, so a typo no longer silently disables a policy.
  • Bun 1.4 (August 2026) tightens lifecycle scripts too. Bun's default trusted-dependencies list only applies to packages from the npm registry. file:, link:, git: and github: dependencies need an explicit trustedDependencies entry to run their scripts. bun.lock now records a SHA-512 hash for GitHub and tarball dependencies.
  • Corepack no longer ships with Node.js 25+. It's bundled from Node 14.19 up to, but not including, Node 25. On newer Node versions, corepack enable only works after npm install -g corepack.

Taken together, npm, pnpm and Bun have all moved to don't run dependency scripts unless told to. That's a real security improvement after several years of npm supply-chain incidents. It also means the most common 2026 build failure isn't a slow install. It's a native module that never got built.

Setting up a fresh pipeline? With automatic deployments from Git, DeployHQ runs any of these install commands in an isolated build environment on every push, before anything reaches your server.

npm: The Default

npm ships with every Node.js installation. You don't need to install anything extra.

Strengths:

  • Zero setup, since it comes with Node.js
  • The default client for the public npm registry
  • npm audit for security vulnerability scanning
  • Deterministic installs via package-lock.json and npm ci
  • Workspaces support since v7
  • Since v12, dependency install scripts are opt-in (allowScripts)

Weaknesses:

  • Consistently the slowest in published benchmarks (see below)
  • Copies dependencies into each project's node_modules
  • Flat dependency tree can cause phantom dependencies: packages you can import but didn't explicitly install

Common commands:

npm init                        # Create a new project
npm install                     # Install all dependencies
npm ci                          # Clean, lockfile-exact install (use in CI)
npm install express             # Add a package
npm install -g typescript       # Install globally
npm run build                   # Run a script
npm audit                       # Check for vulnerabilities
npm install-scripts approve     # npm 12+: approve dependency lifecycle scripts

If you're unsure which install command belongs in your pipeline, our breakdown of npm ci vs npm install covers when each is correct.

When to use npm: Standard Node.js projects where you want the simplest setup with no extra tooling. It's a good fit for small projects and teams already comfortable with the npm ecosystem.

Yarn: Classic vs Berry

Yarn has two distinct versions that work very differently:

  • Yarn Classic (v1): the original, now in maintenance mode (latest 1.22.x)
  • Yarn Berry (v2, v3, v4): a complete rewrite with Plug'n'Play (PnP). The current line is 4.x.

Modern Yarn can eliminate node_modules entirely using PnP, which maps dependencies to zip archives. This makes repeat installs very fast and enables zero-installs, where you commit your dependency cache to Git.

Strengths:

  • PnP mode eliminates node_modules and speeds up installs
  • Excellent monorepo/workspace support, including constraints
  • Strict dependency resolution prevents phantom dependencies
  • Plugin architecture for extensibility

Weaknesses:

  • PnP requires editor setup and can have compatibility issues with some packages
  • Two incompatible versions cause confusion (Classic vs Berry)
  • node_modules mode in Berry can be slower than the alternatives
  • yarn global was removed in Berry. Use yarn dlx instead

Common commands (Yarn Berry v4):

yarn init -2                    # Create a new project with modern Yarn
yarn install                    # Install all dependencies
yarn install --immutable        # Fail if the lockfile would change (use in CI)
yarn add express                # Add a package
yarn dlx create-vite            # Run a one-off command (replaces npx)
yarn run build                  # Run a script
yarn npm audit                  # Check for vulnerabilities (Berry syntax)

Running Yarn 4 on a build server has a couple of setup steps of its own; see using Yarn 4 in the DeployHQ build pipeline.

When to use Yarn: Monorepo projects that benefit from PnP's speed and strict dependency isolation, and teams willing to invest in PnP setup for the long-term gains.

pnpm: The Disk-Efficient Option

pnpm stores every package version once in a global content-addressable store and hard-links it into each project. If ten projects use the same version of Express, the files exist once on disk.

Strengths:

  • Large disk savings on machines with many projects, because each package version is stored once
  • Faster than npm in every scenario on pnpm's published benchmarks
  • Strict node_modules structure prevents phantom dependencies
  • Excellent monorepo support with filtering, recursive commands and catalogs
  • Dependency build scripts don't run unless allowed (allowBuilds)

Weaknesses:

  • Smaller community than npm
  • Some packages that rely on hoisted node_modules need configuration
  • Hard links can occasionally confuse tools that check file identity
  • Since pnpm 11, requires Node.js 22+, and most settings have moved out of .npmrc

Common commands:

pnpm init                       # Create a new project
pnpm install                    # Install all dependencies
pnpm install --frozen-lockfile  # Fail if the lockfile is out of date (use in CI)
pnpm add express                # Add a package
pnpm add -g typescript          # Install globally (isolated per package since pnpm 11)
pnpm run build                  # Run a script
pnpm audit                      # Check for vulnerabilities

To run pnpm on DeployHQ, follow using pnpm in the build pipeline.

When to use pnpm: Projects with many dependencies where disk space matters, CI/CD environments where install speed counts, and monorepos. It's the easiest upgrade from npm because the workflow barely changes.

Bun: The All-in-One Runtime

Bun isn't just a package manager. It's a complete JavaScript/TypeScript runtime, and its package manager is one part of a toolkit that also includes a bundler, a test runner and native TypeScript execution.

Bun reached v1.0 in September 2023 and is now on the 1.4 line. It's used in production by major companies, including Anthropic (for Claude Code).

Strengths:

  • The fastest installer in Bun's own published benchmarks (see below)
  • Native TypeScript and JSX support without a separate transpile step
  • Built-in bundler and test runner
  • Compatible with npm packages and node_modules; installs from a global cache using hard links (Linux/Windows) or clonefile (macOS)

Weaknesses:

  • Not 100% Node.js API compatible. Bun says so itself, though core modules like node:http, node:fs and node:stream pass the large majority of Node's own tests
  • Smaller ecosystem of Bun-specific tooling
  • Requires its own runtime (not a drop-in for Node.js in every case)
  • Lockfile format (bun.lock) differs from npm/Yarn/pnpm

Common commands:

curl -fsSL https://bun.sh/install | bash   # Install Bun
bun init                                     # Create a new project
bun install                                  # Install all dependencies
bun ci                                       # Same as bun install --frozen-lockfile (use in CI)
bun add express                              # Add a package
bun add -g typescript                        # Install globally
bun run build                                # Run a script
bun run index.ts                             # Execute TypeScript directly

For a deeper command reference covering install, build, test, Docker patterns and CI lockfile discipline, see our Bun cheatsheet. To run it on a build server, see using Bun with the DeployHQ build pipeline.

When to use Bun: Performance-sensitive projects, TypeScript-first codebases, and teams that want one tool for runtime, package management, bundling and testing.

What the Published Benchmarks Actually Say

We haven't run our own benchmark for this article. Instead, here's what the two most-cited vendor benchmarks report, with their methodology. Both are run by the tool's own maintainers, so read them as best-case numbers for that tool, not neutral results.

pnpm's benchmark (pnpm.io/benchmarks, linked above, regenerated regularly; figures below from the November 2026 run) installs a large dependency set (alotta-packages) on one machine over an emulated 50ms / 200Mbps link, taking the fastest of three runs. It compares npm and pnpm only, not Yarn or Bun:

Scenario npm 12.2 pnpm 12.21
Clean install (nothing cached) 1m 44s 14.4s
Lockfile present (CI first install) 29.7s 9.01s
Cache + lockfile (reinstall existing project) 20.5s 2.60s

Bun's benchmark (Bun 1.4 release post) installs a T3-stack Next.js app (about 220 packages in the lockfile) on Linux x64, taking the median of three runs. On a first install with no cache, no lockfile and no node_modules, it reports Bun at 1.41s, npm 12.0.2 at 18.1s, pnpm 11.21.0 at 13.5s and Yarn 1.22 (Classic, not Yarn 4) at 20.5s.

Two things to take from these. First, the gap between npm and the rest is real across both benchmarks. Second, the scenario that matters for deployments is lockfile present, cache warm or restored. That's where caching dependencies between builds often saves more time than switching package managers.

pnpm vs npm: Key Differences

Bottom line: pnpm is the better choice for most projects. It's faster in every scenario pnpm benchmarks, stores each package version once on disk, and handles monorepos natively. Migrating from npm usually takes minutes, but check that your build server runs Node.js 22+ first.

This is the most common comparison developers face when they outgrow npm's defaults. Here's how they stack up head-to-head:

Criteria npm pnpm
Install speed Slower in every published scenario Several times faster on pnpm's benchmark (table above)
Disk usage Full copy per project One copy per package version, hard-linked into projects
Phantom dependencies Possible (flat node_modules) Prevented (strict node_modules structure)
Dependency install scripts Blocked by default since npm 12 Not run unless allowed (allowBuilds)
Monorepo support Workspaces Workspaces with filtering, recursive commands, catalogs
CI install command npm ci pnpm install --frozen-lockfile
Migration effort N/A (default) Low: run pnpm import to convert package-lock.json, or delete it and reinstall

The practical difference: On a monorepo with 15 packages sharing Express, Lodash and React, npm copies each dependency into the node_modules tree it builds. pnpm stores them once in its store and hard-links them. The result is faster installs, less disk space, and no phantom dependency surprises.

When pnpm wins clearly: CI/CD pipelines (faster means cheaper), monorepos, machines with many Node projects, and teams who've been bitten by phantom dependencies.

When npm is fine: Solo projects, tutorials and learning, and teams that don't want to change their workflow.

Yarn vs npm: Which Should You Choose?

Bottom line: Yarn's PnP mode outperforms npm, but the complexity trade-off only pays off if your toolchain fully supports it. For most teams starting fresh, pnpm is a simpler upgrade from npm than Yarn Berry.

Facebook created Yarn in 2016 to address npm's early weaknesses: unreliable installs, no lockfile, and poor performance. npm has since caught up on reliability, while Yarn (v4) moved in a different direction with Plug'n'Play.

Criteria npm Yarn (v4 Berry)
Install speed Slowest Fast with PnP; comparable in node_modules mode
Zero-installs Not supported Supported (commit .yarn/cache to Git)
Dependency resolution Flat (allows phantom deps) Strict (PnP prevents phantom deps)
Plugin ecosystem None Extensible via plugins
Learning curve Minimal Moderate (PnP concepts, editor setup)
CI install command npm ci yarn install --immutable

The honest take: Yarn's PnP mode is powerful but adds complexity. If your IDE, testing tools and CI pipeline all support PnP, the zero-install workflow is genuinely fast. If you've hit PnP compatibility issues, many teams find pnpm a smoother alternative that still solves npm's core problems.

When Yarn wins: Teams already invested in PnP, projects using zero-installs, and monorepos that rely on Yarn's workspace plugins and constraints.

When npm is fine: You're starting a new project and don't want to debug PnP compatibility issues.

Bun vs npm: Speed vs Stability

Bottom line: Bun installs far faster than npm in Bun's own benchmark, and it bundles a runtime, bundler and test runner into one binary. Choose Bun for new TypeScript projects. Stick with npm if you need guaranteed Node.js API compatibility.

Criteria npm Bun
First install (Bun 1.4 benchmark) 18.1s 1.41s
Runtime included No (Node.js separate) Yes (runtime + bundler + test runner)
TypeScript support Via transpiler (tsc, tsx) or Node's type stripping Native, no config needed
Node.js compatibility 100% Not 100% yet, by Bun's own account
Dependency install scripts Blocked by default (npm 12) Default trusted list + trustedDependencies
CI install command npm ci bun ci

Benchmark figures are from the Bun 1.4 release post (T3-stack Next.js app, Linux x64, median of three runs), as described above.

The trade-off: Bun is dramatically faster and includes more out of the box. npm is the safe choice with universal compatibility. Most web applications run fine on Bun, but test the specific Node APIs your app uses before switching production traffic.

When Bun wins: New projects, TypeScript-heavy codebases, teams who value developer experience, and anyone tired of configuring separate tools for transpilation, bundling and testing.

When npm is fine: Legacy Node.js projects with specific API dependencies, conservative teams, or environments where Bun isn't available yet.

Bun vs pnpm

Bottom line: Bun is the faster installer in Bun's benchmark, and both avoid npm's copy-everything approach to disk. Choose Bun if raw speed and an all-in-one toolkit are your priority. Choose pnpm if you want to stay on Node.js and need the most mature monorepo tooling.

Both are significant upgrades over npm. The question is whether you prioritize raw speed and an integrated toolkit (Bun) or full Node.js compatibility and monorepo orchestration (pnpm).

Criteria pnpm Bun
First install (Bun 1.4 benchmark) 13.5s (pnpm 11.21) 1.41s
Disk efficiency Content-addressable store, hard links Global cache, hard links (Linux/Windows) or clonefile (macOS)
Strict node_modules Yes, by default Opt-in with --linker=isolated (default for new workspaces)
Node.js compatibility Full (runs on Node.js 22+) Standalone runtime, not 100% Node-compatible yet
Monorepo support Best-in-class (filtering, recursive commands, catalogs) Good (workspaces, catalogs)
Extras Package manager only Runtime + bundler + test runner included

When Bun wins: Greenfield TypeScript projects, rapid prototyping, and teams that also want a bundler and test runner in one tool.

When pnpm wins: Existing Node.js projects, large monorepos with complex dependency graphs, CI/CD pipelines where caching the pnpm store across builds saves more time than raw speed alone, and teams managing dozens of projects on one machine. If you're weighing this for a monorepo, our guide to monorepo deployment strategies with Nx and Turborepo covers the deploy side.

pnpm vs Yarn

Bottom line: pnpm is simpler to adopt and avoids PnP's compatibility friction. Yarn Berry's PnP mode is technically impressive, but most teams don't need it. Choose pnpm unless you're already committed to Yarn's PnP ecosystem.

Both fix npm's core weaknesses, phantom dependencies and slow installs, through different approaches. pnpm uses a content-addressable store with hard links. Yarn Berry replaces node_modules entirely with PnP zip archives.

Criteria pnpm Yarn (v4 Berry)
Install speed Several times faster than npm (pnpm benchmark) Fast with PnP; slower in node_modules mode
Disk savings One copy per version via hard-linked store PnP eliminates node_modules; node_modules mode copies
Migration from npm Minutes (pnpm import, then install) Longer (PnP needs editor and tool configuration)
Compatibility Works with nearly all npm packages PnP can break packages that assume node_modules
Monorepo tooling Filtering, recursive commands, workspace protocol, catalogs Workspace plugins, constraints, PnP isolation

When pnpm wins: Teams migrating from npm who want immediate speed and disk benefits with minimal setup, CI/CD environments, and projects using packages that don't support Yarn PnP.

When Yarn wins: Teams already running PnP with zero-installs in production, and projects that benefit from Yarn's plugin architecture for custom workspace constraints.

Bun vs Yarn

Bottom line: Bun is faster and simpler for new projects. Yarn Berry with PnP and zero-installs is the main scenario where Yarn still competes.

Criteria Yarn (v4 Berry) Bun
Cold install speed Moderate (PnP), slower (node_modules mode) Fastest in Bun's benchmark
Runtime Requires Node.js Standalone (runtime + bundler + test runner)
TypeScript Via transpiler Native, zero config
Ecosystem maturity 10 years (Classic + Berry) 3 years since v1.0

Note that Bun's published comparison uses Yarn Classic (1.22), not Yarn 4, so it doesn't tell you how Bun compares with Yarn 4 in PnP mode.

When Bun wins: New projects, TypeScript-first teams, and anyone who values simplicity and speed over Yarn's PnP architecture.

When Yarn wins: Existing PnP-based projects with zero-installs configured, and teams invested in Yarn's plugin ecosystem.

How Package Manager Choice Affects Deployment

Your choice of package manager directly shapes your deployment pipeline. Here's what matters:

Use the lockfile-exact install command. In CI, run npm ci, yarn install --immutable, pnpm install --frozen-lockfile or bun ci. Each one fails if the lockfile and package.json disagree, instead of quietly resolving new versions on the build server. DeployHQ's build pipelines run any shell command, so all four work. For an npm-specific walkthrough, see using npm in a CI/CD pipeline and using Node.js and npm with the DeployHQ build pipeline.

Commit the lockfile. Always commit package-lock.json, yarn.lock, pnpm-lock.yaml or bun.lock to Git, so your build server installs the exact versions you tested. If you deploy from GitHub to your server or from GitLab, DeployHQ picks up the lockfile with the rest of the repository.

Approve install scripts before you upgrade. On npm 12, pnpm and Bun, dependencies that build native code in postinstall won't run that step until you allow them. Record the approvals locally (npm install-scripts approve, allowBuilds in pnpm-workspace.yaml, or trustedDependencies in package.json), commit them, and the build server will behave the same way.

Pin the Node.js version. pnpm 11+ needs Node.js 22+, and npm 12 needs Node ^22.22.2, ^24.15.0 or >=26. Set the Node version explicitly in your build environment. Our guide to Node.js version managers compares the options.

Check private Git dependencies. npm 12 refuses Git dependencies unless allow-git is set, and pnpm 12 resolves GitHub/GitLab/Bitbucket dependencies over HTTPS by default. If you pull private packages from Git, review your auth setup against our guide to private repository dependencies with npm and SSH.

Cache dependencies between builds. A faster installer helps, but not reinstalling at all helps more. DeployHQ's Build Cache restores dependency directories such as node_modules between deploys and refreshes them when lockfiles change. If you're running continuous deployment on every push, this is usually where the biggest time savings are.

Docker layer caching. If you Dockerize a Node.js app, copy the lockfile and package.json first, run the install, then copy your source code. The dependency layer stays cached and only rebuilds when the lockfile changes. This works the same way for all four managers.

Ready to wire this up? Create a DeployHQ project, add your install and build commands, and deploy on every push.

Installing Each Package Manager

npm ships with Node.js, so there's nothing extra to install:

node -v    # Verify Node.js (and npm) is installed
npm -v     # Check npm version

Yarn and pnpm can be installed via Corepack or independently. Bun has its own installer:

# Via Corepack (bundled with Node.js 14.19 up to, but not including, Node.js 25)
corepack enable
corepack prepare yarn@stable --activate
corepack prepare pnpm@latest --activate

# On Node.js 25+, install Corepack first
npm install -g corepack

# Or install independently
npm install -g yarn
npm install -g pnpm
curl -fsSL https://bun.sh/install | bash    # Bun has its own installer

FAQ

Q: Can I switch package managers mid-project? A: Yes. pnpm can convert an existing lockfile with pnpm import. Otherwise, delete your existing lockfile and node_modules, then run install with the new manager, which generates its own lockfile. Re-check install-script approvals and test thoroughly before deploying.

Q: Is pnpm better than npm? A: For most projects, yes. pnpm is faster in every scenario on its published benchmark, stores each package version once on disk, and prevents phantom dependency issues. The trade-offs are a smaller community, a Node.js 22+ requirement since pnpm 11, and occasional configuration for packages that assume a flat node_modules. For straightforward projects where you don't hit those pain points, npm works fine.

Q: Why is pnpm faster than npm? A: pnpm keeps one copy of each package version in a content-addressable store and hard-links it into projects, so it skips redundant downloads and file copies. npm writes a full copy of every dependency into each project's node_modules, which is slower and uses more disk space.

Q: Should I use Yarn or npm in 2026? A: For a new project, npm or pnpm is usually the better choice. Yarn Classic (v1) is in maintenance mode and shouldn't be used for new projects. Yarn Berry (v4) with PnP is powerful but adds complexity. Unless your team already uses Yarn's PnP ecosystem, pnpm gives you similar benefits with less friction.

Q: Is Bun ready for production? A: For most web applications, yes, and it's used in production by companies including Anthropic. Bun itself says it isn't 100% Node.js-compatible yet, so test the specific Node APIs and native modules your app relies on before moving production traffic.

Q: What is the best Node.js package manager in 2026? A: It depends on your priorities. pnpm offers the best balance of speed, disk efficiency and compatibility. Bun is fastest but means buying into its runtime. npm is the zero-setup default. Yarn is best for teams already committed to PnP.

Q: Which is best for CI/CD pipelines? A: pnpm and Bun install fastest, and all four support lockfile-exact installs (npm ci, yarn install --immutable, pnpm install --frozen-lockfile, bun ci). In practice, caching dependencies between builds matters as much as the installer you pick. DeployHQ's build pipelines work with all four.

Q: Why did my build break after upgrading npm or pnpm? A: The usual suspects in 2026: npm 12 blocking dependency install scripts by default, npm 12 refusing Git dependencies until allow-git is set, pnpm 11 requiring Node.js 22+, pnpm 11 ignoring non-auth settings in .npmrc, or pnpm 11's one-day minimumReleaseAge hiding a version published in the last 24 hours.

Q: Can I use pnpm with existing npm packages? A: Yes. pnpm uses the same npm registry and works with the vast majority of npm packages. Packages that rely on hoisted dependencies may need nodeLinker: hoisted or shamefullyHoist: true. Since pnpm 11, those settings go in pnpm-workspace.yaml, not .npmrc.

Q: Do I need to install Node.js to use Bun? A: No. Bun is a standalone runtime. However, if your project depends on Node.js-specific APIs that Bun doesn't fully support, you may still need Node.js installed alongside Bun.

Q: Which package manager does DeployHQ recommend? A: DeployHQ works with all major package managers. Choose based on your project's needs; the build pipeline runs whichever install command you configure. Pick based on the tradeoffs above.

Q: Is Yarn Classic (v1) still supported? A: Yarn Classic is in maintenance mode and receives only critical fixes. New projects should use Yarn Berry (v4) or consider pnpm.


Your package manager is the foundation of every build. Whether you stick with npm's simplicity, adopt pnpm's efficiency or go all-in on Bun's speed, what matters is that your deployment pipeline handles it reliably. Once your dependencies are sorted, the next decision is your application server. Our comparison of Node.js application servers covers Express, Fastify, Hono and more.

Try DeployHQ free: configure your build pipeline with any package manager and deploy on every push. See plans and pricing for team options.


Questions? Reach out at support@deployhq.com or @deployhq.