diff --git a/.github/workflows/redirects.yml b/.github/workflows/redirects.yml
new file mode 100644
index 0000000..8a44333
--- /dev/null
+++ b/.github/workflows/redirects.yml
@@ -0,0 +1,20 @@
+name: Live redirect checks
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "43 8 * * 2"
+
+permissions:
+  contents: read
+
+jobs:
+  redirects:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v6
+
+      - name: Check deployed redirects and canonical destinations
+        run: python3 scripts/check-redirects.py
diff --git a/.github/workflows/terraform-modules.yml b/.github/workflows/terraform-modules.yml
index b7a9310..b0ddf30 100644
--- a/.github/workflows/terraform-modules.yml
+++ b/.github/workflows/terraform-modules.yml
@@ -85,4 +85,4 @@ jobs:
             Trigger: `${{ github.event_name }}`
             Reason: ${{ inputs.reason || 'Scheduled weekly refresh' }}
 
-            The generated module configuration, cards, and structured data are included in this pull request.
+            The generated module configuration, cards, structured data, and sitemap date are included in this pull request.
diff --git a/README.md b/README.md
index 9b4c22f..ae938d3 100644
--- a/README.md
+++ b/README.md
@@ -197,6 +197,17 @@ Run the repository SEO audit locally:
 python3 scripts/seo-audit.py
 ```
 
+After publishing, check live redirect chains and final canonical destinations:
+
+```sh
+python3 scripts/check-redirects.py
+```
+
+The separate `Live redirect checks` workflow checks production weekly and on
+manual runs. The local SEO audit also checks internal canonical links and
+fragments, distinct titles and descriptions, structured-data URLs, and sitemap
+freshness for the generated Terraform catalogue.
+
 The `Lighthouse and SEO` GitHub Actions workflow audits every canonical page
 on pull requests and pushes to `main`. It enforces minimum performance,
 accessibility, best-practices, and SEO scores together with lab thresholds for
@@ -204,6 +215,6 @@ Largest Contentful Paint, cumulative layout shift, and total blocking time. It
 also validates HTML and checks internal fragments and external links.
 
 Google Search Console requires account-issued ownership verification. Follow
-[`SEARCH_CONSOLE.md`](./SEARCH_CONSOLE.md) to add the URL-prefix property,
-install the unmodified verification file, submit the sitemap, and request
-indexing for each canonical page.
+[`SEARCH_CONSOLE.md`](./SEARCH_CONSOLE.md) to verify a Domain property, retain
+the unmodified verification file, submit the sitemap, and distinguish expected
+redirect exclusions from actual redirect errors.
diff --git a/SEARCH_CONSOLE.md b/SEARCH_CONSOLE.md
index 28a61ac..474c89c 100644
--- a/SEARCH_CONSOLE.md
+++ b/SEARCH_CONSOLE.md
@@ -3,8 +3,9 @@
 The repository is ready for Google Search Console: every indexable page has one
 self-referencing `https://native-cube.com/.../` canonical, explicit index/follow
 directives, matching Open Graph and structured-data URLs, and an entry in
-`sitemap.xml`. `robots.txt` advertises that sitemap, while the duplicate
-`/json-formatter/` alias remains excluded from indexing.
+`sitemap.xml`. `robots.txt` advertises that sitemap. The duplicate
+`/json-formatter/` alias points directly to `/yaml-formatter/` through an instant
+meta refresh and a canonical link; it is excluded from the sitemap and navigation.
 
 Ownership verification must be completed by a Google account with access to
 Search Console. The verification value is account-issued and must not be
@@ -35,7 +36,7 @@ invented or replaced with a placeholder.
    - `https://native-cube.com/visual-subnet-calculator/`
    - `https://native-cube.com/yaml-formatter/`
    - `https://native-cube.com/terraform-modules/`
-4. Do not submit `/json-formatter/`; it is a `noindex` convenience alias.
+4. Do not submit `/json-formatter/`; it is a permanent redirect alias.
 
 ## Confirm Google's selected canonical
 
@@ -49,3 +50,88 @@ sitemap.
 
 The account owner can provide the downloaded verification file to a
 contributor for placement, but should not share Google credentials.
