Skip to main content

GHL Custom HTML Page Hosting SOP

Purpose​

How to publish a self-contained, pre-generated HTML page as a live page on a Symphony Core WordPress site, using the GHL Custom HTML Pages capability (WordPress hosting, inside app.symphonycore.com). This lets us serve hand-built or generated HTML (decks, microsites, one-off landing pages) on our own domain with the platform's SSL and hosting, and no on-the-fly rendering (the file is static, so there is zero per-request render cost).

The canonical worked example is the company overview deck: the deck's markdown source (sc-company-deck.md) is built into a single HTML file, which is published here at the slug company-overview and is live at https://symphonycore.com/pg/company-overview.

Scope​

Single-file static HTML pages hosted on a GHL-managed WordPress site. Covers the upload, publish, and update mechanics plus the file constraints to design around. Out of scope: builder-based (drag-and-drop) WordPress pages, GHL funnels, and authoring the HTML itself (that derives from a markdown source of truth — see Asset routing).

Prerequisites​

  • WordPress hosting active on the target Symphony Core site (Sites → WordPress; "Activate WordPress" if not already enabled). Domain mapping and SSL are handled by the platform.
  • A single, self-contained .html file, 1 MB or smaller, that meets the file requirements below (CSS inlined; images either inlined or referenced by absolute URL).
  • A decided page name and URL slug (e.g. company-overview). Use a clean, public-facing slug, not the internal Drive YYYY-MM-asset-... filename.
  • The final HTML staged in Drive per Asset routing (not left in the inbox).

Procedure​

  1. Open WordPress hosting: in app.symphonycore.com, go to Sites → WordPress. Click Activate WordPress if hosting is not yet enabled on the site.
  2. Manage the site: click Manage Website for the WordPress site you are publishing to.
  3. Open Pages: click the Pages tab at the top.
  4. Start an upload: click Upload New HTML Page.
  5. Name and slug: enter a Page Name and a Custom Site Slug (e.g. company-overview). The public URL is <domain>/pg/<slug>: GHL serves custom HTML pages under a /pg/ path, so this publishes to https://symphonycore.com/pg/company-overview, not the domain root. Keep the slug stable for the life of the page.
  6. Select the file: click the upload area and choose the .html file. Confirm it is the final version and under 1 MB.
  7. Confirm and preview: click Confirm & Preview and verify the layout, fonts, images, and content render correctly. Fix the source and re-export if anything is off (do not try to edit in the platform).
  8. (Optional) more pages: click Upload More Pages to queue additional single-file pages. Each upload is one page at one slug.
  9. Publish: click Publish to make the page live on the mapped domain. Then run Verification.

File requirements and limits​

These are hard platform constraints. Design the HTML to fit them before uploading.

  • One .html file per upload. No multi-file or multi-folder uploads. Each upload produces one page at one slug; multiple pages require multiple uploads.
  • Maximum file size: 1 MB.
  • No relative paths. All CSS, JavaScript, images, and fonts must be either inlined in the file or referenced by absolute URL (a CDN or the WordPress/GHL media library). A relative src="images/x.png" will not resolve.
  • Client-side scripts are supported (analytics, tracking pixels, etc.) as long as they load from absolute URLs.
  • No in-place editing or replacing. A published page's HTML cannot be edited, and there is no reliable replace; the only way to change it is to delete the page and recreate it (see Updating a published page).

Preparing the HTML to fit the limits​

  • Build from the source of truth, into one self-contained file. Inline the CSS in a <style> block in the <head> (our deck build already does this).
  • Images: prefer hosting on an absolute-URL CDN (the GHL media library serves files from storage.googleapis.com/msgsndr/..., the same place the SC logo lives) and referencing them. Small images may be inlined as base64 data URIs instead, but base64 inflates size by roughly a third, so watch the 1 MB cap. (The company deck inlines one founder photo and still lands near 160 KB, well under the limit.)
  • Fonts loaded from an absolute URL (e.g. Google Fonts) are fine.
  • Never reference a private/login-gated URL (e.g. a private Google Drive file): the page will fail to load that asset for public visitors. Use a truly public CDN URL or inline the asset. (Same failure mode as the Canva private-Drive caveat in the Social Planner SOP.)
  • Check the file size (ls -la / file properties) is under 1 MB before upload.

