More
§³hoose

Crafting

Digital

Brilliance

genexohub.org

WEB DEVELOPMENT · 10 MIN READ · UPDATED NOVEMBER 2026

Sage for WordPress Website Development: A Modern Approach to Custom Theme Development

WordPress gives businesses a flexible content platform. Roots Sage gives developers a more structured way to build the custom experience around it.

Roots Sage, the WordPress starter theme for custom development with Laravel Blade and modern front-end tools
Roots Sage provides a modern development foundation for building custom WordPress themes.

WordPress remains a practical choice for organisations that need a dependable content management system. But the way a WordPress website is developed has a significant influence on its maintainability, flexibility and long-term quality.

For projects that require more than a ready-made theme or a collection of page-builder templates, Roots Sage offers a development approach built around modern tools and familiar programming practices. The current Roots documentation identifies Sage v11.2.1. Sage brings together Laravel Blade templating, Vite and Tailwind CSS, while Acorn provides Laravel-inspired functionality within WordPress. Check the official compatibility guidance before selecting a version for a live project.

At Genexo Hub, we value development workflows that make it easier to organise code, build purposeful interfaces and maintain a website as its requirements grow. Sage is one of the tools that supports that approach.

In brief Sage is a WordPress starter theme for developers. It does not replace WordPress; it provides the foundation for building a custom theme with a modern development workflow.

What is Roots Sage?

Roots Sage is a WordPress starter theme designed for custom theme development. Rather than asking developers to begin with a conventional theme structure, Sage provides an organised foundation that brings together modern front-end tooling and Laravel-inspired templating.

WordPress continues to handle the content management system, including posts, pages, users, media and its familiar administrative interface. Sage shapes how the front end is developed and how theme code is organised.

This distinction matters: Sage is not a replacement for WordPress, and it is not a complete Laravel application. It is a starter theme that helps developers build bespoke WordPress experiences with a more structured workflow.

Why developers choose Sage

The value of Sage is not simply that it uses newer tools. Its real benefit is the way those tools work together to support a consistent development process.

1. Laravel Blade for cleaner templates

Sage uses Laravel Blade, a templating engine familiar to developers who work with Laravel. Blade provides readable template syntax, reusable components, template inheritance and directives that help keep presentation code organised.

Instead of repeating large sections of markup across several theme files, developers can separate layouts, partials and components. This makes a growing theme easier to understand and update.

2. Vite for modern asset development

Sage uses Vite, together with the Laravel Vite integration and Roots' WordPress Vite tooling, to compile and bundle front-end assets. Vite provides a development server with hot module replacement, allowing developers to see many code and style changes without repeatedly refreshing the browser. Production builds generate the compiled assets and manifest required by the theme.

A well-configured asset workflow helps keep stylesheets and scripts organised. It does not automatically make a website fast, however; performance still depends on the quality of the implementation, assets, plugins, hosting and caching strategy.

3. Tailwind CSS for deliberate interface styling

Sage includes Tailwind CSS as its default styling approach. Tailwind's utility classes let developers compose layouts and interfaces directly in their templates while maintaining a consistent design system. Sage also integrates Tailwind configuration with WordPress editor settings through generated theme.json support, helping align front-end and block-editor styling.

This can be useful when a project needs a distinctive visual identity rather than the appearance of a generic theme. Developers can define spacing, typography, colours, responsive behaviour and component patterns around the needs of the organisation. Sage is also flexible enough to support alternative styling approaches when a project calls for them.

4. Acorn for Laravel-inspired functionality

Acorn brings selected Laravel components and development patterns into WordPress. In the Sage ecosystem, it supports features such as Blade views, view composers and asset management, and can be extended with additional Laravel packages and functionality.

Acorn does not turn WordPress into a standalone Laravel application. Instead, it provides a bridge for developers who want to use familiar Laravel concepts while working within the WordPress environment.

How the tools work together

These tools have different responsibilities. Their value comes from combining them in a coherent workflow. For developers, that workflow is not only about writing templates; it also includes dependency management, local development, asset compilation, testing and a repeatable deployment process:

  • WordPress manages the website's content and administration.
  • Sage provides the custom theme foundation and project structure.
  • Blade organises the presentation layer into readable, reusable templates.
  • Vite manages front-end development and asset builds.
  • Tailwind CSS supports consistent, responsive interface styling.
  • Acorn brings Laravel-inspired functionality into the WordPress environment.

Together, they give developers a structured starting point for building a website around a project's actual requirements rather than forcing the project into the limits of a pre-designed theme.

A practical Sage development workflow

One reason developers value a structured starter theme is that common setup and build tasks can be handled through familiar command-line tools. The examples below reflect the Sage workflow documented by Roots. Run them in the appropriate directory and adapt them to the version and configuration of the project. The exact scripts and dependencies are defined by the theme's own composer.json and package.json files.

1. Create a Sage theme

From the WordPress themes directory, Composer can create a new Sage project. Replace my-theme with the folder name you want to use:

composer create-project roots/sage my-theme
cd my-theme

Composer resolves the PHP packages declared by the project and creates the theme directory. It is also used later to install and maintain PHP dependencies through the theme's composer.json and composer.lock files.

2. Install front-end dependencies

Sage uses Node.js tooling for its front-end build process. After entering the theme directory, install the dependencies declared in package.json:

npm install

