Yes, you read that correctly.

Everyone “knows” WordPress stores pages in wp_posts.
Everyone also accepts the slow queries, the meta bloat, the accidental deletions, the import/export nightmares.

I don’t.

For a SaaS dashboard with 24 different admin screens, relying on database pages is basically architectural self-harm.

So I stopped doing it.

---

The Trick WordPress Never Told You About

Instead of creating pages in the database…
I just don’t.

I intercept routing before WordPress does anything:

add_action('template_redirect', function() {
    $path = trim(parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH), '/');

    $virtual_pages = [
        'app/orders' => 'virtual-pages/all-orders.php',
        'app/samples' => 'virtual-pages/all-samples.php',
        // ... 20 more
    ];

    if (isset($virtual_pages[$path])) {
        global $wp_query;
        $wp_query->is_404 = false;
        $wp_query->is_page = true;

        include get_template_directory() . '/' . $virtual_pages[$path];
        exit;
    }
});

No posts table.
No queries.
No revisions.
No “who deleted the page?” mysteries.

Just pure, clean routing.

---

What This Unlocks

1. Pure Performance

Database pages:

SELECT * FROM wp_posts...
SELECT * FROM wp_postmeta...

Virtual pages:

0 queries.
Just vibes.

2. Actual Version Control

virtual-pages/
├── all-orders.php
├── order-details.php
└── edit-sample.php

You edit, commit, deploy.
Your UI is in Git, where it belongs.

3. Zero user screwups

Users can’t delete a page that doesn’t exist.
End of problem.

4. Real SaaS structure

You’re no longer “using WordPress.”
You’re building an app that happens to run on WordPress.

---

The Full Pattern as Reusable Code

<?php
/**
 * Virtual pages loader for WordPress
 *
 * - Treats PHP files in a folder (e.g. /virtual-pages) as "pages"
 * - No entries in wp_posts
 * - Works on subdirectory installs (https://example.com/subsite/app/orders)
 *
 * Usage:
 * 1. Put your virtual page templates in:  wp-content/themes/your-theme/virtual-pages/
 * 2. Create a wrapper template:          wp-content/themes/your-theme/virtual-page-wrapper.php
 * 3. This class will route /slug to virtual-pages/slug.php
 */

