You ran 'npm install' off a tutorial. Somewhere in the scroll of output was a paragraph starting with 'npm warn EBADENGINE Unsupported engine', or nothing at all — just a build that quietly behaves differently than the person who wrote the tutorial saw on their machine. Either way you're now staring at a version number you didn't pick, wondering if it's the reason, and the tutorial's only advice was 'install the latest version of Node.'
That advice is not wrong, exactly. It's incomplete in a way that can put you on a countdown without telling you. Here's the two-minute fix: run 'node -v', and actually read what the number is telling you.
The command you already know how to run
$ node -v v22.22.2
That's the real output from the machine I'm writing this on. Three numbers separated by dots — major, minor, patch — and almost every guide that mentions 'node -v' treats it as a health check: did the install work, yes or no, moving on. It's doing more work than that. The major number, the 22 here, is the only one that matters for what I'm about to show you.
The rule: even survives, odd doesn't — for now
Node ships a new major version roughly every six months, and until very recently, which number you land on decided the whole shape of your next year:
- Even majors (20, 22, 24, 26) get promoted to Long-Term Support after six months as 'Current.' LTS means security and bug fixes for roughly 30 months total. Install one and you don't have to think about this again for a long while.
- Odd majors (21, 23, 25) never get that promotion. They run as 'Current' for roughly six months, then get maybe a month more before support is cut off entirely — about eight months total from release to end of life, and no LTS branch, ever. If you 'npm install'-ed against one, you're on a fixed-length clock whether you knew it or not.
You can check the shape of the rule yourself without trusting my prose — parity, from the version you already have:
$ node -v | sed 's/^v//' | cut -d. -f1 22
$ node -e "console.log(process.version, process.version.slice(1).split('.')[0] % 2 === 0 ? 'even' : 'odd')" v22.22.2 even
22 is even. That's not a coincidence for a machine meant to keep running — it's Node 22 ('Jod'), which went Active LTS on 29 October 2024 and doesn't reach end of life until 30 April 2027. A tutorial telling you to 'just install the latest' has no way of knowing whether 'latest' currently means that, or means something with an expiration date months out.
Why this bit real people
The reader who lands here usually got one of two messages. The first is the one I reproduced above — a real 'npm install' against a real 'package.json' declaring a minimum engine version, on this exact machine:
{ "name": "engine-test", "version": "1.0.0", "engines": { "node": ">=99.0.0" } }
$ npm install npm warn EBADENGINE Unsupported engine { npm warn EBADENGINE package: 'engine-test@1.0.0', npm warn EBADENGINE required: { node: '>=99.0.0' }, npm warn EBADENGINE current: { node: 'v22.22.2', npm: '10.9.7' } npm warn EBADENGINE }
That's npm (10.9.7 here) telling you flatly what it wants versus what it got — a warning, not a hard stop, which is exactly why it's easy to scroll past and worry about later. The second message is quieter and worse: nothing at all. No warning, install completes, and the mismatch between the tutorial author's Node and yours only shows up later as a bug that makes no sense, because you're not running the same runtime they wrote the tutorial against.
Neither message tells you the thing this piece is telling you: that the version number itself was already answering the question, before you ever hit a warning or a weird bug.
Where 'latest' actually points right now
Here's the honest state of the landscape as of this month, so you're not decoding the rule in a vacuum:
- Node 24 ('Krypton') — even, Active LTS since 28 October 2025, end of life 30 April 2028. The safe long default.
- Node 25 — odd, already dead. It shipped as Current on 15 October 2025 and hit end of life on 1 June 2026 — about seven and a half months, start to finish. If a tutorial still tells you to grab 25, it's pointing you at a corpse.
- Node 26 — even, the current 'latest,' released 5 May 2026, moving to Active LTS on 28 October 2026.
So right now, 'install the latest Node' actually lands you on 26 — even, safe, on track for LTS — or, if you go through nvm and ask for the LTS line specifically, 24. Both are fine choices this month. The hazard window this piece is about isn't open wide right now; it was open when 25 was the newest thing to grab, and it will open again the next time an odd release is the shiny one — which is exactly why the rule is worth having memorized instead of looked up each time.
The part that expires
I want to be straight with you about how long this rule is good for, because a guide that states it as permanent is setting you up the same way 'install the latest' did. Node's own release announcement is explicit: starting with Node 27, the odd/even split ends entirely. Every major version will move to LTS after its Current phase — no more permanently-Current, permanently-abandoned odd releases. Node 27 lands as an alpha in October 2026, ships as 27.0.0 in April 2027, and goes LTS that October — and it's the first release under the new rule, not the old one.
So: 'odd equals never LTS' is true for every major version you can install today, and it is true right up through Node 26. It stops being true at 27. If you're reading this after April 2027 and you see an odd major number, don't apply this rule to it blind — go check whether the split still exists, because Node itself has already told you it won't.
Turning the rule into a decision
Next time you're about to install Node, or you just ran 'node -v' and want to know if you're fine, here's the actual decision, in order:
- Run 'node -v'. Read the major number.
- Divide by two. Remainder zero, you're on an LTS track — check the end-of-life date if you care exactly how long, but you're not on a clock that ends in months.
- Remainder one, and the major is 26 or lower — you're on a release with about eight months total, start to end of life, and only a few weeks of runway once a newer even major takes over as 'Current.' Node 25 is the case in point: it lived October 2025 to June 2026, roughly seven and a half months, and lost barely a month of that once 26 took over as Current. Fine for trying something out this weekend, not what you want a tutorial pointing you at for anything you'll still be running in the spring.
- Major is 27 or higher — the split is gone. Every release is headed for LTS regardless of parity, so this whole rule stops applying and you check the actual end-of-life date instead of doing arithmetic on the version number.
If you want the LTS line specifically instead of doing the math yourself every time, nvm — the version-switching tool a lot of tutorials assume you already have — documents exactly this shortcut: 'nvm install --lts' installs the latest LTS release outright, and 'nvm install lts/jod' pins a specific LTS line by codename ('jod' is Node 22, the exact major already printed in the box above). That's the tool-assisted version of the same decision — worth knowing either way, because not every tutorial you'll read tells you to use a version manager at all.
Why this matters
'Install the latest Node' is advice that was true the day someone wrote it and silently stops being reliable advice months later, because 'latest' is a moving target riding on a release schedule the tutorial author never mentioned. The number you get back from 'node -v' isn't just confirming the install worked — it's telling you, in one digit's parity, whether you're on a runtime with a year-plus of support ahead of it or one that's already most of the way through an eight-month lifespan. Most install guides show you the command and skip the part where the output means something.
Final thought
Open a terminal right now and run 'node -v'. Take the major number, check it against even or odd, and if it's odd and 26 or lower, go install the even LTS line before you build anything you plan to keep — 'nvm install --lts' if you have a version manager, or the LTS download directly from nodejs.org if you don't. And if you landed here because 'npm install' already threw EBADENGINE at you, changing Node is not the last step: re-run 'npm install' inside the project afterward so your dependencies resolve against the line you just moved to, or you have swapped the runtime and fixed nothing. Two minutes, and you're not decoding a warning message months from now.