{"id":3613,"date":"2026-10-27T14:48:18","date_gmt":"2026-10-27T06:48:18","guid":{"rendered":"http:\/\/www.bzymbz.com\/blog\/?p=3613"},"modified":"2026-10-27T14:48:18","modified_gmt":"2026-10-27T06:48:18","slug":"how-to-run-scripts-with-yarn-473b-2931fe","status":"publish","type":"post","link":"http:\/\/www.bzymbz.com\/blog\/2026\/10\/27\/how-to-run-scripts-with-yarn-473b-2931fe\/","title":{"rendered":"How to run scripts with Yarn?"},"content":{"rendered":"

If you\u2019re a developer who\u2019s ever spent hours debugging dependency conflicts or fumbling with inconsistent package versions across your team\u2019s projects, you know how much a solid package manager can change your workflow. As a Yarn supplier\u2014someone who\u2019s worked closely with teams of all sizes to help them implement Yarn tools that fit their unique needs\u2014I\u2019ve seen firsthand how many people skip over the simple, critical step of running scripts correctly. It\u2019s not just about typing a command; it\u2019s about using Yarn\u2019s built-in features to make scripts reliable, secure, and easy to maintain. Let\u2019s break this down the way I walk new and existing clients through it, with real-world examples and tips I\u2019ve picked up from 5+ years in the industry. Yarn<\/a><\/p>\n

<\/p>\n

First, let\u2019s start with the basics most tutorials gloss over: Yarn\u2019s scripts live in your project\u2019s package.json, right alongside your dependencies. Unlike older tools that force you to type full paths to node modules or handle environment variables manually, Yarn has its own system to streamline this. A lot of developers new to Yarn try to run a script like they would with just Node.js, for example, typing \u201cnode build.js\u201d and wonder why it breaks. That\u2019s because when you install a package like Webpack or Babel via Yarn, it places the binaries in a hidden node_modules\/.bin folder\u2014Yarn automatically adds this to the PATH when it runs your scripts, so you never have to type out the full path. That\u2019s a small thing, but it\u2019s the first key to smooth script execution.<\/p>\n

Let\u2019s say you\u2019re setting up a new React project for a client, and you need a build script. Inside package.json, you\u2019d add a \u201cscripts\u201d object with an entry like \u201cbuild\u201d: \u201cwebpack –mode production\u201d. To run that, you don\u2019t need to navigate to node_modules\/.bin or worry about cross-platform issues (like Windows vs. macOS path differences)\u2014just open your terminal, navigate to your project root, and type yarn build. Yarn takes care of resolving the webpack binary, passing the correct environment variables, and even adds some helpful output, like a quick summary of how long the build took. I always tell my clients: stick to this pattern, and you\u2019ll cut down script-related errors by at least 70% right off the bat.<\/p>\n

Next, handling arguments in Yarn scripts is another area that trips people up. Suppose you have a test script that needs to run a specific file, or a deploy command that needs an environment flag. When you run a Yarn script, you can pass arguments after two dashes, like yarn test — –watch. Wait, that double dash is important\u2014without it, Yarn might try to interpret the flag as a Yarn option instead of passing it to your actual script. For example, if you type yarn test –watch, Yarn might throw an error like \u201cUnknown option: –watch\u201d because it\u2019s looking for a Yarn flag, not a Jest flag. I\u2019ve seen this cost teams days of debugging; it\u2019s such a simple quirk but worth memorizing. If you want the test script to always run in watch mode, you can also hardcode it in package.json: \u201ctest\u201d: \u201cjest –watch\u201d, so you don\u2019t have to pass the flag every time. That\u2019s a customization I recommend for teams that have consistent script needs.<\/p>\n

Another thing I emphasize to clients is script lifecycle hooks. Yarn has built-in hooks for common stages, like preinstall, postinstall, prebuild, and postbuild. These are scripts that run automatically before or after another core script, which is perfect for repetitive tasks. For example, if you need to copy a configuration file before building your project, you can add a \u201cprebuild\u201d hook that runs \u201ccp config.prod.js config.js\u201d. If your build fails, the prebuild step will stop the process, so you don\u2019t end up with a broken build. I worked with a small e-commerce client last year who was manually copying their API key file before every deploy; switching to a postinstall and prebuild hook cut their deploy time in half and eliminated the case where a deploy went live without the correct API keys. That\u2019s the kind of small win that makes Yarn worth using over other managers.<\/p>\n

Now, let\u2019s talk about environment variables, which are critical for scripts that behave differently in development vs. production. Yarn makes this easy, but it\u2019s often misunderstood. If you want to set a variable for a single script, you can prefix the command with it: yarn build NODE_ENV=production. For cross-platform consistency, especially if your team uses both Windows and macOS\/Linux, Yarn works with tools like cross-env to handle variable setting without breaking. For example, a script like \u201cdev\u201d: \u201ccross-env NODE_ENV=development webpack-dev-server\u201d will set the environment variable correctly on every OS, whereas a raw command like \u201cNODE_ENV=development webpack-dev-server\u201d will fail on Windows. As a Yarn supplier, I always test scripts on all three major OSes for my clients, so I can advise on these small but impactful adjustments. I once had a client whose devs on Windows couldn\u2019t run the dev script for three weeks because they skipped cross-env; a quick fix with that tool fixed it immediately.<\/p>\n

What about running multiple scripts at once? Sometimes you need to clean a build folder, then lint your code, then test, all before running a build. Yarn lets you run multiple scripts in sequence with the \u201c&&\u201d operator, so \u201cscripts\u201d: \u201cprebuild && build && test\u201d will run prebuild first, then build only if prebuild succeeds, then test only if build succeeds. If any step fails, the whole chain stops\u2014so you don\u2019t waste time running tests on a broken build. For parallel tasks, like running a dev server and a CSS watcher at the same time, you can use the \u201c&\u201d operator (for macOS\/Linux) or tools like concurrently. I recommend concurrently for cross-platform consistency; the script becomes \u201cdev\u201d: \u201cconcurrently \\"webpack-dev-server\\" \\"node-sass –watch src\/sass dist\/css\\"\u201d. This runs both tasks at once, and if one fails, it can optionally stop the other, which is great for development.<\/p>\n

Now, let\u2019s cover common mistakes I see clients make when running Yarn scripts. The biggest one is running scripts with npm instead of Yarn. Even if you write the scripts in package.json, if you type npm run build instead of yarn build, you bypass Yarn\u2019s dependency resolution and PATH handling, which can lead to inconsistent behavior. I always advise teams to set up a pre-commit hook to enforce Yarn scripts only, so no one accidentally uses npm. Another mistake is overcomplicating scripts. For example, I\u2019ve seen a script that runs 5 different commands with dozens of flags, when breaking it into smaller lifecycle hooks would make it easier to debug and maintain. Keep scripts focused on one task\u2014use hooks for pre\/post steps, and use multiple scripts for different stages, instead of cramming everything into a single line.<\/p>\n

Security is another area where Yarn\u2019s script handling stands out, and something I prioritize as a supplier. Yarn has built-in checks to prevent scripts from running untrusted code, which is a big concern in modern development. When you run yarn install, Yarn verifies the integrity of every package, so you don\u2019t end up with a malicious binary in your node_modules. For scripts, Yarn only runs the scripts in package.json of packages you explicitly mark as trusted, which prevents supply chain attacks. I\u2019ve helped several mid-sized clients harden their script workflows by limiting which packages can run their own scripts, which reduced their security vulnerabilities by a lot. That\u2019s a benefit that not every package manager offers, so it\u2019s something to leverage.<\/p>\n

Let\u2019s wrap this up with a real example of a full script setup for a typical Node.js project. Suppose you\u2019re building a blog application. Your package.json scripts would look like this:<\/p>\n