if ( ! class_exists( 'BV_Virtual_Pages_Loader' ) ) {

	class BV_Virtual_Pages_Loader {

		/**
		 * Folder (inside the theme) that contains virtual page templates.
		 *
		 * @var string
		 */
		protected $folder;

		/**
		 * Map of slug => file path.
		 *
		 * @var array
		 */
		protected $slugs = [];

		/**
		 * Currently requested virtual page slug (if any).
		 *
		 * @var string|null
		 */
		protected $current_slug = null;

		/**
		 * @param string $folder Relative folder inside the theme (no leading slash).
		 */
		public function __construct( $folder = 'virtual-pages' ) {
			$this->folder = trim( $folder, '/' );

			add_action( 'init', [ $this, 'scan_files' ] );
			add_filter( 'template_include', [ $this, 'intercept_request' ], 99 );

			// Keep titles consistent for virtual pages.
			add_filter( 'the_title', [ $this, 'maybe_override_title' ], 10, 2 );
			add_filter( 'get_the_title', [ $this, 'maybe_override_title' ], 10, 2 );
		}

		/**
		 * Scan the virtual pages folder and register all *.php files as slugs.
		 */
		public function scan_files() {
			$directory = trailingslashit( get_stylesheet_directory() ) . $this->folder;

			if ( ! is_dir( $directory ) ) {
				return;
			}

			foreach ( glob( $directory . '/*.php' ) as $file ) {
				$slug                 = basename( $file, '.php' );
				$this->slugs[ $slug ] = $file;
			}
		}

		/**
		 * Get the current request path converted to a slug.
		 *
		 * Handles subdirectory installs like /my-site/app/dashboard.
		 *
		 * @return string
		 */
		protected function get_requested_slug() {
			$request_uri = parse_url( $_SERVER['REQUEST_URI'] ?? '', PHP_URL_PATH );
			$site_path   = parse_url( home_url(), PHP_URL_PATH );

			if ( $request_uri === null ) {
				$request_uri = '';
			}
			if ( $site_path === null ) {
				$site_path = '';
			}

			// Strip the site base path (for subdirectory installs).
			if ( $site_path !== '/' && $site_path !== '' && $request_uri !== '' && strpos( $request_uri, $site_path ) === 0 ) {
				$request_uri = substr( $request_uri, strlen( $site_path ) );
			}

			return trim( $request_uri, '/' );
		}

		/**
		 * Intercept the template resolution and route to a virtual page if it matches.
		 *
		 * @param string $template Default template path.
		 * @return string
		 */
		public function intercept_request( $template ) {
			$requested_slug       = $this->get_requested_slug();
			$this->current_slug = $requested_slug;

			if ( isset( $this->slugs[ $requested_slug ] ) ) {
				// Mark as a valid page, not a 404.
				status_header( 200 );

				global $wp_query;
				$wp_query->is_404  = false;
				$wp_query->is_page = true;

				// Browser <title>.
				add_filter(
					'document_title_parts',
					function ( $parts ) use ( $requested_slug ) {
						$parts['title'] = $this->humanize_slug( $requested_slug );
						return $parts;
					}
				);

				// Let title functions know we're on a virtual page.
				$GLOBALS['virtual_page_slug'] = $requested_slug;

				// Wrapper template: can include header/footer and then load the actual page.
				$wrapper = trailingslashit( get_stylesheet_directory() ) . 'virtual-page-wrapper.php';

				if ( file_exists( $wrapper ) ) {
					return $wrapper;
				}

				// Fallback: load the virtual page template directly.
				return $this->slugs[ $requested_slug ];
			}

			return $template;
		}

		/**
		 * Override the_title() / get_the_title() for virtual pages.
		 *
		 * @param string     $title
		 * @param int|string $post_id
		 * @return string
		 */
		public function maybe_override_title( $title, $post_id = null ) {
			if ( isset( $GLOBALS['virtual_page_slug'] ) && ! is_admin() ) {
				return $this->humanize_slug( $GLOBALS['virtual_page_slug'] );
			}

			return $title;
		}

		/**
		 * Get the current virtual slug (optional helper for wrappers).
		 *
		 * @return string|null
		 */
		public function get_current_slug() {
			return $this->current_slug;
		}

		/**
		 * Convert a slug like "app-orders" to "App Orders".
		 *
		 * @param string $slug
		 * @return string
		 */
		protected function humanize_slug( $slug ) {
			return ucwords( str_replace( '-', ' ', $slug ) );
		}
	}

	// Bootstrap: create loader instance once the theme is ready.
	add_action(
		'after_setup_theme',
		function () {
			new BV_Virtual_Pages_Loader( 'virtual-pages' );
		}
	);
}

You can pair this with a simple virtual-page-wrapper.php like:

<?php
// virtual-page-wrapper.php
get_header();

$slug = isset( $GLOBALS['virtual_page_slug'] ) ? $GLOBALS['virtual_page_slug'] : '';
if ( $slug ) {
    $file = trailingslashit( get_stylesheet_directory() ) . 'virtual-pages/' . $slug . '.php';
    if ( file_exists( $file ) ) {
        include $file;
    } else {
        echo '<p>Virtual page not found.</p>';
    }
}

get_footer();

---

Real Example: My 24-Page Dashboard

My system has:

• User settings
• Bulk import
• CRM settings
• Order creation
• Order PDFs
• Sample editor
• Notifications
• System config
• Documentation

All inside one folder:

virtual-pages/
├── scan.php
├── manager-dashboard.php
├── create-order.php
└── system-settings.php

Not a single database page.
Deployment is just Git push.

---

When to Use This

Use it when:
You’re building a SaaS or dashboard
Pages are interface, not “content”
You want Git over database
You want speed
You hate WordPress menus

Avoid it when:
You need the WP editor
Clients manage content
SEO matters
Comments/revisions matter

---

The Reality Check

WordPress is not an app framework.
But you can bend it.
Hard.

Application pages don’t belong in wp_posts.
They belong in code.

24 pages.
0 posts.
0 database problems.
Maximum control.

Use this pattern and you stop fighting WordPress – you make it work for you.