Development Tips

The JavaScript Tools I Actually Use on Client Projects in 2026

By Ken Key Mar 17, 2026 5 min read Updated Oct 16, 2026

The JavaScript Tools I Actually Use on Client Projects in 2026
The short answer

For small business sites I reach for Vite, TypeScript where it pays off, ESLint with Prettier, Vitest for tests, and pnpm. Plain script tags beat a bundler on low-interactivity marketing pages. Pick tools you can still read and maintain six months later.

Part of the complete web development guide.

On this page

Every year the JavaScript ecosystem ships a new batch of tools that promise to fix everything, and every year most of them quietly disappear. I build websites for small businesses and agencies around Commack and the rest of Long Island, and I care about one thing: does the tool still make sense on a real project six months from now. Here are the five I keep coming back to, and the honest reasons why.

1. Vite for dev server and builds

Vite won the bundler fight for most app work, and it’s still the default I reach for in 2026. The dev server starts in milliseconds because it serves your source over native ES modules instead of bundling everything up front, and the production build uses Rollup (or Rolldown in newer setups) under the hood. The config is short enough that you can actually read it later.

// vite.config.js
import { defineConfig } from 'vite';

export default defineConfig({
 build: {
 target: 'es2022',
 sourcemap: true,
 rollupOptions: {
 output: {
 manualChunks: {
 vendor: ['react', 'react-dom']
 }
 }
 }
 },
 server: {
 port: 5173
 }
});

The one caveat: if you’re building a five page marketing site with almost no interactivity, you don’t need a bundler at all. A plain <script type="module"> tag and a couple of files will load faster and be easier for the next person to maintain. Tooling has a cost, and Vite is only worth it once you have enough JavaScript that hand-managing dependencies gets painful.

2. TypeScript, but only where it pays off

I resisted TypeScript for years because I thought it slowed me down on small sites. It doesn’t, as long as you don’t try to type every last thing. What changed my mind was the number of bugs it catches in code I’d otherwise ship and debug in production at 11pm. For anything with a data layer, an API, or more than one developer, it’s worth it.

type Lead = {
 name: string;
 email: string;
 message: string;
 source?: 'contact-form' | 'phone' | 'referral';
};

async function submitLead(lead: Lead): Promise<{ ok: boolean }> {
 const res = await fetch('/api/leads', {
 method: 'POST',
 headers: { 'Content-Type': 'application/json' },
 body: JSON.stringify(lead)
 });
 return { ok: res.ok };
}

Where it doesn’t pay off: a static brochure site with one form and a phone number. In that case plain JavaScript is fine, and adding a build step just so you can have types you’ll never change is a waste of your time and your client’s money.

3. Playwright for testing the stuff that actually breaks

Unit tests are great, but the bugs that reach real users on a small business site are almost always in the flow: the form that doesn’t submit on mobile Safari, the menu that won’t close, the checkout button that’s covered by a sticky banner. Playwright runs a real browser and catches those. It’s also the tool I trust most for cross-browser checks because it drives Chromium, Firefox, and WebKit from one API.

import { test, expect } from '@playwright/test';

test('contact form submits and shows confirmation', async ({ page }) => {
 await page.goto('https://example.com/contact');
 await page.getByLabel('Name').fill('Test User');
 await page.getByLabel('Email').fill('test@example.com');
 await page.getByLabel('Message').fill('Checking the form works.');
 await page.getByRole('button', { name: 'Send' }).click();
 await expect(page.getByText('Thanks, we got it')).toBeVisible();
});

You don’t need a hundred tests. Three or four that cover your money paths (contact, checkout, signup) will catch most of the regressions that cost clients real leads.

4. Tailwind CSS, with a real design system behind it

I was skeptical of Tailwind for a long time because utility classes in markup look messy. What won me over is that it forces consistency. Once you define your spacing scale, colors, and type sizes in the config, every page uses the same values whether you remember them or not. That matters a lot when you hand a site off and the client’s nephew starts editing it.

// tailwind.config.js
export default {
 content: ['./src/**/*.{html,js,ts,jsx,tsx}'],
 theme: {
 extend: {
 colors: {
 brand: {
 500: '#1d4ed8',
 600: '#1e40af'
 }
 },
 fontFamily: {
 sans: ['Inter', 'system-ui', 'sans-serif']
 }
 }
 }
};

The catch: Tailwind is not a design. If you don’t have a coherent set of colors and spacing rules going in, you’ll just end up with a consistent mess. I usually pair it with something like a Figma file or, for smaller budgets, a hand-written style guide of maybe twenty decisions.

5. Astro for content-heavy sites

Most of the sites I build are content first: a homepage, a services page, a blog, a contact page. Astro is built for exactly that. It ships zero JavaScript by default and lets you drop in interactive components only where you need them. The result is a site that loads fast on a phone with a mediocre connection, which is still most of the traffic I see from local searches.

---
// src/pages/blog/[slug].astro
export async function getStaticPaths() {
 const posts = await fetch('https://cms.example.com/posts').then(r => r.json());
 return posts.map((post) => ({
 params: { slug: post.slug },
 props: { post }
 }));
}
const { post } = Astro.props;
---
<article>
 <h1>{post.title}</h1>
 <div set:html={post.body} />
</article>

For a marketing site with a CMS, this is the cleanest setup I’ve found. You get static HTML out the door, and you can bolt on a React island later if the client wants a calculator or a live availability widget. When a project needs more than a static site can reasonably handle, that’s usually the point where I bring in help from a custom web development partner rather than forcing the wrong tool to do the job.

What I’d skip in 2026

A few things I’ve stopped reaching for, at least on small projects:

  • Create React App. It’s been deprecated for a while now, and Vite does the same job better.
  • jQuery for new builds. It still works fine on legacy sites, but you don’t need it for new code.
  • Heavy state libraries on sites with no real state. You probably just need a couple of signals or a small store.
  • Any tool you can’t explain to the person maintaining the site after you’re gone.

FAQ

Do I need all five of these on every project?

No, and that’s the point. Most sites use two or three. A static marketing site might just be Astro and Tailwind. A web app might be Vite, TypeScript, and Playwright. Pick the ones that solve a problem you actually have.

Is any of this going to be outdated by next year?

Some of it, yes. Vite and TypeScript are safe bets. Tailwind and Astro are mature enough that they’ll be around. The specific bundler or test runner might shift, but the underlying ideas (fast dev feedback, type safety, real browser tests, consistent styles, static output) won’t.

What if I’m not a developer and just want a site that works?

Then don’t worry about the tool names. Ask whoever builds your site whether it loads fast on a phone, whether the forms actually deliver email, and whether you can update the content yourself. If the answer is yes to all three, the tooling underneath is doing its job.

Have a project like this?

I do custom web development for Long Island businesses. If you need this done right, let’s talk.