Running Tailwind CSS?

Tailwind classes missing or v4 upgrade stuck? We clear the backlog.

Tailwind is the fastest way to style a UI until the content configuration cuts a class you only use at runtime, the v4 engine refuses to recognize a plugin that worked on v3, or three different teams have each invented their own `btn-primary` and nobody wants to touch the audit. We go through the config, the build output and the components, and we leave you with a system that is actually consistent.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

tailwind-build.log

still broken

What it is

Tailwind CSS at a glance

Tailwind CSS is a utility-first CSS framework created by Adam Wathan and first released in 2017. Rather than writing component classes, you compose designs from small single-purpose utilities (`flex`, `pt-4`, `text-sm`, `bg-gray-800`) directly in markup, and an unused-class purge keeps the final stylesheet small.

Version 4, released in 2025, replaces the PostCSS plugin with a native engine, drops `tailwind.config.js` in favor of CSS-first configuration via `@theme`, and adds container queries, the `3xl` breakpoint and a faster incremental build. The upgrade path is straightforward for simple projects and significantly more involved for codebases with plugins, deep theme extensions or server-rendered dynamic class names.

Type
Utility-first CSS framework
First released
2017
License
MIT
Maintained by
Tailwind Labs
Typically used for
Web app UI, marketing sites, design systems, component libraries, dashboards

The honest version

Tailwind CSS pros and cons

No technology is all upside. This is where Tailwind CSS earns its place and where it tends to cause trouble.

Where Tailwind CSS is strong

  • Design decisions live next to the markupA component's look is visible in the same file as its structure. No jumping to a separate `.scss` file to work out which rule set is winning the cascade.
  • Bundle size stays smallThe purge or JIT step emits only the utilities you used. Even a large app usually ends up with a stylesheet in the tens of kilobytes, not the hundreds.
  • Consistent design tokensSpacing, color, type scale and breakpoints come from a central theme, so every team member is drawing from the same palette instead of hand-picking hex codes.
  • Fast in developmentNo naming new classes for every element, no cascade debugging, no deciding where a one-off style should live. Changes ship faster, especially during early product iteration.
  • Great ecosystemTailwind UI, Headless UI, DaisyUI, Flowbite and shadcn/ui all lean on it, so component libraries integrate without translation.
  • Works across frameworksReact, Vue, Svelte, Astro, Rails, Laravel, Django, plain HTML, all consume Tailwind the same way, which keeps one design system coherent across different codebases.

Where Tailwind CSS bites

  • Markup gets noisy fastA button with hover, focus, dark mode, responsive and disabled states can run 20 to 30 classes in a single attribute. Readability suffers without discipline around components.
  • Dynamic class names break purgeConstructing class strings at runtime (`bg-${color}-500`) hides them from Tailwind's scanner, so the utilities get stripped from the build and the page renders unstyled.
  • The v4 upgrade is not freeCSS-first config, removed APIs, plugins that have not updated and PostCSS plugin replacement mean a real codebase needs a planned migration, not a flag flip.
  • `@apply` abuse creates worse CSSTeams reach for `@apply` to tidy markup and end up with an opaque component stylesheet that neither uses the framework's model nor plain CSS cleanly.
  • Hiring preferences are splitSome engineers love it, some will not touch it. On larger teams the stance needs to be explicit rather than assumed.
  • Diff review is harderA class list change in a pull request obscures intent. 'Changed layout' and 'fixed a bug' can look identical in the diff until you read the component.

Sound familiar?

Common Tailwind CSS problems we fix

The Tailwind CSS problems that bring people to us, and what you have once each one is fixed.

`bg-[#1a1a1a]` class does not exist

Arbitrary values are not being emitted

Dynamic class construction building the class name at runtime, a content path that misses the template file, or an older Tailwind version that does not support the arbitrary syntax.

Classes present and applied

No utility classes were detected

The entire stylesheet comes out empty