Matching the host site and keeping navigation in-page​

A custom HTML page does not inherit the WordPress theme's header, footer, or menu — it renders only what is in the file. So when the page sits alongside a normal site (not a standalone deck), the HTML must carry its own header/footer that looks native, and its links must behave like the rest of the site.

  • Replicate the live site's chrome. Build the page's own header and footer to match the host site: same logo, the same navigation items in the same order (add the current page to the menu and mark it as the active item), the same colour tokens, fonts, and button shape. Pull the exact values from the live site rather than guessing.
  • Keep navigation in the same tab. Internal and navigation links must not use target="_blank". A hosted page that carries its own nav otherwise spawns a new browser tab on every menu click, which breaks the in-site feel. Reserve target="_blank" for genuinely external destinations only, and even then confirm it is wanted.
  • Point CTAs at real destinations. "Request a quote" / contact buttons should link to the live contact form or a tel: link, not a placeholder.

SEO for hosted custom HTML pages​

A static custom HTML page is server-rendered real text, so it is crawlable and can rank — but only if it is discoverable and confirmed indexable. The page being live at /pg/<slug> is not enough on its own.

  • Real text, not an image or iframe. Keep the H1, headings, and body as actual selectable HTML text (this format already does), with one <title>, a meta description, a single H1 + heading hierarchy, and alt text on every image.
  • Link it internally. Custom HTML pages are orphaned by default — nothing on the main site links to them. Add the page to the main site's navigation menu (and an in-body link from a related page) so crawlers and visitors can reach it.
  • Get it in the XML sitemap, then request indexing.
  • Confirm it is indexable in Google Search Console (URL Inspection → Live Test): "Indexing allowed? Yes", no noindex, allowed by robots.txt, self-referencing canonical. Do not trust a static curl/WebFetch for this — a plugin- or JS-injected tag can differ from the served HTML. See ghl-funnel-wordpress-seo-sop.md for the live-test method and webfetch-unreliable-for-seo.
  • Add structured data (Service / LocalBusiness as relevant) so the page is eligible for richer results.
  • /pg/ is fine but not root-level. The URL is <domain>/pg/<slug>; a clean vanity URL needs a separate redirect (keep the slug stable either way).

Updating a published page​

You cannot edit or replace a hosted page's content in place (first-hand finding: there is no working in-place edit, and there is no reliable "upload new version" replace). To change a published page, delete it and create a new one with the same slug:

  1. Edit the source (e.g. the deck markdown), then regenerate the single .html file. Keep this file on hand before deleting anything.
  2. In Pages, delete the existing page.
  3. Upload a new page (per the Procedure above) and re-enter the exact same Custom Site Slug, so the public URL stays the same (<domain>/pg/<slug>).
  4. Publish and re-run Verification.

Caveats of delete-and-recreate:

  • Re-enter the exact same slug; if it differs, the URL changes and any existing links or embeds pointing at it break.
  • There is a brief window where the page is down (between delete and republish) — do updates at low-traffic times and recreate immediately.

Embeds and print-to-PDF​

  • Embeds and iframes (a YouTube video, a booking widget, a form) work the same way as other assets: reference them by absolute URL. A YouTube <iframe src="https://www.youtube.com/embed/..."> renders fine inside a custom HTML page. Verify on first embed.
  • Print-to-PDF (validated). When the page ships a print stylesheet (@media print with an @page size and per-slide page-break-after), the browser's Print → Save as PDF produces a clean, one-slide-per-page PDF. This removes the need to host a separate PDF file. For decks and one-pagers, add a "Print / Save as PDF" link in the page nav that calls window.print(), and keep the nav hidden in print (@media print { .deck-nav { display: none } }) so the control does not appear in the output. The company-overview deck is the worked example.