+
+## Redirect exclusions versus redirect failures
+
+Search Console's **Page with redirect** is expected for HTTP, `www`, the old
+GitHub Pages hostname, paths missing their trailing slash, and `/json-formatter/`.
+Google indexes the destination instead. Those source URLs should remain
+excluded; repeatedly validating them as indexable pages will not fix anything.
+
+**Redirect error** is different: Google could not follow a chain because of a
+loop, excessive redirects, an invalid or empty destination, or an overly long
+URL. Copy the exact affected URL from the report and inspect every hop and the
+final destination. **Alternate page with proper canonical tag** is also expected
+for `/index.html` duplicates that GitHub Pages serves with HTTP 200.
+
+These distinctions are documented in Google's
+[Page indexing report help](https://support.google.com/webmasters/answer/7440203).
+
+## Check the deployed site
+
+Run the dependency-free live audit after deployment:
+
+```sh
+python3 scripts/check-redirects.py
+```
+
+It checks every sitemap page across HTTP/HTTPS, apex/`www`, and the old GitHub
+Pages hostname, plus slashless paths, `index.html` duplicates, and formatter
+aliases. It follows HTTP and instant meta-refresh redirects explicitly, rejects
+loops and temporary or insecure redirects, and checks that each final page is
+HTTP 200 with the expected canonical and no indexing restrictions. The separate
+**Live redirect checks** workflow runs weekly and can be started manually in
+Actions. It checks production, so run it after the source changes are published.
+
+An optional user agent helps investigate response differences:
+
+```sh
+python3 scripts/check-redirects.py --user-agent Googlebot
+```
+
+Changing a user-agent string does not reproduce Google's crawler network or
+replace Search Console's **Test live URL**.
+
+Public HTTP checks on 2 November 2026 confirmed that all eight canonical pages
+returned 200 and the tested HTTP, `www`, and GitHub Pages variants redirected
+permanently to the apex HTTPS URLs. The formatter alias still served the old
+`noindex` directive before this change was deployed. This is a consolidation
+signal issue; it does not prove the cause of an account's **Redirect error**.
+
+## Hosting settings and the formatter alias
+
+Keep **Settings → Pages → Custom domain** set to `native-cube.com` and
+**Enforce HTTPS** enabled. The repository's `CNAME` file does not by itself
+enforce HTTPS or configure DNS. Both the apex and `www` DNS records must point
+to GitHub Pages for GitHub's automatic hostname redirect and HTTPS certificate
+to work. See GitHub's
+[custom-domain configuration](https://docs.github.com/en/pages/configuring-a-custom-domain-for-your-github-pages-site/managing-a-custom-domain-for-your-github-pages-site)
+and [HTTPS settings](https://docs.github.com/en/pages/getting-started-with-github-pages/securing-your-github-pages-site-with-https).
+
+GitHub Pages serves static HTML and does not provide per-path HTTP redirect
+rules in this repository. The formatter alias therefore uses an instant meta
+refresh, which Google treats as a permanent redirect, plus a matching absolute
+canonical and fallback link. JavaScript preserves query strings and fragments
+for visitors. See Google's
+[redirect guidance](https://developers.google.com/search/docs/crawling-indexing/301-redirects).
+An HTTP 301 for this alias would require redirect support at a hosting or proxy
+layer. Do not add redirect files for other hosting services and expect GitHub
+Pages to apply them.
+
+Do not use `noindex` to consolidate the alias with its destination; rely on the
+redirect and canonical together. Google's
+[canonicalization guidance](https://developers.google.com/search/docs/crawling-indexing/consolidate-duplicate-urls)
+explains why `noindex` is unsuitable for canonical selection.
+
+After publishing, rerun the live audit, resubmit the canonical sitemap, and use
+**Test live URL** for each affected destination. Request indexing for canonical
+pages and validate actual **Redirect error** fixes. Historical exclusions remain
+until Google recrawls them, and intentional redirects remain excluded.
+
+## Keep sitemap dates accurate
+
+Update a page's `lastmod` when its public content or metadata changes. The
+Terraform renderer updates its sitemap date from the published catalogue's
+`synced_at` value while preserving a later manual edit date. Include `sitemap.xml`
+in catalogue update commits. The local SEO audit rejects a Terraform sitemap
+date older than the catalogue. Do not reset every date simply because CI ran.
diff --git a/argocd-applicationset-studio/index.html b/argocd-applicationset-studio/index.html
index 481524f..a9eac89 100644
--- a/argocd-applicationset-studio/index.html
+++ b/argocd-applicationset-studio/index.html
@@ -153,7 +153,7 @@
       <section class="hero">
         <div class="hero-intro">
           <p class="eyebrow">Argo CD / Fleet engineering</p>
-          <h1>Preview the fleet.<br /><em>Ship with confidence.</em></h1>
+          <h1>Preview Argo CD ApplicationSets.<br /><em>Review your fleet.</em></h1>
         </div>
         <div class="hero-copy">
           <p>
diff --git a/helm-chart-builder/index.html b/helm-chart-builder/index.html
index 361e651..a6c9c7a 100644
--- a/helm-chart-builder/index.html
+++ b/helm-chart-builder/index.html
@@ -141,7 +141,7 @@
       <section class="hero">
         <div>
           <p class="eyebrow">Helm / Chart authoring</p>
-          <h1>Shape the values.<br /><em>Generate the chart.</em></h1>
+          <h1>Build a Helm chart.<br /><em>Download it in seconds.</em></h1>
         </div>
         <div class="hero-copy">
           <p>
diff --git a/json-formatter/index.html b/json-formatter/index.html
index 926f8f4..d664059 100644
--- a/json-formatter/index.html
+++ b/json-formatter/index.html
@@ -3,15 +3,14 @@
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <meta name="robots" content="noindex" />
-    <meta http-equiv="refresh" content="0; url=../yaml-formatter/" />
+    <meta http-equiv="refresh" content="0; url=https://native-cube.com/yaml-formatter/" />
     <link
       rel="canonical"
       href="https://native-cube.com/yaml-formatter/"
     />
     <title>Redirecting to YAML &amp; JSON Formatter | Native Cube</title>
     <script>
-      const destination = new URL("../yaml-formatter/", window.location.href);
+      const destination = new URL("https://native-cube.com/yaml-formatter/");
       destination.search = window.location.search;
       destination.hash = window.location.hash;
       window.location.replace(destination);
@@ -20,7 +19,7 @@
   <body>
     <p>
       Redirecting to the
-      <a href="../yaml-formatter/">YAML &amp; JSON Formatter</a>.
+      <a href="https://native-cube.com/yaml-formatter/">YAML &amp; JSON Formatter</a>.
     </p>
   </body>
 </html>
diff --git a/kubernetes-rbac-explorer/index.html b/kubernetes-rbac-explorer/index.html
index 0aafa51..a115297 100644
--- a/kubernetes-rbac-explorer/index.html
+++ b/kubernetes-rbac-explorer/index.html
@@ -146,7 +146,7 @@
       <section class="hero">
         <div>
           <p class="eyebrow">Kubernetes / Access control</p>
-          <h1>See who can do what.<br /><em>Know exactly why.</em></h1>
+          <h1>Explore Kubernetes RBAC.<br /><em>See who can do what.</em></h1>
         </div>
         <p class="hero-copy">
           Turn Roles and bindings into an understandable access map. Test an
diff --git a/scripts/check-redirects.py b/scripts/check-redirects.py
new file mode 100644
index 0000000..44b6931
--- /dev/null
+++ b/scripts/check-redirects.py
@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""Check deployed HTTP and instant meta-refresh redirects without dependencies."""
+
+import argparse
+from concurrent.futures import ThreadPoolExecutor
+from html.parser import HTMLParser
+from pathlib import Path
+import re
+import sys
+from urllib.error import HTTPError
+from urllib.parse import urljoin, urlsplit
+from urllib.request import build_opener, HTTPRedirectHandler, Request
+import xml.etree.ElementTree as ET
+
+
+ROOT = Path(__file__).resolve().parent.parent
+SITE_URL = "https://native-cube.com"
+HOSTS = (
+    SITE_URL,
+    "http://native-cube.com",
+    "https://www.native-cube.com",
+    "http://www.native-cube.com",
+    "https://native-cube.github.io",
+    "http://native-cube.github.io",
+)
+PERMANENT = {301, 308}
+
+
+class NoRedirect(HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+class Page(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.canonicals = []
+        self.refreshes = []
+        self.robots = []
+
+    def handle_starttag(self, tag, attrs):
+        values = dict(attrs)
+        if tag == "link" and "canonical" in values.get("rel", "").lower().split():
+            self.canonicals.append(values.get("href", ""))
+        if tag == "meta":
+            if values.get("http-equiv", "").lower() == "refresh":
+                self.refreshes.append(values.get("content", ""))
+            if values.get("name", "").lower() in {"robots", "googlebot"}:
+                self.robots.append(values.get("content", "").lower())
+
+
+def fetch(url, user_agent):
+    opener = build_opener(NoRedirect)
+    try:
+        response = opener.open(Request(url, headers={"User-Agent": user_agent}), timeout=20)
+    except HTTPError as error:
+        response = error
+    with response:
+        return response.status, response.headers, response.read().decode("utf-8", "replace")
+
+
+def check_url(source, expected, user_agent):
+    current = source
+    seen = set()
+    chain = []
+    try:
+        for _ in range(6):
+            if current in seen:
+                raise ValueError("redirect loop")
+            seen.add(current)
+            status, headers, body = fetch(current, user_agent)
+            chain.append(f"{status} {current}")
+            if 300 <= status < 400:
+                if status not in PERMANENT:
+                    raise ValueError(f"expected a permanent redirect, got {status}")
+                location = headers.get("Location")
+                if not location:
+                    raise ValueError("redirect has no Location header")
+                destination = urljoin(current, location)
+            elif status == 200:
+                page = Page()
+                page.feed(body)
+                directives = page.robots + [headers.get("X-Robots-Tag", "").lower()]
+                if any("noindex" in value or "nofollow" in value for value in directives):
+                    raise ValueError("indexing or following is blocked")
+                if page.refreshes:
+                    if len(page.refreshes) != 1:
+                        raise ValueError("multiple meta-refresh redirects")
+                    match = re.fullmatch(r"0\s*;\s*url=(.+)", page.refreshes[0], re.I)
+                    if not match:
+                        raise ValueError("meta refresh must be an instant permanent redirect")
+                    destination = urljoin(current, match[1].strip("\"'"))
+                    if destination != expected or page.canonicals != [expected]:
+                        raise ValueError("meta refresh and canonical must point directly to target")
+                    chain.append(f"meta refresh -> {destination}")
+                else:
+                    # GitHub Pages serves /index.html duplicates with 200. Their
+                    # canonical consolidates them without a client-side redirect.
+                    duplicate = expected + "index.html"
+                    if current not in {expected, duplicate}:
+                        raise ValueError(f"chain ended at {current}, expected {expected}")
+                    if page.canonicals != [expected]:
+                        raise ValueError(f"expected exactly one canonical: {expected}")
+                    if "text/html" not in headers.get("Content-Type", ""):
+                        raise ValueError("target is not served as HTML")
+                    return True, " -> ".join(chain)
+            else:
+                raise ValueError(f"unexpected HTTP {status}")
+            target = urlsplit(destination)
+            if target.hostname not in {"native-cube.com", "www.native-cube.com", "native-cube.github.io"}:
+                raise ValueError(f"redirect leaves the site: {destination}")
+            if target.scheme != "https":
+                raise ValueError(f"redirect does not use HTTPS: {destination}")
+            current = destination
+        raise ValueError("more than five redirects")
+    except Exception as error:
+        return False, f"{' -> '.join(chain) or source}: {error}"
+
+
+def redirect_cases():
+    namespace = {"s": "http://www.sitemaps.org/schemas/sitemap/0.9"}
+    sitemap = ET.parse(ROOT / "sitemap.xml")
+    cases = {}
+    for node in sitemap.findall("s:url/s:loc", namespace):
+        canonical = node.text
+        if not canonical or not canonical.startswith(SITE_URL + "/"):
+            raise ValueError("sitemap contains a non-canonical URL")
+        path = urlsplit(canonical).path
+        for host in HOSTS:
+            cases[host + path] = canonical
+        cases[canonical + "index.html"] = canonical
+        if path != "/":
+            cases[canonical.rstrip("/")] = canonical
+    target = SITE_URL + "/yaml-formatter/"
+    for host in HOSTS:
+        cases[host + "/json-formatter/"] = target
+    cases[SITE_URL + "/json-formatter"] = target
+    cases[SITE_URL + "/json-formatter/index.html"] = target
+    return list(cases.items())
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--user-agent", default="NativeCubeSEOAudit/1.0")
+    args = parser.parse_args()
+    cases = redirect_cases()
+    with ThreadPoolExecutor(max_workers=6) as pool:
+        results = list(pool.map(lambda case: check_url(*case, args.user_agent), cases))
+    for passed, detail in results:
+        print(f"{'PASS' if passed else 'FAIL'} {detail}")
+    failures = sum(not passed for passed, _ in results)
+    print(f"Live redirect audit: {len(results) - failures}/{len(results)} passed")
+    return 1 if failures else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/seo-audit.py b/scripts/seo-audit.py
index 5e204bd..a708a43 100644
--- a/scripts/seo-audit.py
+++ b/scripts/seo-audit.py
@@ -7,7 +7,7 @@
 import struct
 import sys
 import xml.etree.ElementTree as ET
-from urllib.parse import urlsplit
+from urllib.parse import unquote, urljoin, urlsplit
 
 
 ROOT = Path(__file__).resolve().parent.parent
@@ -145,11 +145,18 @@ def assert_social_image(url):
         )
 
 
+parsed_pages = {}
+titles = set()
+descriptions = set()
 for path, canonical in PAGES.items():
     page = parse_page(path)
+    parsed_pages[canonical] = page
     title = "".join(page.title).strip()
     if not title:
         fail(f"{path} has no title")
+    if title in titles:
+        fail(f"{path} repeats another page's title")
+    titles.add(title)
     if page.h1_count != 1:
         fail(f"{path} has {page.h1_count} h1 elements; expected exactly one")
     if len(page.canonicals) != 1:
@@ -169,6 +176,11 @@ def assert_social_image(url):
     missing_meta = sorted(key for key in REQUIRED_META if not page.meta.get(key))
     if missing_meta:
         fail(f"{path} is missing metadata: {', '.join(missing_meta)}")
+    if page.meta["description"] in descriptions:
+        fail(f"{path} repeats another page's description")
+    descriptions.add(page.meta["description"])
+    if "refresh" in page.meta:
+        fail(f"{path} is a canonical page but contains a redirect")
     if page.meta.get("og:url") != canonical:
         fail(f"{path} og:url does not match its canonical URL")
     robots = {
@@ -186,16 +198,40 @@ def assert_social_image(url):
         fail(f"{path} uses different Open Graph and Twitter images")
 
     assert_social_image(page.meta["og:image"])
+    if not page.json_ld:
+        fail(f"{path} has no structured data")
+    entities = []
     for payload in page.json_ld:
-        json.loads(payload)
+        data = json.loads(payload)
+        entities.extend(data if isinstance(data, list) else [data])
+    if not any(entity.get("url") == canonical for entity in entities):
+        fail(f"{path} structured data does not identify its canonical URL")
+
+for canonical, page in parsed_pages.items():
+    if len(page.ids) != len(set(page.ids)):
+        fail(f"{canonical} has duplicate HTML IDs")
+    for link in page.links:
+        target = urlsplit(urljoin(canonical, link))
+        if target.hostname in {"www.native-cube.com", "native-cube.github.io"}:
+            fail(f"{canonical} links to a non-canonical hostname: {link}")
+        if target.hostname != "native-cube.com":
+            continue
+        target_url = f"{target.scheme}://{target.netloc}{target.path}"
+        if target_url not in parsed_pages:
+            fail(f"{canonical} links to a non-canonical or missing page: {link}")
+        if target.fragment and unquote(target.fragment) not in parsed_pages[target_url].ids:
+            fail(f"{canonical} links to a missing fragment: {link}")
 
 redirect = parse_page(REDIRECT_PATH)
-if redirect.meta.get("robots") != "noindex":
-    fail(f"{REDIRECT_PATH} must remain noindex")
-if redirect.meta.get("canonical") != PAGES[Path("yaml-formatter/index.html")]:
+redirect_target = PAGES[Path("yaml-formatter/index.html")]
+if "noindex" in redirect.meta.get("robots", "").lower():
+    fail(f"{REDIRECT_PATH} must consolidate with its target without noindex")
+if redirect.canonicals != [redirect_target]:
     fail(f"{REDIRECT_PATH} must canonicalize to /yaml-formatter/")
-if "../yaml-formatter/" not in redirect.meta.get("refresh", ""):
-    fail(f"{REDIRECT_PATH} meta refresh must target /yaml-formatter/")
+if redirect.meta.get("refresh") != f"0; url={redirect_target}":
+    fail(f"{REDIRECT_PATH} must immediately redirect to the absolute canonical URL")
+if redirect_target not in redirect.links:
+    fail(f"{REDIRECT_PATH} must provide a direct fallback link to its target")
 
 namespace = {"sitemap": "http://www.sitemaps.org/schemas/sitemap/0.9"}
 sitemap = ET.parse(ROOT / "sitemap.xml")
@@ -222,6 +258,10 @@ def assert_social_image(url):
         fail(f"sitemap entry {location} has invalid lastmod value {last_modified}")
     if modified_date > date.today():
         fail(f"sitemap entry {location} has a future lastmod value")
+    if location == PAGES[Path("terraform-modules/index.html")]:
+        catalogue = json.loads((ROOT / "terraform-modules/modules.json").read_text())
+        if modified_date < date.fromisoformat(catalogue["synced_at"].split("T")[0]):
+            fail("Terraform sitemap lastmod predates the published catalogue")
 
 robots = (ROOT / "robots.txt").read_text()
 if f"Sitemap: {SITE_URL}/sitemap.xml" not in robots:
diff --git a/scripts/sync-terraform-modules.py b/scripts/sync-terraform-modules.py
index b349d3e..f332be1 100755
--- a/scripts/sync-terraform-modules.py
+++ b/scripts/sync-terraform-modules.py
@@ -17,6 +17,7 @@
 CATALOGUE_PATH = ROOT / "terraform-modules/modules.json"
 SCHEMA_PATH = ROOT / "terraform-modules/modules.schema.json"
 PAGE_PATH = ROOT / "terraform-modules/index.html"
+SITEMAP_PATH = ROOT / "sitemap.xml"
 APP_PATH = ROOT / "terraform-modules/app.js"
 JSON_LD_START = "<!-- MODULE_JSON_LD_START -->"
 JSON_LD_END = "<!-- MODULE_JSON_LD_END -->"
@@ -695,6 +696,19 @@ def write_catalogue(catalogue):
 
 def write_page(catalogue):
     PAGE_PATH.write_text(rendered_page(catalogue))
+    # Preserve a later date from a manual content edit, while ensuring weekly
+    # catalogue updates also tell crawlers that the published page has changed.
+    sitemap = SITEMAP_PATH.read_text()
+    pattern = r"(<loc>https://native-cube\.com/terraform-modules/</loc>\s*<lastmod>)([^<]+)(</lastmod>)"
+    synced_date = catalogue["synced_at"].split("T", 1)[0]
+    updated, count = re.subn(
+        pattern,
+        lambda match: match[1] + max(match[2], synced_date) + match[3],
+        sitemap,
+    )
+    if count != 1:
+        raise SyncError("sitemap.xml must contain one dated Terraform catalogue entry")
+    SITEMAP_PATH.write_text(updated)
 
 
 def metadata_drift(stored, live):
diff --git a/sitemap.xml b/sitemap.xml
index 843eb66..ab3cbf5 100644
--- a/sitemap.xml
+++ b/sitemap.xml
@@ -10,15 +10,15 @@
   </url>
   <url>
     <loc>https://native-cube.com/helm-chart-builder/</loc>
-    <lastmod>2026-08-19</lastmod>
+    <lastmod>2026-11-02</lastmod>
   </url>
   <url>
     <loc>https://native-cube.com/argocd-applicationset-studio/</loc>
-    <lastmod>2026-08-19</lastmod>
+    <lastmod>2026-11-02</lastmod>
   </url>
   <url>
     <loc>https://native-cube.com/kubernetes-rbac-explorer/</loc>
-    <lastmod>2026-08-19</lastmod>
+    <lastmod>2026-11-02</lastmod>
   </url>
   <url>
     <loc>https://native-cube.com/visual-subnet-calculator/</loc>
@@ -26,10 +26,10 @@
   </url>
   <url>
     <loc>https://native-cube.com/yaml-formatter/</loc>
-    <lastmod>2026-08-19</lastmod>
+    <lastmod>2026-11-02</lastmod>
   </url>
   <url>
     <loc>https://native-cube.com/terraform-modules/</loc>
-    <lastmod>2026-08-28</lastmod>
+    <lastmod>2026-10-12</lastmod>
   </url>
 </urlset>
diff --git a/yaml-formatter/index.html b/yaml-formatter/index.html
index 9e23a6d..9ee72df 100644
--- a/yaml-formatter/index.html
+++ b/yaml-formatter/index.html
@@ -146,7 +146,7 @@
       <section class="hero">
         <div>
           <p class="eyebrow">YAML / JSON</p>
-          <h1>Clean up your config.<br /><em>Catch every error.</em></h1>
+          <h1>Format YAML and JSON.<br /><em>Validate your config.</em></h1>
         </div>
         <p class="hero-copy">
           Format, validate, and convert YAML or JSON without leaving your