A content configuration that no longer matches the project structure after a folder move, or a path glob that excludes the files actually using Tailwind.

Content paths accurate, styles emitted

tailwindcss v4 · plugin missing

Tailwind v4 upgrade is stalled

A codebase mid-migration from v3 to v4, with CSS-first config half done, plugins not ported, and the design visibly different depending on which page you look at.

Project fully on v4 with parity

class `text-brand-500` purged

Classes vanish in production only

Classes constructed from string templates or stored in a CMS, invisible to the Tailwind scanner, that work in dev because every class is present and fail once the production purge runs.

Safelists or refactor so purge is honest

3 teams · 3 button patterns

The design system has drifted

Multiple component libraries, three competing button styles, color values hard-coded in some files and tokenized in others, and nobody wants to be the one to rewrite it.

One tokenized system, enforced in code

@apply breaks on build

@apply directives are breaking the build

`@apply` used in CSS files that are not processed through Tailwind, or applied to classes that are purged before the directive resolves.

@apply in processed files, scoped correctly

FOUC on load

Unstyled flash during page load

A late-loaded stylesheet, a build that split critical CSS incorrectly, or a Tailwind preflight race with framework-level style injection.

Styles present at first paint

What we do

Tailwind CSS help, from upgrade to audit

Call us for one page that looks wrong, or the entire design system.

v3 to v4 migration
Config to CSS-first, plugin replacements, theme port, build tool updates, with visual regression checks so pages look the same at the end.
Design system cleanup
Consolidating competing button, card, form and typography patterns into a single tokenized set your teams can actually agree on.
Build and purge rescue
Fixing production-only missing classes, broken JIT configuration, and content paths that stopped matching when the project layout changed.
Component library builds
Headless UI, shadcn/ui or in-house libraries built on top of Tailwind, with theming, dark mode and accessibility done properly.
Audit and refactor
Reviewing markup noise, `@apply` usage and inconsistent token usage, with a plan for cleanup that does not require freezing feature work.
Managed Tech
Version upgrades, plugin maintenance, design token reviews and ongoing support as Tailwind evolves and your UI patterns do too.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running Tailwind CSS alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

Tailwind CSS questions

Something else? Call+1 737 727 7327

Should we upgrade from Tailwind v3 to v4?

For most projects, yes, but on a schedule that respects the scope. The new engine is faster, container queries are first class, and v3 will eventually stop getting fixes. For codebases with heavy plugin use, custom theme extensions, or server-rendered dynamic class names the migration is a real project. We plan it, migrate in branches, run visual regression against staging, and ship it without surprises.

Why do some Tailwind classes work in dev but not in production?

Almost always because the class name is constructed dynamically or stored somewhere Tailwind's scanner cannot see. The dev build emits more classes, so the issue is hidden. The fix is to either stop constructing class names at runtime, add a safelist for the classes that must survive purge, or widen the content paths to include the files where the classes actually appear.

Can you help us build or clean up a design system in Tailwind?

Yes. That work usually starts with inventorying what is already in the codebase, agreeing on tokens for color, spacing and type, extracting the patterns that repeat into components, and documenting the result so new work does not immediately drift back. We can also layer Headless UI or shadcn/ui on top if a headless library is a better fit than growing one in-house.

Is `@apply` an anti-pattern?

Not inherently, but it is easy to overuse. The pattern that works is small utility combinations extracted into components (a button, a card) where the semantics are clear. The pattern that goes wrong is wrapping every utility into a bespoke class, which rebuilds the old CSS problem Tailwind was meant to avoid.

Can you take over a Tailwind project from a previous developer?

Yes. We review the config, the content paths, the plugin set, the component patterns and the token usage, and give you a short report on what will need tidying up before new features ship cleanly. Then we either do the tidy or hand the plan to your team.

How much does Tailwind CSS help cost?

Free estimate first. Send us the repo or describe what is rendering wrong, and we come back with a price you can sign off before any work starts.

Free estimate

Tailwind giving you trouble?

Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.