Verification​

  • Open the live URL on the mapped domain (https://<domain>/pg/<slug>, e.g. https://symphonycore.com/pg/company-overview) and confirm it loads over HTTPS (valid SSL).
  • Confirm fonts, images, and layout render correctly, and that no asset is broken (every absolute-URL asset resolves; nothing points at a private/login-gated link).
  • Check the page on mobile width.
  • Confirm navigation and CTA links open in the same tab (no stray target="_blank"), and that every link reaches a real destination (contact form, tel:, internal page).
  • Confirm the page's header, footer, nav items, colours, and fonts match the live site, and the current page is marked active in its own nav.
  • (Discoverability) confirm the page is linked from the main site nav, is in the sitemap, and is indexable per Google Search Console (see SEO for hosted custom HTML pages).
  • For an updated page (delete + recreate), confirm the same slug was reused so the URL is unchanged, and that it now serves the new content. Keep the previous .html file so you can roll back.

Asset routing and source-of-truth​

  • The source of truth is the markdown in this repo; the HTML is a generated, downstream artifact (see generated-outputs-to-drive).
  • The canonical generated .html lives in Drive (sc-docs-storage/...), never committed to the repo. The uploaded WordPress page is the published copy of that file.
  • When the source changes, regenerate the HTML, refresh the Drive copy, and republish by deleting and recreating the page with the same slug (see Updating a published page).

Known limitations (plan around these)​

  • 1 MB cap — keep inlined images small or move them to an absolute-URL CDN.
  • Absolute URLs only — no relative asset paths, no folder uploads.
  • One page per upload — batch via Upload More Pages, but each is its own slug.
  • No in-place edit or replace — a page's content cannot be changed after publishing; every update is a delete + recreate (see Updating a published page).
  • Pages live under /pg/ — the public URL is <domain>/pg/<slug>, not a root-level path. A clean root-level vanity URL (e.g. /company-overview) would need a separate redirect.
  • Updates mean a swap, with brief downtime — first-hand finding: there is no in-place edit and no reliable replace, so updating a live page means deleting it and recreating it with the same slug. Plan the swap for low-traffic times.

Revision History​

DateVersionChangeAuthor
2026-06-221.3Added learnings from hosting a client service page: a new Matching the host site and keeping navigation in-page section (replicate the live site's header/footer/nav/brand tokens since custom HTML pages don't inherit the theme; internal/nav links must not use target="_blank" so navigation stays in the same tab) and a new SEO for hosted custom HTML pages section (real text vs iframe, link from the main nav since these pages are orphaned by default, sitemap, confirm indexable in GSC, structured data, /pg/ slug note). Added matching verification bullets.Symphony Core Systems Team
2026-06-171.2Corrected the update procedure: first-hand finding that a hosted page's content cannot be edited or replaced in place (the KB "Upload New Version" path does not reliably replace content). Rewrote Updating a published page to the verified workaround: delete the page and recreate it with the same slug (with caveats: exact-slug reuse, brief downtime). Updated the matching limitation and verification bullets.Symphony Core Systems Team
2026-06-171.1Promoted to active after first-hand use (the company-overview page is live). Documented the /pg/ URL prefix (public URL is <domain>/pg/<slug>) across the worked example, procedure, and verification, and added it as a known gotcha. Added an Embeds and print-to-PDF section (iframes via absolute URLs; a print stylesheet plus a window.print() nav link replaces a hosted PDF). Replaced the pre-verification caveat with the confirmed reality.Symphony Core Systems Team
2026-06-161.0Initial draft. Documents the GHL WordPress Custom HTML Pages flow (upload, publish, Upload New Version for stable-slug updates), the single-file / 1 MB / absolute-URL constraints, and how we prepare a self-contained HTML from a markdown source. Transcribed from the HighLevel KB; pending first-run verification.Symphony Core Systems Team