This creates the local node_modules directory. It is generated from the package manifest and should not be edited manually or uploaded to production.

3. Start development and build production assets

During development, Vite can run the local development server. Before deployment, compile the production assets:

# Start the local Vite development server
npm run dev

# Compile production assets
npm run build

The production build generates the compiled files and Vite manifest used by the theme. A missing or outdated manifest can prevent assets from loading correctly, so the build step is part of deployment rather than an optional finishing touch.

4. Understand the Blade presentation layer

Blade helps separate reusable layout from page-specific content. For example, a theme can include a shared header and footer in a base layout, then render page content in a defined section:

<!-- resources/views/layouts/app.blade.php -->
<!doctype html>
<html lang="en">
<body>
    @include('partials.header')

    <main>
        @yield('content')
    </main>

    @include('partials.footer')
</body>
</html>

A page template can extend that layout and provide its own content. This is a small illustration of Blade's layout and include concepts; a production theme should follow its own established template conventions and accessibility requirements.

5. Prepare the theme for deployment

Roots documents a production sequence that builds front-end assets, installs production PHP dependencies and uploads the theme without the local node_modules directory. Acorn optimisation can also be run where the project has a working WP-CLI and Acorn installation:

npm run build
composer install --no-dev --optimize-autoloader
wp acorn optimize

The exact deployment sequence depends on the hosting environment and release process. Confirm that the server's PHP version is compatible with the project's Composer dependencies, deploy the compiled assets and manifest, and do not upload node_modules. The wp acorn optimize command requires a working WP-CLI and Acorn setup. Protect Blade template files from direct public access using the server configuration appropriate to your hosting stack.

Developer note These commands are practical starting points, not a substitute for checking the project's composer.json, package.json, Vite configuration, deployment environment and official version-specific documentation.

Sage and custom WordPress website development

A custom website should do more than look different. Its structure should support the organisation's content, users, workflows and future plans.

Sage is particularly useful when a project requires a carefully designed front end, reusable page sections, custom content presentation or a development workflow that multiple developers can understand. Its organised templates can also make ongoing changes more predictable when the theme is properly planned and maintained.

For example, a university website may need distinct layouts for news, departments, staff profiles, research information and public notices. A business website may need custom service pages, case studies, lead-generation sections and integrations. Sage provides a foundation on which these experiences can be developed as part of one coherent theme.

Is Sage better than a page builder?

Not in every situation. Page builders can be useful when a website needs to be launched quickly, when non-technical staff must create many layouts independently, or when a project has a limited development budget.

Sage is a stronger fit when the project calls for a developer-led custom theme, greater control over the underlying templates and a codebase designed around specific requirements. It also expects more technical involvement: developers need to work with PHP, Composer, Node.js, npm and the asset build process.

The right choice depends on the people who will maintain the website, the complexity of its requirements, the available budget and the level of control the project needs. A tool should serve the project, not become the project.

What to consider before choosing Sage

Sage is not a one-click website solution. Before choosing it, consider the following:

  • Developer capability: the team should be comfortable with PHP, WordPress, Composer and front-end tooling.
  • Deployment workflow: production assets must be built and deployed correctly, including the Vite manifest and compiled files.
  • Long-term maintenance: theme conventions, dependencies and documentation should be managed consistently.
  • Content editing: editors' needs should inform the design of templates and block-editor support.
  • Performance: optimise images, scripts, styles, plugins, caching and hosting; the choice of starter theme alone does not guarantee performance.

Why this approach matters at Genexo Hub

At Genexo Hub, we do not rely on a single framework, content management system or development stack for every project. Sage is one of the tools available to us, particularly when a WordPress project calls for a fully customised theme and a developer-led workflow. It is not the only technology we use, and it is not a default requirement for every website we build.

Depending on the brief, we may work with WordPress and its wider theme and plugin ecosystem, Roots Sage and Acorn, Laravel for application-driven platforms, or custom PHP and front-end technologies such as JavaScript, React, Tailwind CSS and Bootstrap. The appropriate combination depends on the product's purpose, required integrations, content workflows, expected traffic, security considerations, available budget and the team's ability to maintain it over time.

Our process starts with the problem to be solved, not with a preferred tool. We assess the requirements, define the architecture, choose a suitable stack, and build around usability, maintainability, security and the client's operational needs. A simple content-led website may not need the same architecture as a university portal, publishing platform, employee system or bespoke business application.

That flexibility is central to our approach: use Sage when it is the right fit, use another framework or platform when it is more appropriate, and avoid adding technical complexity that does not create meaningful value for the client.

Final thoughts

Roots Sage brings a modern development workflow to custom WordPress theme creation. With Blade for templating, Vite for asset development, Tailwind CSS for styling and Acorn for Laravel-inspired functionality, it gives developers a practical foundation for building structured, bespoke WordPress experiences.

It is not necessary for every WordPress project, and it is certainly not the only way to build a professional website. At Genexo Hub, the best technology is the one that meets the project's requirements and can be supported responsibly throughout its life.

HAVE A WEBSITE PROJECT IN MIND?

Let's build a digital experience that works for your organisation.

Whether you need a custom WordPress website, a redesigned digital presence or a more capable business platform, let's discuss what your project requires.

LET'S TALK

Further reading

For technical details and the latest implementation guidance, consult the official Roots documentation:

Back to all resources
More practical ideas for building better digital experiences.

Explore more from Genexo Hub.