Pages is a powerful platform for developing performant and SEO-optimized websites that leverage the Yext Knowledge Graph. As a developer, you can use the most up-to-date web development technologies, while content managers can update data seamlessly through an intuitive UI.

Pages integrates Knowledge Graph data with your frontend code and transforms it into web pages using a Jamstack architecture. Your site is generated by Yext through an automatic integration with GitHub and served via a global CDN.

Note: You do not have to use React to build your site. If you prefer not to use React, check out the reference on Pure JavaScript Rendering.

Types of Pages

All three types of Yext Pages allow you to create SEO-optimized pages built on top of the Yext platform — the differentiation is how you want to build and manage them.

Pages is a fully custom architecture that allows pages to be built by any developer. Developers can preview their pages locally and deploy them globally using Yext's backend infrastructure. This is what the rest of this documentation covers and what you may see referred to as the "latest version of Pages."

Page Builder is a point-and-click editor in the Yext platform that enables you to build simple, templated pages without writing code.

Classic Pages are fully custom sites developed by Yext's Professional Services Team. Existing custom sites built on the Classic rendering architecture fall into this category. If you have questions about Classic Pages, reach out to your account team.

View Your Page Type

Navigate to Sites > All Sites in the Yext platform to see a table of all your sites. The Type column displays the page type for each site.

The Deployment Process

The Pages system has been architected to support building statically generated pages at scale. Most static site generators struggle to build sites with more than thousands of pages and require a full site rebuild even for a tiny data change.

The Pages deployment process is optimized for scale: incremental data changes only update the necessary pages, resulting in changes going live in less than five seconds in most cases.

The deployment process is split into three independent phases:

1. Initial Build
2. Initial Page Generation
3. Ongoing Data Updates

By decoupling these phases, the system can provide processing environments uniquely optimized for the distinct responsibilities of each phase, yielding overall faster deploy performance.

Phase 1: Initial Build

The initial build phase generates all the static assets that make up the frontend of the website: CSS stylesheets, JavaScript files, font files, images, and similar supporting assets.

This phase is triggered when a developer pushes code to GitHub. The Yext Pages system checks out the code and initiates the build process.

Importantly, the initial build phase does not interact with the data source — it is not responsible for generating web pages from data records. This split is critical: it allows the system to only update HTML files when data changes, rather than restarting the entire build from scratch.

The exact build process is determined by a build command in the config.yaml file at the root of the project. This build chain can run any arbitrary node-based tools. Generally, this step runs npm install and then npm build, but it can be configured. See the Site Configuration reference doc for details.

After the initial build completes, initial page generation begins.

Phase 2: Initial Page Generation

The page generation phase is responsible for generating the HTML web pages that make up the site. These pages are generated based on data records from the Yext Knowledge Graph, using a system called Streams that pushes entities from the Knowledge Graph into Pages.

For every data record, an HTML page is generated using the build artifacts from Phase 1. After generation, the HTML files are automatically pushed to the global CDN. Since each page can be generated independently, this process happens in parallel, which greatly improves generation speed.

After initial page generation is complete, the deploy is live and served via the CDN. Data changes in the platform after this point are processed incrementally in Phase 3.

Phase 3: Ongoing Data Updates

After initial page generation, the deploy continues listening for ongoing data changes via the same Streams system used in Phase 2. If data changes in the platform, Streams notifies the site to incrementally build any pages that the change impacts.

Unlike other static site generation systems, this does not kick off a new build from the beginning. Instead, it incrementally generates HTML only for the pages that changed, reusing the build artifacts from Phase 1. The result is incremental publishes in less than five seconds.

If a large number of updates happen at once, the Pages system parallelizes these requests to minimize total processing time.

Summary

The deployment process is managed entirely by the Pages system without additional developer intervention. If changes to the structure of the site are required, the developer pushes their latest commit to GitHub. Otherwise, data changes in the Knowledge Graph automatically update the relevant statically-generated pages in real time. The Pages system handles all the details of managing the build artifact, generating HTML, and knowing when to re-generate which pages.