Unicorn Platform

World's best and simplest website builder powered by AI

Build your website
Friday, October 27, 2023

Tailwind CSS Tutorial: Design Flexible Components


Tailwind CSS has rapidly become one of the most popular CSS frameworks for building modern, responsive user interfaces quickly. With its utility-first approach, Tailwind makes styling elements easy by providing reusable classes like bg-blue-500 and text-lg right in your markup. However, when constructing complex interfaces and reusable components, maintaining consistency and accessibility can be tricky without additional practices.

In this comprehensive walkthrough, we'll explore strategies for designing flexible, maintainable UI components with Tailwind CSS. Following proven techniques like semantic HTML, responsive design, and accessibility will allow us to create robust components suitable for any project.

By the end, you'll have the skills to build reusable Tailwind components that can adapt to any design system with ease. Let's dive in!

Tailwind CSS Overview

For those new to Tailwind CSS, here's a quick overview of its utility-first workflow and key features:

Utility Classes

Instead of targeting elements and writing custom CSS, Tailwind uses utility classes that you apply directly to your HTML:

<button class="bg-blue-500 text-white font-bold py-2 px-4 rounded">

Some common utilities include:

  • bg-{color} - background color
  • text-{size} - font size
  • p-{size} - padding

This atomic approach allows rapid development, but can lead to messy HTML at scale.

Responsive Design

One of Tailwind's best features is its mobile-first responsiveness. You can use prefixes like sm: and md: to apply styles at different breakpoints:

<div class="sm:flex md:block lg:grid">

This flexes between block, flexbox and CSS grid seamlessly.


Tailwind is customizable through tailwind.config.js. Add custom colors, fonts, variants and plugins to match any brand.

With this flexibility, Tailwind adapts to any project.

Now let's see how to build truly reusable components with these tools.

Strategies for Flexible Components

When designing components in Tailwind, follow these best practices:

Consistent Class Names

Use consistent class names like:

<button class="btn btn-primary">

This allows easy styling across component instances.


Extract common styles into theme classes:

// tailwind.config.js

module.exports = {
  theme: {
    extend: {
      colors: {
        primary: '#3490dc'

Then apply the theme:

<button class="bg-primary">

Customize spacing, fonts and more.

Modular Components

Split larger components into smaller single-responsibility ones:

// Usage
<Button variant="primary" />

// Button.js
export default function Button({variant}) {
  if (variant === 'primary') {
    return <PrimaryButton />

This is far more maintainable than a single component with conditionals.


Ensure accessibility through:

  • Semantic HTML
  • Keyboard interactions
  • ARIA roles/attributes
  • Color contrast

For example, make a <Button> reachable via Tab key.

Refer to WCAG guidelines.


Components should adapt across screens with:

  • Mobile-first
  • Breakpoint classes
  • Responsive props

For example:

<Button responsive={{
  base: 'w-full',
  sm: 'w-auto' 

Now let's walk through practical examples.

Building Reusable Components

Let's look at building some common components in Tailwind:

Button Component

Here is a reusable <Button>:

export default function Button({
}) {

  return (
      className={`btn ${variant}`}


// Usage
<Button variant="primary">
  Click Me

Expand with sizes, colors, states and more.

A responsive Navbar:

return (
  <nav className="flex justify-between">

    <div className="flex">
      <Logo />
      <ul className="hidden sm:flex"> 
        <!-- etc -->  
    <MobileMenu />


Show/hide links based on screen size.

Product Card

Display a product in a card:

return (
  <div className="p-4 bg-white shadow">

    <img src={product.image} />
    <h2 className="font-bold">{product.name}</h2>
    <button className="btn btn-primary">
      Add to Cart


Style with backgrounds, borders, responsive images, etc.

Form Validation

Show live error messages:

return (

      className={errors.name ? 'border-red' : ''} 
    {errors.name && (
      <p className="text-red-600">{errors.name}</p>


Style inputs based on validation state.

An accessible modal:

return (

    {/* Overlay */}
    <div className="fixed inset-0 bg-black/50"/>
    <div className="fixed inset-40 p-4 bg-white">
      <button onClick={close}>
      <!-- Content -->

Overlay content, trap focus with layering and ARIA.

These examples show building robust UIs by composing small components!


In this comprehensive Tailwind CSS tutorial, we learned proven techniques like theming, consistency, modularity and accessibility to create reusable components suitable for any project.

By writing semantic HTML, handling responsiveness and separating concerns, you can build flexible UI elements rapidly. To recap:

  • Consistent naming conventions
  • Extract common styles into themes
  • Modular single-responsibility components
  • Accessible and responsive

Additional resources:

I hope you enjoyed this in-depth guide on designing maintainable Tailwind components! Let me know if you have any other topics you'd like to see covered. Happy coding!