diff --git a/docusaurus.config.js b/docusaurus.config.js
index ec3984ad19..f94170d33b 100644
--- a/docusaurus.config.js
+++ b/docusaurus.config.js
@@ -2,6 +2,8 @@
 
 import {themes as prismThemes} from "prism-react-renderer";
 const path = require("path");
+const remarkFaqSchema = require("./src/remark/remarkFaqSchema");
+const {siteGraph} = require("./src/schema/siteEntities");
 const fs = require("fs");
 import {visit} from "unist-util-visit";
 const FontPreloadPlugin = require("webpack-font-preload-plugin");
@@ -60,121 +62,17 @@ module.exports = {
         href: "https://keploy.io/",
       },
     },
+    // Site-wide entity graph (Organization, WebSite, SoftwareApplication).
+    // These used to be three sibling <script> blocks, each re-declaring its
+    // own publisher, which left several disconnected Organization nodes on
+    // every page. They now share one graph and are addressable by `@id`, so
+    // per-page schema can point at them instead of copying them.
     {
       tagName: "script",
       attributes: {
         type: "application/ld+json",
       },
-      innerHTML: JSON.stringify({
-        "@context": "https://schema.org",
-        "@type": "SoftwareApplication",
-        name: "Keploy",
-        description:
-          "Keploy is an open-source, AI-powered testing agent and sandboxing platform that automatically generates test cases, dependency mocks, and production-like sandboxes from real user traffic using eBPF. It helps developers achieve 90% test coverage in minutes with zero code changes. Native support is available on Linux; macOS and Windows require a Linux environment such as Lima, WSL, or Docker.",
-        applicationCategory: "DeveloperTool",
-        applicationSubCategory: "Test Automation",
-        operatingSystem: "Linux",
-        license: "https://www.apache.org/licenses/LICENSE-2.0",
-        softwareHelp: "https://keploy.io/docs/",
-        codeRepository: "https://github.com/keploy/keploy",
-        downloadUrl: "https://github.com/keploy/keploy/releases",
-        isAccessibleForFree: true,
-        url: "https://keploy.io",
-        featureList: [
-          "Automatic test case generation from real user traffic",
-          "Production-like sandbox environments from captured traffic",
-          "AI-powered dependency virtualization and mock generation",
-          "Record and replay testing with eBPF kernel capture",
-          "AI noise detection for flaky test elimination",
-          "Legacy application testing without code changes",
-          "Migration regression testing against production baselines",
-          "Continuous validation in CI/CD pipelines",
-          "Multi-language support (Go, Java, TypeScript, Python)",
-        ],
-        keywords: [
-          "test automation",
-          "API testing",
-          "API test generation",
-          "unit testing",
-          "integration testing",
-          "mock generation",
-          "dependency virtualization",
-          "eBPF-based testing",
-          "record and replay",
-          "production sandbox",
-        ],
-        programmingLanguage: [
-          "Go",
-          "Java",
-          "TypeScript",
-          "JavaScript",
-          "Python",
-        ],
-        publisher: {
-          "@type": "Organization",
-          name: "Keploy",
-          url: "https://keploy.io",
-        },
-      }),
-    },
-    {
-      tagName: "script",
-      attributes: {
-        type: "application/ld+json",
-      },
-      innerHTML: JSON.stringify({
-        "@context": "https://schema.org/",
-        "@type": "Organization",
-        name: "Keploy",
-        url: "https://keploy.io/",
-        logo: "https://keploy.io/images/keploy-logo-full.svg",
-        foundingDate: "2021-01-01",
-        knowsAbout: [
-          "API Testing",
-          "Test Automation",
-          "eBPF-based Testing",
-          "Dependency Virtualization",
-          "AI-Powered Testing",
-        ],
-        award: [
-          "API World 2023 Award: Best in API Infrastructure",
-          "CNCF Landscape",
-          "Google for Startups Accelerator",
-          "Google Summer of Code Mentoring Organization",
-        ],
-        sameAs: [
-          "https://github.com/keploy",
-          "https://twitter.com/Keployio",
-          "https://www.linkedin.com/company/keploy",
-          "https://www.youtube.com/@keploy",
-          "https://discord.gg/keploy",
-          "https://community.keploy.io",
-          "https://marketplace.visualstudio.com/items?itemName=Keploy.keployio",
-          "https://chromewebstore.google.com/detail/keploy-api-test-recorder/ohcclfkaidblnjnggclkiecgkpgldihe",
-          "https://www.crunchbase.com/organization/hybridk8s",
-          "https://www.gartner.com/reviews/product/keploy-618993540",
-          "https://www.g2.com/products/keploy/reviews",
-          "https://www.capterra.in/software/1070466/Keploy",
-          "https://aws.amazon.com/marketplace/reviews/reviews-list/prodview-xgwmdk4ivjjv4",
-        ],
-      }),
-    },
-    {
-      tagName: "script",
-      attributes: {
-        type: "application/ld+json",
-      },
-      innerHTML: JSON.stringify({
-        "@context": "https://schema.org/",
-        "@type": "WebSite",
-        name: "Keploy Documentation",
-        url: "https://keploy.io/docs/",
-        potentialAction: {
-          "@type": "SearchAction",
-          target: "https://keploy.io/docs/search?q={search_term_string}",
-          "query-input": "required name=search_term_string",
-        },
-      }),
+      innerHTML: JSON.stringify(siteGraph),
     },
     // Meta Pixel Code
     {
@@ -484,6 +382,9 @@ fbq('track', 'PageView');`,
                 },
               {},
             ],
+            // Emit FAQPage JSON-LD (Question/Answer) for FAQ docs so they are
+            // eligible for FAQ rich results and AI extraction.
+            remarkFaqSchema,
           ],
         },
         // Will be passed to @docusaurus/plugin-content-blog
diff --git a/scripts/verify-schema-graph.js b/scripts/verify-schema-graph.js
new file mode 100644
index 0000000000..d42e6be3d1
--- /dev/null
+++ b/scripts/verify-schema-graph.js
@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+/**
+ * Verifies the JSON-LD graph in the built site.
+ *
+ * The @id-based consolidation only pays off if every bare {"@id": "..."}
+ * reference resolves to a node actually defined on the same page -- an
+ * unresolved reference is worse than the inline duplicate it replaced,
+ * because consumers get a dangling pointer instead of an entity. This walks
+ * the built HTML and fails on unparseable JSON-LD or dangling references.
+ *
+ * Usage: node scripts/verify-schema-graph.js [buildDir]
+ */
+const fs = require("fs");
+const path = require("path");
+
+const buildDir = process.argv[2] || "build";
+const SKIP_VERSIONS = ["/1.0.0/", "/2.0.0/"];
+
+function findHtml(dir, out = []) {
+  for (const entry of fs.readdirSync(dir, {withFileTypes: true})) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      findHtml(full, out);
+    } else if (entry.name === "index.html") {
+      out.push(full);
+    }
+  }
+  return out;
+}
+
+// The build inlines JSON-LD into <script type="application/ld+json">. Entities
+// are HTML-escaped by React, so unescape before parsing.
+const SCRIPT_RE =
+  /<script[^>]*type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/g;
+
+function unescapeHtml(s) {
+  return s
+    .replace(/&quot;/g, '"')
+    .replace(/&#x27;/g, "'")
+    .replace(/&#39;/g, "'")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&amp;/g, "&");
+}
+
+// Collect every node that declares an @id, and every bare {"@id"} reference.
+function walk(node, defined, referenced) {
+  if (Array.isArray(node)) {
+    node.forEach((n) => walk(n, defined, referenced));
+    return;
+  }
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  const keys = Object.keys(node).filter((k) => k !== "@context");
+  if (node["@id"]) {
+    // A node carrying only "@id" is a reference; anything else defines it.
+    if (keys.length === 1) {
+      referenced.add(node["@id"]);
+    } else {
+      defined.add(node["@id"]);
+    }
+  }
+  for (const key of keys) {
+    walk(node[key], defined, referenced);
+  }
+}
+
+const files = findHtml(buildDir).filter(
+  (f) => !SKIP_VERSIONS.some((v) => f.includes(v))
+);
+
+let parseErrors = 0;
+let dangling = 0;
+let blocks = 0;
+const typeCounts = new Map();
+
+for (const file of files) {
+  const html = fs.readFileSync(file, "utf8");
+  const defined = new Set();
+  const referenced = new Set();
+  let match;
+  SCRIPT_RE.lastIndex = 0;
+  while ((match = SCRIPT_RE.exec(html))) {
+    blocks += 1;
+    let parsed;
+    try {
+      parsed = JSON.parse(unescapeHtml(match[1]));
+    } catch (err) {
+      parseErrors += 1;
+      console.error(`INVALID JSON-LD  ${file}\n  ${err.message}`);
+      continue;
+    }
+    const graph = parsed["@graph"] || parsed;
+    walk(graph, defined, referenced);
+    for (const n of Array.isArray(graph) ? graph : [graph]) {
+      const t = n && n["@type"];
+      if (typeof t === "string") {
+        typeCounts.set(t, (typeCounts.get(t) || 0) + 1);
+      }
+    }
+  }
+  for (const ref of referenced) {
+    if (!defined.has(ref)) {
+      dangling += 1;
+      console.error(`DANGLING @id     ${file}\n  ${ref}`);
+    }
+  }
+}
+
+console.log(`\nPages scanned:     ${files.length}`);
+console.log(`JSON-LD blocks:    ${blocks}`);
+console.log(`Invalid JSON:      ${parseErrors}`);
+console.log(`Dangling @id refs: ${dangling}`);
+console.log("\nTop-level @type distribution:");
+for (const [type, count] of [...typeCounts].sort((a, b) => b[1] - a[1])) {
+  console.log(`  ${String(count).padStart(5)}  ${type}`);
+}
+
+process.exit(parseErrors || dangling ? 1 : 0);
diff --git a/src/components/GetStartedPaths.js b/src/components/GetStartedPaths.js
index b7aa5cf12e..881abda4f5 100644
--- a/src/components/GetStartedPaths.js
+++ b/src/components/GetStartedPaths.js
@@ -4,6 +4,37 @@ import useBaseUrl from "@docusaurus/useBaseUrl";
 import {FaRocket, FaMagic, FaRetweet, FaLaptopCode} from "react-icons/fa";
 import {SiKubernetes} from "react-icons/si";
 
+// The four entry points rendered as cards below, in display order. Exported
+// so the docs home can emit them as an ItemList off the same data the links
+// are built from -- a hand-copied list in the JSON-LD would quietly rot the
+// first time one of these paths moves.
+export const GET_STARTED_PATHS = [
+  {
+    name: "Generate from OpenAPI Schema / Postman Collection / cURL",
+    description:
+      "Connect resources in Keploy Console and generate validated suites",
+    href: "/docs/running-keploy/generate-api-tests-using-ai/",
+  },
+  {
+    name: "Record with Chrome extension",
+    description: "Turn browser actions into API test flows (no mocks)",
+    href: "/docs/running-keploy/api-testing-chrome-extension/",
+  },
+  {
+    name: "Record in K8s, Replay Anywhere (Local/CI/K8s)",
+    description: "Capture from staging/prod, replay in your pipeline",
+    href: "/docs/quickstart/k8s-proxy/",
+  },
+  {
+    name: "Record Locally",
+    description: "Classic Keploy CLI experience for rapid iteration",
+    href: "/docs/server/installation/",
+  },
+];
+
+const [AI_GENERATE, CHROME_EXTENSION, K8S_PROXY, LOCAL_RECORD] =
+  GET_STARTED_PATHS;
+
 export const GetStartedPaths = () => {
   return (
     <section className="mb-12">
@@ -24,7 +55,7 @@ export const GetStartedPaths = () => {
       {/* Two Paths Grid */}
       <div className="grid gap-6 md:grid-cols-2">
         {/* AI Test Generation */}
-        <div className="group relative overflow-hidden rounded-2xl border border-gray-200 bg-gradient-to-br from-white to-orange-50/50 p-6 h-full shadow-sm transition-all duration-300 hover:shadow-lg hover:shadow-orange-100/50 dark:border-gray-700 dark:from-gray-800 dark:to-orange-950/20 dark:hover:shadow-orange-900/20">
+        <div className="group relative h-full overflow-hidden rounded-2xl border border-gray-200 bg-gradient-to-br from-white to-orange-50/50 p-6 shadow-sm transition-all duration-300 hover:shadow-lg hover:shadow-orange-100/50 dark:border-gray-700 dark:from-gray-800 dark:to-orange-950/20 dark:hover:shadow-orange-900/20">
           {/* Decorative gradient blob */}
           <div className="absolute -right-10 -top-10 h-32 w-32 rounded-full bg-gradient-to-br from-orange-400/20 to-orange-600/10 blur-2xl transition-transform duration-500 group-hover:scale-150"></div>
 
@@ -80,10 +111,8 @@ export const GetStartedPaths = () => {
             {/* Console Options */}
             <div className="mt-auto space-y-3 pt-2">
               <Link
-                to={useBaseUrl(
-                  "/docs/running-keploy/generate-api-tests-using-ai/"
-                )}
-                className="group/option flex items-start justify-between gap-3 rounded-xl border border-gray-200 bg-white/50 p-3 min-h-[92px] transition-all duration-200 hover:border-orange-300 hover:bg-orange-50/50 hover:no-underline dark:border-gray-600 dark:bg-gray-800/50 dark:hover:border-orange-500/50 dark:hover:bg-orange-900/10"
+                to={useBaseUrl(AI_GENERATE.href)}
+                className="group/option flex min-h-[92px] items-start justify-between gap-3 rounded-xl border border-gray-200 bg-white/50 p-3 transition-all duration-200 hover:border-orange-300 hover:bg-orange-50/50 hover:no-underline dark:border-gray-600 dark:bg-gray-800/50 dark:hover:border-orange-500/50 dark:hover:bg-orange-900/10"
               >
                 <div className="flex items-start gap-3">
                   <div className="flex h-10 w-10 flex-shrink-0 items-center justify-center rounded-lg bg-orange-100 text-orange-700 transition-colors group-hover/option:bg-orange-100 group-hover/option:text-orange-800 dark:bg-orange-900/30 dark:text-orange-300">
@@ -105,10 +134,8 @@ export const GetStartedPaths = () => {
               </Link>
 
               <Link
-                to={useBaseUrl(
-                  "/docs/running-keploy/api-testing-chrome-extension/"
-                )}
-                className="group/option flex items-start justify-between gap-3 rounded-xl border border-gray-200 bg-white/50 p-3 min-h-[92px] transition-all duration-200 hover:border-orange-300 hover:bg-orange-50/50 hover:no-underline dark:border-gray-600 dark:bg-gray-800/50 dark:hover:border-orange-500/50 dark:hover:bg-orange-900/10"
+                to={useBaseUrl(CHROME_EXTENSION.href)}
+                className="group/option flex min-h-[92px] items-start justify-between gap-3 rounded-xl border border-gray-200 bg-white/50 p-3 transition-all duration-200 hover:border-orange-300 hover:bg-orange-50/50 hover:no-underline dark:border-gray-600 dark:bg-gray-800/50 dark:hover:border-orange-500/50 dark:hover:bg-orange-900/10"
               >
                 <div className="flex items-start gap-3">
                   <div className="flex h-10 w-10 flex-shrink-0 items-center justify-center rounded-lg bg-orange-100 text-orange-700 transition-colors group-hover/option:bg-orange-100 group-hover/option:text-orange-800 dark:bg-orange-900/30 dark:text-orange-300">
@@ -132,7 +159,7 @@ export const GetStartedPaths = () => {
         </div>
 
         {/* Record & Replay */}
-        <div className="group relative overflow-hidden rounded-2xl border border-gray-200 bg-gradient-to-br from-white to-purple-50/50 p-6 h-full shadow-sm transition-all duration-300 hover:shadow-lg hover:shadow-purple-100/50 dark:border-gray-700 dark:from-gray-800 dark:to-purple-950/20 dark:hover:shadow-purple-900/20">
+        <div className="group relative h-full overflow-hidden rounded-2xl border border-gray-200 bg-gradient-to-br from-white to-purple-50/50 p-6 shadow-sm transition-all duration-300 hover:shadow-lg hover:shadow-purple-100/50 dark:border-gray-700 dark:from-gray-800 dark:to-purple-950/20 dark:hover:shadow-purple-900/20">
           {/* Decorative gradient blob */}
           <div className="absolute -right-10 -top-10 h-32 w-32 rounded-full bg-gradient-to-br from-purple-400/20 to-purple-600/10 blur-2xl transition-transform duration-500 group-hover:scale-150"></div>
 
@@ -187,8 +214,8 @@ export const GetStartedPaths = () => {
             {/* Sub-Options */}
             <div className="mt-auto space-y-3 pt-2">
               <Link
-                to={useBaseUrl("/docs/quickstart/k8s-proxy/")}
-                className="group/option flex items-start justify-between gap-3 rounded-xl border border-gray-200 bg-white/50 p-3 min-h-[92px] transition-all duration-200 hover:border-purple-300 hover:bg-purple-50/50 hover:no-underline dark:border-gray-600 dark:bg-gray-800/50 dark:hover:border-purple-500/50 dark:hover:bg-purple-900/10"
+                to={useBaseUrl(K8S_PROXY.href)}
+                className="group/option flex min-h-[92px] items-start justify-between gap-3 rounded-xl border border-gray-200 bg-white/50 p-3 transition-all duration-200 hover:border-purple-300 hover:bg-purple-50/50 hover:no-underline dark:border-gray-600 dark:bg-gray-800/50 dark:hover:border-purple-500/50 dark:hover:bg-purple-900/10"
               >
                 <div className="flex items-start gap-3">
                   <div className="flex h-10 w-10 flex-shrink-0 items-center justify-center rounded-lg bg-purple-100 text-purple-700 transition-colors group-hover/option:bg-purple-100 group-hover/option:text-purple-800 dark:bg-purple-900/30 dark:text-purple-200">
@@ -209,8 +236,8 @@ export const GetStartedPaths = () => {
               </Link>
 
               <Link
-                to={useBaseUrl("/docs/server/installation/")}
-                className="group/option flex items-start justify-between gap-3 rounded-xl border border-gray-200 bg-white/50 p-3 min-h-[92px] transition-all duration-200 hover:border-purple-300 hover:bg-purple-50/50 hover:no-underline dark:border-gray-600 dark:bg-gray-800/50 dark:hover:border-purple-500/50 dark:hover:bg-purple-900/10"
+                to={useBaseUrl(LOCAL_RECORD.href)}
+                className="group/option flex min-h-[92px] items-start justify-between gap-3 rounded-xl border border-gray-200 bg-white/50 p-3 transition-all duration-200 hover:border-purple-300 hover:bg-purple-50/50 hover:no-underline dark:border-gray-600 dark:bg-gray-800/50 dark:hover:border-purple-500/50 dark:hover:bg-purple-900/10"
               >
                 <div className="flex items-start gap-3">
                   <div className="flex h-10 w-10 flex-shrink-0 items-center justify-center rounded-lg bg-purple-100 text-purple-700 transition-colors group-hover/option:bg-purple-100 group-hover/option:text-purple-800 dark:bg-purple-900/30 dark:text-purple-200">
diff --git a/src/components/GlossaryCard.js b/src/components/GlossaryCard.js
index 3444522354..1b6248afb6 100644
--- a/src/components/GlossaryCard.js
+++ b/src/components/GlossaryCard.js
@@ -1,10 +1,16 @@
 import React from "react";
+import Link from "@docusaurus/Link";
 import ArrowUpRight from "../../static/img/ArrowUpRight.svg";
 
+// Uses Docusaurus `Link` rather than a bare `<a>` for two reasons: a glossary
+// entry pointing at a slug that doesn't exist now fails the build
+// (`onBrokenLinks: "throw"`) instead of shipping a 404 that only surfaces in a
+// crawl, and `Link` applies the site's `trailingSlash` setting, so these
+// hand-written slash-less paths stop costing a 301 on every click.
 const GlossaryCard = ({name, description, link}) => {
   return (
-    <a
-      href={link}
+    <Link
+      to={link}
       className="group flex h-full flex-col rounded-xl border border-transparent bg-[var(--ifm-card-background-color)] p-6 shadow-[0_4px_12px_var(--ifm-card-shadow-color)] transition-all duration-300 hover:border-[var(--ifm-color-primary)] hover:shadow-[0_8px_20px_var(--ifm-card-shadow-color)] focus:outline-none focus:ring-2 focus:ring-[var(--ifm-color-primary)] focus:ring-offset-2
       "
     >
@@ -20,7 +26,7 @@ const GlossaryCard = ({name, description, link}) => {
       <p className="text-sm leading-relaxed text-[var(--ifm-color-emphasis-700)]">
         {description}
       </p>
-    </a>
+    </Link>
   );
 };
 
diff --git a/src/pages/about.js b/src/pages/about.js
index a7633f3042..9c2661972a 100644
--- a/src/pages/about.js
+++ b/src/pages/about.js
@@ -1,9 +1,15 @@
 import React from "react";
 import Layout from "@theme/Layout";
 import Head from "@docusaurus/Head";
+import {
+  SITE_URL as SITE,
+  DOCS_URL,
+  organizationRef,
+  websiteRef,
+} from "../schema/siteEntities";
 
 // Custom React pages under src/pages/ are not covered by the docs schema
-// plugin — add Article + BreadcrumbList JSON-LD inline so the page is
+// plugin — add AboutPage + BreadcrumbList JSON-LD inline so the page is
 // machine-readable for search engines and AI crawlers.
 //
 // Site config sets `trailingSlash: true`, so canonical URLs in the JSON-LD
@@ -21,40 +27,26 @@ const ABOUT_TITLE = "About the Keploy Documentation";
 const ABOUT_DESCRIPTION =
   "Information about Keploy's documentation, contribution guidelines, and licensing.";
 
-// Derive every canonical URL from a single `SITE` + path constants instead
-// of hardcoding `https://keploy.io/docs/...` in each field — mirrors the
-// pattern in concepts/reference/glossary.js. If the domain or docs baseUrl
-// ever changes, the Article/BreadcrumbList structured data updates in one
-// place instead of going stale field-by-field.
-//
-// Site config sets `trailingSlash: true`, so paths that map to a page carry
-// a trailing slash to match the canonical href and avoid duplicate-URL
-// variants in structured data.
-const SITE = "https://keploy.io";
+// Canonical URLs derive from the shared site constants so the domain and
+// docs baseUrl live in one place. Site config sets `trailingSlash: true`, so
+// paths that map to a page carry a trailing slash to match the canonical href
+// and avoid duplicate-URL variants in structured data.
 const HOME_URL = `${SITE}/`;
-const DOCS_URL = `${SITE}/docs/`;
-const ABOUT_URL = `${SITE}/docs/about/`;
-const LOGO_URL = `${SITE}/docs/img/favicon.png`;
+const ABOUT_URL = `${DOCS_URL}about/`;
 
 const aboutStructuredData = [
   {
     "@context": "https://schema.org",
-    "@type": "Article",
-    headline: ABOUT_TITLE,
+    // AboutPage rather than Article: this is standing information about the
+    // documentation itself (SLA, contribution, licensing), with no author,
+    // byline or publication date for an Article to carry.
+    "@type": "AboutPage",
+    "@id": ABOUT_URL,
+    name: ABOUT_TITLE,
     description: ABOUT_DESCRIPTION,
     url: ABOUT_URL,
-    publisher: {
-      "@type": "Organization",
-      name: "Keploy",
-      logo: {
-        "@type": "ImageObject",
-        url: LOGO_URL,
-      },
-    },
-    mainEntityOfPage: {
-      "@type": "WebPage",
-      "@id": ABOUT_URL,
-    },
+    isPartOf: websiteRef,
+    publisher: organizationRef,
   },
   {
     "@context": "https://schema.org",
diff --git a/src/pages/concepts/reference/glossary.js b/src/pages/concepts/reference/glossary.js
index 7baf19d0e5..7e904d4b4f 100644
--- a/src/pages/concepts/reference/glossary.js
+++ b/src/pages/concepts/reference/glossary.js
@@ -5,6 +5,15 @@ import BackToTopButton from "@theme/BackToTopButton";
 
 import {glossaryEntries} from "../../../../static/data/glossaryEntries";
 import GlossaryCard from "../../../components/GlossaryCard";
+import {
+  SITE_URL as SITE,
+  DOCS_URL,
+  GLOSSARY_URL,
+  TERMSET_ID,
+  organizationRef,
+  websiteRef,
+  withTrailingSlash,
+} from "../../../schema/siteEntities";
 
 // SEO/GEO: turn each glossary entry into a DefinedTerm inside a single
 // DefinedTermSet so AI engines can cite individual definitions and engines
@@ -15,15 +24,6 @@ import GlossaryCard from "../../../components/GlossaryCard";
 // trailing slash to match the canonical href. Otherwise Google treats the
 // no-slash variant as a duplicate URL of the canonical one.
 const allGlossaryItems = Object.values(glossaryEntries).flat();
-const SITE = "https://keploy.io";
-const GLOSSARY_PATH = "/docs/concepts/reference/glossary/";
-const GLOSSARY_URL = `${SITE}${GLOSSARY_PATH}`;
-const TERMSET_ID = `${GLOSSARY_URL}#termset`;
-
-function withTrailingSlash(path) {
-  if (!path) return path;
-  return path.endsWith("/") ? path : `${path}/`;
-}
 
 const glossaryStructuredData = [
   {
@@ -34,6 +34,8 @@ const glossaryStructuredData = [
     description:
       "Definitions for software testing, test automation, and quality engineering terminology, maintained by the Keploy documentation team.",
     url: GLOSSARY_URL,
+    isPartOf: websiteRef,
+    publisher: organizationRef,
     // Defensive: an entry without a valid `link` (e.g. a typoed key like
     // `ink:`) would emit `https://keploy.ioundefined` into the JSON-LD.
     // Drop those entries here so structured data never carries a malformed
@@ -42,25 +44,31 @@ const glossaryStructuredData = [
       .filter(
         (entry) => typeof entry.link === "string" && entry.link.length > 0
       )
-      .map((entry) => ({
-        "@type": "DefinedTerm",
-        name: entry.name,
-        description: entry.description,
-        url: `${SITE}${withTrailingSlash(entry.link)}`,
-        inDefinedTermSet: TERMSET_ID,
-      })),
+      .map((entry) => {
+        const url = `${SITE}${withTrailingSlash(entry.link)}`;
+        return {
+          "@type": "DefinedTerm",
+          // Same `@id` the term's own page emits, so the hub listing and the
+          // term page resolve to one entity instead of two near-duplicates.
+          "@id": `${url}#term`,
+          name: entry.name,
+          description: entry.description,
+          url,
+          inDefinedTermSet: TERMSET_ID,
+        };
+      }),
   },
   {
     "@context": "https://schema.org",
     "@type": "BreadcrumbList",
     itemListElement: [
       {"@type": "ListItem", position: 1, name: "Home", item: `${SITE}/`},
-      {"@type": "ListItem", position: 2, name: "Docs", item: `${SITE}/docs/`},
+      {"@type": "ListItem", position: 2, name: "Docs", item: DOCS_URL},
       {
         "@type": "ListItem",
         position: 3,
         name: "Concepts",
-        item: `${SITE}/docs/concepts/`,
+        item: `${DOCS_URL}concepts/`,
       },
       {"@type": "ListItem", position: 4, name: "Glossary", item: GLOSSARY_URL},
     ],
diff --git a/src/pages/index.js b/src/pages/index.js
index 51aa1c2482..e5ed72a8ad 100644
--- a/src/pages/index.js
+++ b/src/pages/index.js
@@ -10,6 +10,8 @@ import {
   WhatIsKeploy,
   EcosystemSupport,
 } from "../components";
+import {GET_STARTED_PATHS} from "../components/GetStartedPaths";
+import {organizationRef, websiteRef} from "../schema/siteEntities";
 //import {Intro} from "../components";
 export default function Home() {
   const context = useDocusaurusContext();
@@ -57,23 +59,31 @@ export default function Home() {
     "Keploy Documentation — Install, Capture & Replay API Tests";
   const docsHomeDescription =
     "Install Keploy in 5 minutes, capture real API traffic with eBPF, and replay it as deterministic tests in CI. Quickstarts, SDK references, and integration guides.";
-  const articleSchema = docsUrl
+  // CollectionPage, not Article: this page is an index of the docs, with no
+  // single author, publication date or headline. DocItem already suppresses
+  // Article on /docs/ for exactly that reason, so emitting one here left the
+  // site's only generic Article on the page the rule was written for. The
+  // ItemList mirrors the four entry-point cards GetStartedPaths renders.
+  const collectionPageSchema = docsUrl
     ? {
         "@context": "https://schema.org",
-        "@type": "Article",
-        headline: docsHomeTitle,
+        "@type": "CollectionPage",
+        "@id": docsUrl,
+        name: docsHomeTitle,
         description: docsHomeDescription,
-        mainEntityOfPage: {
-          "@type": "WebPage",
-          "@id": docsUrl,
-        },
-        publisher: {
-          "@type": "Organization",
-          name: "Keploy",
-          logo: {
-            "@type": "ImageObject",
-            url: "https://keploy.io/docs/img/favicon.png",
-          },
+        url: docsUrl,
+        isPartOf: websiteRef,
+        publisher: organizationRef,
+        mainEntity: {
+          "@type": "ItemList",
+          name: "Ways to get started with Keploy",
+          itemListElement: GET_STARTED_PATHS.map((path, i) => ({
+            "@type": "ListItem",
+            position: i + 1,
+            name: path.name,
+            description: path.description,
+            url: toAbsoluteUrl(siteConfig.url, path.href),
+          })),
         },
       }
     : null;
@@ -86,9 +96,9 @@ export default function Home() {
             {JSON.stringify(breadcrumbSchema)}
           </script>
         )}
-        {articleSchema && (
+        {collectionPageSchema && (
           <script type="application/ld+json">
-            {JSON.stringify(articleSchema)}
+            {JSON.stringify(collectionPageSchema)}
           </script>
         )}
       </Head>
diff --git a/src/pages/leadership.js b/src/pages/leadership.js
index 07fb122a9c..7b7ce0f590 100644
--- a/src/pages/leadership.js
+++ b/src/pages/leadership.js
@@ -2,15 +2,58 @@ import React from "react";
 import clsx from "clsx";
 import Layout from "@theme/Layout";
 import Link from "@docusaurus/Link";
+import Head from "@docusaurus/Head";
 import useDocusaurusContext from "@docusaurus/useDocusaurusContext";
 import useBaseUrl from "@docusaurus/useBaseUrl";
 import styles from "./styles.module.css";
+import {DOCS_URL, organizationRef, websiteRef} from "../schema/siteEntities";
 
 export default function Security() {
   const context = useDocusaurusContext();
   const {siteConfig = {}} = context;
+  const team = [
+    {
+      name: "Neha Gupta",
+      image: "https://avatars.githubusercontent.com/u/15074229?v=4",
+      sameAs: "https://twitter.com/know_neha",
+    },
+    {
+      name: "Shubham Jain",
+      image: "https://avatars.githubusercontent.com/u/12831254?v=4",
+      sameAs: "https://twitter.com/slayerjain",
+    },
+  ];
+  // CollectionPage of Person entities so search engines / AI can resolve the
+  // Keploy leadership team (name, photo, social profile) as structured people.
+  const leadershipSchema = {
+    "@context": "https://schema.org",
+    "@type": "CollectionPage",
+    name: "Keploy Leadership",
+    url: `${DOCS_URL}Leadership/`,
+    isPartOf: websiteRef,
+    publisher: organizationRef,
+    mainEntity: {
+      "@type": "ItemList",
+      itemListElement: team.map((person, i) => ({
+        "@type": "ListItem",
+        position: i + 1,
+        item: {
+          "@type": "Person",
+          name: person.name,
+          image: person.image,
+          worksFor: organizationRef,
+          sameAs: [person.sameAs],
+        },
+      })),
+    },
+  };
   return (
     <Layout title="Leadership" permalink="/Leadership" description="<head />">
+      <Head>
+        <script type="application/ld+json">
+          {JSON.stringify(leadershipSchema)}
+        </script>
+      </Head>
       <div className="my-15 mx-auto w-auto">
         <ul className="text-center">
           <li className="my-7">
diff --git a/src/pages/privacy-policy.js b/src/pages/privacy-policy.js
index ca0001a355..e7f764a820 100644
--- a/src/pages/privacy-policy.js
+++ b/src/pages/privacy-policy.js
@@ -1,16 +1,34 @@
 import React from "react";
 import Layout from "@theme/Layout";
+import Head from "@docusaurus/Head";
 import useDocusaurusContext from "@docusaurus/useDocusaurusContext";
+import {DOCS_URL, organizationRef, websiteRef} from "../schema/siteEntities";
 
 function PrivacyPolicy() {
   const context = useDocusaurusContext();
   const {siteConfig = {}} = context;
+  // DigitalDocument with a real dateModified so the legal doc's freshness is
+  // machine-readable rather than emitting nothing.
+  const privacySchema = {
+    "@context": "https://schema.org",
+    "@type": "DigitalDocument",
+    name: "Keploy, Inc. Privacy Policy",
+    url: `${DOCS_URL}privacy-policy/`,
+    dateModified: "2024-04-28",
+    isPartOf: websiteRef,
+    publisher: organizationRef,
+  };
   return (
     <Layout
       title="Keploy, Inc. Privacy Policy"
       permalink="/privacy-policy"
       description="Privacy Policy information about Keploy."
     >
+      <Head>
+        <script type="application/ld+json">
+          {JSON.stringify(privacySchema)}
+        </script>
+      </Head>
       <main className="margin-vert--lg container">
         <div className="pb-5 text-center text-4xl font-bold">
           Keploy Inc. Privacy Policy
diff --git a/src/pages/security.js b/src/pages/security.js
index c1ccb251ce..a8a9a416b3 100644
--- a/src/pages/security.js
+++ b/src/pages/security.js
@@ -2,19 +2,61 @@ import React from "react";
 import clsx from "clsx";
 import Layout from "@theme/Layout";
 import Link from "@docusaurus/Link";
+import Head from "@docusaurus/Head";
 import useDocusaurusContext from "@docusaurus/useDocusaurusContext";
 import useBaseUrl from "@docusaurus/useBaseUrl";
 import styles from "./styles.module.css";
+import {
+  DOCS_URL,
+  ORGANIZATION_ID,
+  organizationRef,
+  websiteRef,
+} from "../schema/siteEntities";
 
 export default function Security() {
   const context = useDocusaurusContext();
   const {siteConfig = {}} = context;
+  // WebPage + security ContactPoint so the responsible-disclosure channel is
+  // machine-readable (this page is linked from every doc footer).
+  const securitySchema = {
+    "@context": "https://schema.org",
+    "@graph": [
+      {
+        "@type": "WebPage",
+        "@id": `${DOCS_URL}security/`,
+        name: "Keploy Security Practices and Policies",
+        url: `${DOCS_URL}security/`,
+        description:
+          "Learn how Keploy ensures data protection, privacy, and secure testing — Keploy's security measures, policies, and responsible-disclosure process.",
+        isPartOf: websiteRef,
+        publisher: organizationRef,
+      },
+      {
+        // Shares the site-wide Organization's `@id`, so the disclosure
+        // address attaches to that entity rather than creating a second
+        // Keploy. This is the page that documents the channel, so the
+        // property is declared here rather than on every route.
+        "@type": "Organization",
+        "@id": ORGANIZATION_ID,
+        contactPoint: {
+          "@type": "ContactPoint",
+          contactType: "security",
+          email: "hello@keploy.io",
+        },
+      },
+    ],
+  };
   return (
     <Layout
       title="Keploy Security"
       permalink="/security"
       description="<head />"
     >
+      <Head>
+        <script type="application/ld+json">
+          {JSON.stringify(securitySchema)}
+        </script>
+      </Head>
       <header className={clsx("hero hero--primary", styles.heroBanner)}>
         <div className="container">
           <h1 className="hero__title text-black">
diff --git a/src/remark/remarkFaqSchema.js b/src/remark/remarkFaqSchema.js
new file mode 100644
index 0000000000..5604b819cd
--- /dev/null
+++ b/src/remark/remarkFaqSchema.js
@@ -0,0 +1,116 @@
+// remarkFaqSchema — emit FAQPage JSON-LD for FAQ docs.
+//
+// FAQ pages (keploy-explained/*-faq.md) are written as a list of
+// `### <question>` headings each followed by answer prose. Google/AI can only
+// extract them as an FAQ rich result if the page carries FAQPage structured
+// data with Question/Answer pairs — which Docusaurus does not generate.
+//
+// This build-time plugin detects FAQ docs (by file path), pulls each level-2/3
+// heading as a Question and the prose that follows (until the next heading) as
+// the acceptedAnswer, and injects a <script type="application/ld+json"> block.
+// Dependency-free; never throws — a page it can't parse is simply left as-is.
+
+// Collect the plain-text content of an mdast node subtree (headings, prose).
+function textOf(node) {
+  if (!node) return "";
+  if (typeof node.value === "string") return node.value; // text, inlineCode
+  if (Array.isArray(node.children)) {
+    return node.children.map(textOf).join("");
+  }
+  return "";
+}
+
+// Strip a leading list number ("1. ", "12. ") that FAQ headings use.
+function cleanQuestion(text) {
+  return text.replace(/^\s*\d+[.)]\s*/, "").trim();
+}
+
+function isFaqFile(file) {
+  const p = (file && (file.path || file.history?.[0])) || "";
+  return /-faq\.mdx?$/.test(p);
+}
+
+function remarkFaqSchema() {
+  return function transformer(tree, file) {
+    try {
+      if (!isFaqFile(file)) return;
+      const children = Array.isArray(tree.children) ? tree.children : [];
+
+      const qa = [];
+      let current = null;
+      for (const node of children) {
+        if (node.type === "heading" && (node.depth === 2 || node.depth === 3)) {
+          // flush previous
+          if (current && current.answer.trim()) qa.push(current);
+          const q = cleanQuestion(textOf(node));
+          // skip the page's own title-style h2/h3 that isn't a question
+          current = q ? {question: q, answer: ""} : null;
+        } else if (current && node.type !== "heading") {
+          const t = textOf(node).trim();
+          if (t) current.answer += (current.answer ? " " : "") + t;
+        } else if (node.type === "heading" && node.depth <= 1) {
+          if (current && current.answer.trim()) qa.push(current);
+          current = null;
+        }
+      }
+      if (current && current.answer.trim()) qa.push(current);
+
+      // Only emit when we found real Q&A pairs.
+      if (qa.length < 2) return;
+
+      const schema = {
+        "@context": "https://schema.org",
+        "@type": "FAQPage",
+        mainEntity: qa.map((item) => ({
+          "@type": "Question",
+          name: item.question,
+          acceptedAnswer: {"@type": "Answer", text: item.answer},
+        })),
+      };
+
+      // Inject inside a <head> block: Docusaurus hoists MDX <head> content to
+      // the document head (a bare <script> in the body is stripped). The script
+      // child is a JS string-literal expression `{"...json..."}`, so the JSX
+      // evaluates back to the exact JSON string at render time (matches the
+      // DocItem JSON-LD pattern). MDX needs an estree AST on expression nodes,
+      // so build a minimal Program(Literal) rather than only a raw value.
+      const jsonString = JSON.stringify(schema);
+      const raw = JSON.stringify(jsonString);
+      const jsonExpression = {
+        type: "mdxFlowExpression",
+        value: jsonString,
+        data: {
+          estree: {
+            type: "Program",
+            sourceType: "module",
+            body: [
+              {
+                type: "ExpressionStatement",
+                expression: {type: "Literal", value: jsonString, raw},
+              },
+            ],
+          },
+        },
+      };
+      // Emit as a plain <script> in the page body. react-dom/server treats
+      // <script> as a raw-text element, so the JSON renders unescaped (clean
+      // quotes) — matching how the site's <HowTo> component emits JSON-LD.
+      tree.children.push({
+        type: "mdxJsxFlowElement",
+        name: "script",
+        attributes: [
+          {
+            type: "mdxJsxAttribute",
+            name: "type",
+            value: "application/ld+json",
+          },
+        ],
+        children: [jsonExpression],
+      });
+    } catch (_e) {
+      // Never break the build over a schema nicety.
+    }
+  };
+}
+
+module.exports = remarkFaqSchema;
diff --git a/src/schema/siteEntities.js b/src/schema/siteEntities.js
new file mode 100644
index 0000000000..81da27f89e
--- /dev/null
+++ b/src/schema/siteEntities.js
@@ -0,0 +1,158 @@
+/**
+ * Canonical schema.org nodes for the docs site.
+ *
+ * Consumers merge JSON-LD nodes that share an `@id`, so each entity is
+ * declared once here and referenced by `@id` everywhere else. Without that,
+ * a single doc page emitted four unrelated Organization nodes -- the
+ * site-wide one, `SoftwareApplication.publisher`, `Article.author` and
+ * `Article.publisher` -- which had already drifted apart, carrying two
+ * different logo URLs between them.
+ *
+ * CommonJS because docusaurus.config.js require()s this alongside the ESM
+ * theme components and pages that import it.
+ */
+
+const SITE_URL = "https://keploy.io";
+// `trailingSlash: true`, so URLs emitted into JSON-LD need the slash to match
+// the canonical href instead of the variant that 301s to it.
+const DOCS_URL = `${SITE_URL}/docs/`;
+
+const ORGANIZATION_ID = `${SITE_URL}/#organization`;
+const WEBSITE_ID = `${DOCS_URL}#website`;
+const SOFTWARE_APPLICATION_ID = `${SITE_URL}/#keploy`;
+const GLOSSARY_URL = `${DOCS_URL}concepts/reference/glossary/`;
+const TERMSET_ID = `${GLOSSARY_URL}#termset`;
+
+// Bare `@id` references. The full nodes below ship in the <head> of every
+// route via the site-wide `headTags` graph, so these always resolve.
+const organizationRef = {"@id": ORGANIZATION_ID};
+const websiteRef = {"@id": WEBSITE_ID};
+
+// `trailingSlash: true` means the slash-less form of any internal path 301s
+// to the canonical one. Hand-written paths (glossary data, hard-coded hrefs)
+// routinely omit it, which costs a redirect hop for users and makes JSON-LD
+// URLs disagree with the canonical tag.
+function withTrailingSlash(path) {
+  if (!path || path.endsWith("/")) {
+    return path;
+  }
+  return `${path}/`;
+}
+
+const organizationNode = {
+  "@type": "Organization",
+  "@id": ORGANIZATION_ID,
+  name: "Keploy",
+  url: `${SITE_URL}/`,
+  logo: {
+    "@type": "ImageObject",
+    "@id": `${SITE_URL}/#logo`,
+    url: `${SITE_URL}/images/keploy-logo-full.svg`,
+    caption: "Keploy",
+  },
+  foundingDate: "2021-01-01",
+  knowsAbout: [
+    "API Testing",
+    "Test Automation",
+    "eBPF-based Testing",
+    "Dependency Virtualization",
+    "AI-Powered Testing",
+  ],
+  award: [
+    "API World 2023 Award: Best in API Infrastructure",
+    "CNCF Landscape",
+    "Google for Startups Accelerator",
+    "Google Summer of Code Mentoring Organization",
+  ],
+  sameAs: [
+    "https://github.com/keploy",
+    "https://twitter.com/Keployio",
+    "https://www.linkedin.com/company/keploy",
+    "https://www.youtube.com/@keploy",
+    "https://discord.gg/keploy",
+    "https://community.keploy.io",
+    "https://marketplace.visualstudio.com/items?itemName=Keploy.keployio",
+    "https://chromewebstore.google.com/detail/keploy-api-test-recorder/ohcclfkaidblnjnggclkiecgkpgldihe",
+    "https://www.crunchbase.com/organization/hybridk8s",
+    "https://www.gartner.com/reviews/product/keploy-618993540",
+    "https://www.g2.com/products/keploy/reviews",
+    "https://www.capterra.in/software/1070466/Keploy",
+    "https://aws.amazon.com/marketplace/reviews/reviews-list/prodview-xgwmdk4ivjjv4",
+  ],
+};
+
+const websiteNode = {
+  "@type": "WebSite",
+  "@id": WEBSITE_ID,
+  name: "Keploy Documentation",
+  url: DOCS_URL,
+  publisher: organizationRef,
+  potentialAction: {
+    "@type": "SearchAction",
+    target: `${DOCS_URL}search?q={search_term_string}`,
+    "query-input": "required name=search_term_string",
+  },
+};
+
+const softwareApplicationNode = {
+  "@type": "SoftwareApplication",
+  "@id": SOFTWARE_APPLICATION_ID,
+  name: "Keploy",
+  description:
+    "Keploy is an open-source, AI-powered testing agent and sandboxing platform that automatically generates test cases, dependency mocks, and production-like sandboxes from real user traffic using eBPF. It helps developers achieve 90% test coverage in minutes with zero code changes. Native support is available on Linux; macOS and Windows require a Linux environment such as Lima, WSL, or Docker.",
+  applicationCategory: "DeveloperTool",
+  applicationSubCategory: "Test Automation",
+  operatingSystem: "Linux",
+  license: "https://www.apache.org/licenses/LICENSE-2.0",
+  softwareHelp: DOCS_URL,
+  codeRepository: "https://github.com/keploy/keploy",
+  downloadUrl: "https://github.com/keploy/keploy/releases",
+  isAccessibleForFree: true,
+  url: SITE_URL,
+  featureList: [
+    "Automatic test case generation from real user traffic",
+    "Production-like sandbox environments from captured traffic",
+    "AI-powered dependency virtualization and mock generation",
+    "Record and replay testing with eBPF kernel capture",
+    "AI noise detection for flaky test elimination",
+    "Legacy application testing without code changes",
+    "Migration regression testing against production baselines",
+    "Continuous validation in CI/CD pipelines",
+    "Multi-language support (Go, Java, TypeScript, Python)",
+  ],
+  keywords: [
+    "test automation",
+    "API testing",
+    "API test generation",
+    "unit testing",
+    "integration testing",
+    "mock generation",
+    "dependency virtualization",
+    "eBPF-based testing",
+    "record and replay",
+    "production sandbox",
+  ],
+  programmingLanguage: ["Go", "Java", "TypeScript", "JavaScript", "Python"],
+  publisher: organizationRef,
+};
+
+// One graph for the whole site, injected into every route via `headTags`.
+// Replaces three sibling <script> blocks that each re-declared the publisher.
+const siteGraph = {
+  "@context": "https://schema.org",
+  "@graph": [organizationNode, websiteNode, softwareApplicationNode],
+};
+
+module.exports = {
+  SITE_URL,
+  DOCS_URL,
+  ORGANIZATION_ID,
+  WEBSITE_ID,
+  SOFTWARE_APPLICATION_ID,
+  GLOSSARY_URL,
+  TERMSET_ID,
+  organizationRef,
+  websiteRef,
+  siteGraph,
+  withTrailingSlash,
+};
diff --git a/src/theme/DocItem/index.js b/src/theme/DocItem/index.js
index 9d09f48a1d..4dd1bfbf2b 100644
--- a/src/theme/DocItem/index.js
+++ b/src/theme/DocItem/index.js
@@ -24,6 +24,12 @@ import useDocusaurusContext from "@docusaurus/useDocusaurusContext";
 import {useDocsVersion} from "@docusaurus/plugin-content-docs/client";
 import {KeployCloud} from "@site/src/components/KeployCloud";
 import MarkdownPageActions from "@site/src/components/MarkdownPageActions";
+import {
+  organizationRef,
+  websiteRef,
+  TERMSET_ID,
+  withTrailingSlash,
+} from "@site/src/schema/siteEntities";
 
 export default function DocItem(props) {
   const {content: DocContent} = props;
@@ -107,7 +113,15 @@ export default function DocItem(props) {
       })
       .filter(Boolean);
   };
-  const pageUrl = toAbsoluteUrl(siteConfig?.url, metadata?.permalink);
+  // `metadata.permalink` omits the trailing slash even under
+  // `trailingSlash: true`, while the canonical tag and og:url both carry it.
+  // Every `@id` derived from pageUrl has to match the canonical URL exactly,
+  // otherwise the nodes keyed on it never merge with the ones the glossary hub
+  // and other pages emit, and the graph fragments again along a bare slash.
+  const canonicalPermalink = siteConfig?.trailingSlash
+    ? withTrailingSlash(metadata?.permalink)
+    : metadata?.permalink;
+  const pageUrl = toAbsoluteUrl(siteConfig?.url, canonicalPermalink);
   const modifiedTime = toIsoDate(
     metadata?.lastUpdatedAt || frontMatter?.lastUpdatedAt
   );
@@ -116,21 +130,31 @@ export default function DocItem(props) {
   );
   const schemaTypeFromFrontMatter =
     frontMatter?.schemaType || frontMatter?.schema_type;
+  const docTags = frontMatter?.tags || [];
   const isApi =
     frontMatter?.apiReference === true ||
     frontMatter?.type === "api" ||
-    (frontMatter?.tags || []).includes?.("api");
+    docTags.includes?.("api") ||
+    docTags.includes?.("api-testing") ||
+    // API-reference doc paths (suites, endpoints, CLI, SDK install).
+    /\/running-keploy\/(api-testing-|public-api|cli-commands)|\/server\/sdk-installation\//.test(
+      metadata?.permalink || ""
+    );
   const isBlog =
     frontMatter?.type === "blog" ||
     frontMatter?.blog === true ||
-    (frontMatter?.tags || []).includes?.("blog");
+    docTags.includes?.("blog");
+  // Every Keploy doc is a technical article, so default to TechArticle rather
+  // than the generic Article (both are Article subtypes accepting the same
+  // properties as articleSchema below — no shape change, just a precise type).
+  // API-reference pages use the more specific APIReference.
   const schemaType = schemaTypeFromFrontMatter
     ? schemaTypeFromFrontMatter
     : isApi
       ? "APIReference"
       : isBlog
         ? "BlogPosting"
-        : "Article";
+        : "TechArticle";
   const authorList = toPersonList(frontMatter?.author || frontMatter?.authors);
   const maintainerList = toPersonList(frontMatter?.maintainer);
   const contributorList = toPersonList(frontMatter?.contributor);
@@ -147,6 +171,11 @@ export default function DocItem(props) {
   const socialImage = image
     ? toAbsoluteUrl(siteConfig?.url, imageWithBaseUrl)
     : null;
+  // Article schema requires an `image`; fall back to the site-wide default
+  // social card (the same 1200x630 og:image set in docusaurus.config.js) when
+  // a doc has no front-matter image, so every Article carries a valid image.
+  const articleImage =
+    socialImage || "https://keploy.io/images/keploy-hero.png";
   const normalizedMetaKeywords = Array.isArray(metaKeywords)
     ? metaKeywords.join(", ")
     : metaKeywords;
@@ -196,6 +225,7 @@ export default function DocItem(props) {
           "@type": schemaType,
           headline: title,
           description,
+          image: [articleImage],
           ...(modifiedTime ? {dateModified: modifiedTime} : {}),
           // datePublished falls back to the last-modified time so every doc
           // carries a freshness signal even when front matter omits `date`.
@@ -208,13 +238,7 @@ export default function DocItem(props) {
           // (E-E-A-T) instead of dropping the field entirely.
           ...(authorList.length
             ? {author: authorList}
-            : {
-                author: {
-                  "@type": "Organization",
-                  name: "Keploy",
-                  url: "https://keploy.io",
-                },
-              }),
+            : {author: organizationRef}),
           ...(combinedContributors.length
             ? {contributor: combinedContributors}
             : {}),
@@ -225,21 +249,40 @@ export default function DocItem(props) {
             "@type": "WebPage",
             "@id": pageUrl,
           },
-          publisher: {
-            "@type": "Organization",
-            name: "Keploy",
-            logo: {
-              "@type": "ImageObject",
-              url: "https://keploy.io/docs/img/favicon.png",
-            },
-          },
+          isPartOf: websiteRef,
+          publisher: organizationRef,
+        }
+      : null;
+  // Glossary term pages also emit a DefinedTerm belonging to the glossary
+  // hub's DefinedTermSet, so AI engines can cite an individual definition
+  // rather than only the TechArticle wrapping it. Matches a term slug under
+  // /concepts/reference/glossary/ (the hub itself is a React page, so it
+  // never reaches DocItem). Restricted to the current version: 1.0.0 and
+  // 2.0.0 carry `noIndex: true`, and emitting their terms too would put
+  // three competing definitions of the same term in one term set.
+  const isGlossaryTerm =
+    isLatestVersion &&
+    /\/concepts\/reference\/glossary\/[^/]+\/?$/.test(permalink);
+  const definedTermSchema =
+    isGlossaryTerm && pageUrl && title
+      ? {
+          "@context": "https://schema.org",
+          "@type": "DefinedTerm",
+          "@id": `${pageUrl}#term`,
+          name: frontMatter?.sidebar_label || title,
+          description,
+          url: pageUrl,
+          inDefinedTermSet: TERMSET_ID,
         }
       : null;
   const MDXComponent = props.content;
   return (
     <>
       <Head>
-        <title>{title}</title>
+        {/* Suffix differentiates the <title> from the on-page <h1> (which is
+            also `title`), clearing SEMrush "Duplicate content in h1 and title"
+            across all doc pages. */}
+        <title>{`${title} | Keploy Docs`}</title>
         {description && <meta name="description" content={description} />}
         {normalizedMetaKeywords && (
           <meta name="keywords" content={normalizedMetaKeywords} />
@@ -270,6 +313,11 @@ export default function DocItem(props) {
             {JSON.stringify(articleSchema)}
           </script>
         )}
+        {definedTermSchema && (
+          <script type="application/ld+json">
+            {JSON.stringify(definedTermSchema)}
+          </script>
+        )}
         {Array.isArray(frontMatter.head) &&
           frontMatter.head.map((headTag, i) => {
             if (!headTag?.tag) return null;
diff --git a/vale_styles/config/vocabularies/Base/accept.txt b/vale_styles/config/vocabularies/Base/accept.txt
index 898c9ad0ac..f13dfac9a6 100644
--- a/vale_styles/config/vocabularies/Base/accept.txt
+++ b/vale_styles/config/vocabularies/Base/accept.txt
@@ -227,3 +227,14 @@ cbshim
 stdin
 sudo
 [Rr]eplayable
+[Aa]sync
+[Bb]oolean
+[Dd]atastore
+[Gg]zip
+[Jj][Ww][Tt]
+[Mm]ux
+[Pp]risma
+[Qq]uickstarts?
+[Uu]nbuggy
+[Ww]ebhook('?s)?
+_Transform
diff --git a/versioned_docs/version-4.0.0/ci-cd/github.md b/versioned_docs/version-4.0.0/ci-cd/github.md
index 94b2d6f374..839007ebc6 100644
--- a/versioned_docs/version-4.0.0/ci-cd/github.md
+++ b/versioned_docs/version-4.0.0/ci-cd/github.md
@@ -14,6 +14,22 @@ tags:
   - plugin
 ---
 
+import HowTo from '@site/src/components/HowTo';
+
+<HowTo
+name="Set up Keploy API testing in GitHub Actions"
+description="Install Keploy in a GitHub Actions workflow and replay recorded API test suites on every push or pull request."
+totalTime="PT10M"
+tools={["GitHub Actions", "Keploy CLI"]}
+steps={[
+{name: "Check out the commit", text: "Add actions/checkout to your workflow so the job runs against the code under test."},
+{name: "Install Keploy", text: "Download the Keploy binary from the latest GitHub release and move it to /usr/local/bin on the runner."},
+{name: "Run the tests", text: "Add a step that runs keploy test -c \"<command to run your app>\" to replay the recorded suites."},
+{name: "Run cloud replay (optional)", text: "Authenticate with a Keploy API token and trigger cloud replay from the pipeline for hosted test sets."},
+]}
+visible={false}
+/>
+
 import ProductTier from '@site/src/components/ProductTier';
 
 <ProductTier tiers="Open Source, Enterprise" offerings="Self-Hosted, Dedicated" />
@@ -274,3 +290,9 @@ Replace `<NAMESPACE>`, `<DEPLOYMENT>`, `<CLUSTER>`, and `<DELAY>` with your own
 > `KEPLOY_API_KEY: ${{ secrets.KEPLOY_API_KEY }}` pulls the value from GitHub's secret store and makes it available as an environment variable in all subsequent steps.
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [Integrating with GitLab CI](/docs/ci-cd/gitlab/) — the GitLab equivalent.
+- [Integrating with Jenkins](/docs/ci-cd/jenkins/) — the Jenkins equivalent.
+- [API Test Setup for GitHub CI/CD](/docs/running-keploy/api-testing-cicd/) — API-suite CI setup.
diff --git a/versioned_docs/version-4.0.0/ci-cd/gitlab.md b/versioned_docs/version-4.0.0/ci-cd/gitlab.md
index 77433904ab..7dec0ff98b 100644
--- a/versioned_docs/version-4.0.0/ci-cd/gitlab.md
+++ b/versioned_docs/version-4.0.0/ci-cd/gitlab.md
@@ -14,6 +14,22 @@ tags:
   - plugin
 ---
 
+import HowTo from '@site/src/components/HowTo';
+
+<HowTo
+name="Run Keploy API tests in GitLab CI"
+description="Add a GitLab CI job that installs Keploy and replays recorded API test suites in the pipeline."
+totalTime="PT10M"
+tools={["GitLab CI", "Keploy CLI"]}
+steps={[
+{name: "Define a test job", text: "Add a keploy-test-job in the test stage using an ubuntu:22.04 image."},
+{name: "Install dependencies", text: "In before_script install curl, python3, git and kernel headers, then clone your application repo."},
+{name: "Install Keploy", text: "Download the Keploy binary and place it on the PATH inside the job."},
+{name: "Run the tests", text: "Run keploy test -c \"<command to run your app>\" to replay the recorded suites."},
+]}
+visible={false}
+/>
+
 import ProductTier from '@site/src/components/ProductTier';
 
 <ProductTier tiers="Open Source, Enterprise" offerings="Self-Hosted, Dedicated" />
@@ -191,3 +207,9 @@ keploy-cloud-replay:
 Replace `<NAMESPACE>`, `<DEPLOYMENT>`, `<CLUSTER>`, and `<DELAY>` with your own values. Set `<DELAY>` to cover your application's startup time (in seconds).
 
 > Because `KEPLOY_API_KEY` is defined as a masked variable in GitLab, it is already present in the job's environment — no `export` step is needed.
+
+## Related
+
+- [Integrating with GitHub CI](/docs/ci-cd/github/) — the GitHub equivalent.
+- [Integrating with Jenkins](/docs/ci-cd/jenkins/) — the Jenkins equivalent.
+- [API Test Setup for GitHub CI/CD](/docs/running-keploy/api-testing-cicd/) — API-suite CI setup.
diff --git a/versioned_docs/version-4.0.0/ci-cd/jenkins.md b/versioned_docs/version-4.0.0/ci-cd/jenkins.md
index 4ff9bd9968..d7c8928426 100644
--- a/versioned_docs/version-4.0.0/ci-cd/jenkins.md
+++ b/versioned_docs/version-4.0.0/ci-cd/jenkins.md
@@ -14,6 +14,21 @@ tags:
   - plugin
 ---
 
+import HowTo from '@site/src/components/HowTo';
+
+<HowTo
+name="Run Keploy API tests in a Jenkins pipeline"
+description="Configure a Jenkins pipeline to install Keploy and replay recorded API test suites on the agent."
+totalTime="PT10M"
+tools={["Jenkins", "Keploy CLI"]}
+steps={[
+{name: "Grant passwordless sudo", text: "Give the jenkins user NOPASSWD sudo so Keploy can attach its eBPF probes."},
+{name: "Install Keploy", text: "Add an Install Keploy stage that downloads the binary onto the Jenkins agent."},
+{name: "Run the tests", text: "Add a stage that runs keploy test -c \"<command to run your app>\" to replay the recorded suites."},
+]}
+visible={false}
+/>
+
 import ProductTier from '@site/src/components/ProductTier';
 
 <ProductTier tiers="Open Source, Enterprise" offerings="Self-Hosted, Dedicated" />
@@ -228,3 +243,9 @@ pipeline {
 Replace `<NAMESPACE>`, `<DEPLOYMENT>`, `<CLUSTER>`, and `<DELAY>` with your own values. Set `<DELAY>` to cover your application's startup time (in seconds).
 
 > `withCredentials` binds the Jenkins secret to `KEPLOY_API_KEY` only for the duration of that stage — the CLI picks it up automatically.
+
+## Related
+
+- [Integrating with GitHub CI](/docs/ci-cd/github/) — the GitHub equivalent.
+- [Integrating with GitLab CI](/docs/ci-cd/gitlab/) — the GitLab equivalent.
+- [API Test Setup for GitHub CI/CD](/docs/running-keploy/api-testing-cicd/) — API-suite CI setup.
diff --git a/versioned_docs/version-4.0.0/concepts/general-glossary.md b/versioned_docs/version-4.0.0/concepts/general-glossary.md
index 1ec910f96b..dcd5819867 100644
--- a/versioned_docs/version-4.0.0/concepts/general-glossary.md
+++ b/versioned_docs/version-4.0.0/concepts/general-glossary.md
@@ -2,7 +2,7 @@
 id: general-glossary
 title: General Glossary for Users
 sidebar_label: Glossary
-description: This glossary has an explanation of all the terminologies that beginners find difficult to understand at first glance.
+description: Plain-language definitions of common software testing terms — unit, integration, end-to-end, regression, mocks, and stubs — for developers getting started with Keploy.
 tags:
   - explanation
   - reference
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/acceptance-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/acceptance-testing.md
index b50f12bbc4..a7ba09b622 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/acceptance-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/acceptance-testing.md
@@ -69,6 +69,14 @@ To ensure the effectiveness of acceptance testing, consider the following best p
 
 Acceptance testing is a critical step in the software development process, ensuring that the product is ready for deployment and meets the user's needs. By following best practices and involving key stakeholders, organizations can deliver high-quality software that satisfies customer expectations.
 
+## Related Terms
+
+- [End-to-End Testing](/docs/concepts/reference/glossary/end-to-end-testing/) — validates complete user flows before release.
+- [Integration Testing](/docs/concepts/reference/glossary/integration-testing/) — precedes acceptance testing in the cycle.
+- [Behaviour Driven Development](/docs/concepts/reference/glossary/behaviour-driven-development/) — defines acceptance criteria in plain language.
+- [Software Testing Life Cycle](/docs/concepts/reference/glossary/software-testing-life-cycle/) — where acceptance testing fits overall.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQs
 
 ### What is the difference between UAT and Systematic Testing?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/agile-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/agile-testing.md
index ffabafa86b..6705de5625 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/agile-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/agile-testing.md
@@ -35,3 +35,11 @@ Agile unit testing is typically done by developers. Developers write unit tests
 ### Conclusion
 
 Agile unit testing is a valuable tool for improving the quality of software applications. By following the best practices for agile unit testing, developers can help to ensure that their applications are free of defects and meet the needs of their users.
+
+## Related Terms
+
+- [Unit Testing](/docs/concepts/reference/glossary/unit-testing/) — the core practice agile teams apply frequently.
+- [Test Driven Development](/docs/concepts/reference/glossary/test-driven-development/) — a key principle of agile unit testing.
+- [Behaviour Driven Development](/docs/concepts/reference/glossary/behaviour-driven-development/) — another Agile, collaboration-focused method.
+- [Unit Test Automation](/docs/concepts/reference/glossary/unit-test-automation/) — agile tests run automatically in CI.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/ai-test-completion.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/ai-test-completion.md
index f408079698..da13ea51d7 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/ai-test-completion.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/ai-test-completion.md
@@ -59,6 +59,14 @@ By using Keploy’s AI-based testing :
 
 AI Test Completion represents a significant advancement in software testing, leveraging AI and ML to automate and improve the testing process. By automating test case generation, predicting potential scenarios, and enhancing test coverage, AI Test Completion enables teams to achieve higher efficiency, accuracy, and scalability in their testing efforts. However, challenges such as data quality, setup complexity, and integration issues must be addressed to fully leverage the benefits of AI-driven testing. Integrating AI Test Completion into testing workflows can empower teams to deliver robust software solutions that meet user expectations and business requirements effectively.
 
+## Related Terms
+
+- [Unit Test Automation](/docs/concepts/reference/glossary/unit-test-automation/) — AI accelerates automated unit test creation.
+- [Test Data Generation](/docs/concepts/reference/glossary/test-data-generation/) — AI produces inputs and edge cases.
+- [Code Coverage](/docs/concepts/reference/glossary/code-coverage/) — AI-generated tests aim to raise coverage.
+- [QA Automation](/docs/concepts/reference/glossary/qa-automation/) — AI extends broader test automation efforts.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQ
 
 ### How does AI test completion work?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/behaviour-driven-development.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/behaviour-driven-development.md
index aeae9d09b8..5166d44164 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/behaviour-driven-development.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/behaviour-driven-development.md
@@ -174,6 +174,14 @@ Popular BDD tools include:
 
 Behavior Driven Development (BDD) is a collaborative Agile methodology that improves communication among developers, testers, and business stakeholders. By focusing on user stories and scenarios written in plain language, BDD ensures that software meets real user needs and business objectives. With the support of BDD tools like Cucumber, Behave, and SpecFlow, teams can automate tests, integrate them into CI/CD pipelines, and maintain living documentation of system behavior. Although BDD requires commitment and may involve a learning curve, its benefits in improving collaboration, testability, and software quality make it a valuable addition to modern development practices.
 
+## Related Terms
+
+- [Test Driven Development](/docs/concepts/reference/glossary/test-driven-development/) — BDD evolves from the TDD approach.
+- [Cucumber Testing](/docs/concepts/reference/glossary/cucumber-testing/) — popular tool for automating BDD scenarios.
+- [Acceptance Testing](/docs/concepts/reference/glossary/acceptance-testing/) — BDD scenarios double as acceptance criteria.
+- [Agile Unit Testing](/docs/concepts/reference/glossary/agile-unit-testing/) — BDD is an Agile collaboration methodology.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQs about Behavior Driven Development (BDD)
 
 ### 1. What is Behavior Driven Development (BDD)?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/beta-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/beta-testing.md
index d4a3969413..eb57b917d2 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/beta-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/beta-testing.md
@@ -2,7 +2,7 @@
 id: beta-testing
 title: Beta Testing
 sidebar_label: Beta Testing
-description: This glossary has an explanation of all the terminologies that beginners find difficult to understand at first glance.
+description: What is beta testing? Learn its purpose, common types, and where it fits in the software release cycle before a product ships to all users.
 tags:
   - explanation
   - Glossary
@@ -53,35 +53,35 @@ There are many benefits to beta testing, including:
 Bugs and flaws can be found and fixed early in the development process, which saves time and money.
 
 **Example: Dropbox**  
- During the beta phase for a major feature update, Dropbox discovered that certain file sync issues only occurred under specific conditions, which the internal testing had not captured. This early detection allowed them to resolve these issues, saving time and resources that would have been spent addressing them post-launch.
+During the beta phase for a major feature update, Dropbox discovered that certain file sync issues only occurred under specific conditions, which the internal testing had not captured. This early detection allowed them to resolve these issues, saving time and resources that would have been spent addressing them post-launch.
 
 ### **Improved user experience:**
 
 Beta testers can provide feedback on how to improve the user experience.
 
 **Example: Google Chrome**  
- Google regularly uses beta testing to refine the user interface and functionality of Chrome. During a beta release of a new tab layout, users provided feedback about the accessibility of certain features. Based on this feedback, Google adjusted the layout to enhance usability, ensuring that the final version was more user-friendly.
+Google regularly uses beta testing to refine the user interface and functionality of Chrome. During a beta release of a new tab layout, users provided feedback about the accessibility of certain features. Based on this feedback, Google adjusted the layout to enhance usability, ensuring that the final version was more user-friendly.
 
 ### **Gathering feedback:**
 
 Beta testers can provide feedback on the product's features, functionality, and performance.
 
 **Example: Instagram**  
- When Instagram introduced a new Stories feature, they conducted beta testing with a selected group of users. Feedback regarding the feature's visibility and ease of use led to several adjustments, such as changing the placement of the Stories bar. This feedback was critical in ensuring the feature's success upon full release.
+When Instagram introduced a new Stories feature, they conducted beta testing with a selected group of users. Feedback regarding the feature's visibility and ease of use led to several adjustments, such as changing the placement of the Stories bar. This feedback was critical in ensuring the feature's success upon full release.
 
 ### **Promoting user acceptance:**
 
 Beta testing can help to promote user acceptance of the product by getting the word out about it.
 
 **Example: Tesla**  
- Tesla often invites existing customers to participate in beta testing for new software updates. By allowing loyal customers to be part of the testing process, Tesla promotes user acceptance and loyalty, as these users feel invested in the development of new features.
+Tesla often invites existing customers to participate in beta testing for new software updates. By allowing loyal customers to be part of the testing process, Tesla promotes user acceptance and loyalty, as these users feel invested in the development of new features.
 
 ### **Boosting software quality:**
 
 Beta testing can help to boost the quality of the software by ensuring that it is as stable, safe, and functional as possible.
 
 **Example: Spotify**  
- Spotify uses beta testing to explore new features like collaborative playlists. By inviting a small group of users to test this feature and providing a structured feedback mechanism, Spotify was able to gauge interest and refine the feature before rolling it out to the entire user base.
+Spotify uses beta testing to explore new features like collaborative playlists. By inviting a small group of users to test this feature and providing a structured feedback mechanism, Spotify was able to gauge interest and refine the feature before rolling it out to the entire user base.
 
 ## How to Beta Test
 
@@ -97,3 +97,11 @@ Here are some tips for beta testing:
 ## Conclusion
 
 Beta testing is an important part of the software development process. By beta testing a product, developers can get valuable feedback from real users and improve the quality of the product before it is released to the general public.
+
+## Related Terms
+
+- [Acceptance Testing](/docs/concepts/reference/glossary/acceptance-testing/) — validates user needs just before release.
+- [End-to-End Testing](/docs/concepts/reference/glossary/end-to-end-testing/) — checks full flows ahead of beta.
+- [Manual Testing](/docs/concepts/reference/glossary/manual-testing/) — beta relies on real users testing manually.
+- [Software Testing Life Cycle](/docs/concepts/reference/glossary/software-testing-life-cycle/) — where beta testing fits before launch.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/black-box-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/black-box-testing.md
index cf0c8c73d4..7fac50be70 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/black-box-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/black-box-testing.md
@@ -149,6 +149,14 @@ testing with Keploy:
 
 Black-box testing is a valuable tool for ensuring the quality of software. It can be used to find a wide range of defects, and it can be performed by testers with a variety of skill levels. The best testing strategy for a particular software project will depend on the specific needs of the project. In some cases, black-box testing may be sufficient. In other cases, white-box testing may be necessary to find all the defects in the software.
 
+## Related Terms
+
+- [White Box Testing](/docs/concepts/reference/glossary/white-box-testing/) — the opposite, code-aware testing approach.
+- [Grey Box Testing](/docs/concepts/reference/glossary/gray-box-testing/) — combines black-box and white-box techniques.
+- [Functional Testing](/docs/concepts/reference/glossary/functional-testing/) — verifies behavior without internal knowledge.
+- [Regression Testing](/docs/concepts/reference/glossary/regression-testing/) — often done via black-box test cases.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQ
 
 ### What is black-box testing?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/code-coverage.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/code-coverage.md
index 63d9e66412..57adde730c 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/code-coverage.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/code-coverage.md
@@ -41,7 +41,7 @@ It's analysis provides several benefits:
 
 Keploy has native integrations with your unit-testing libraries like go-test, jUnit, jest, pyTest. Keploy gives combined test-coverage and can also be integrated in existing CI pipelines easily within go-test, jUnit, jest, pyTest workflows.
 
-<img src="https://keploy.io/docs/gif/replay-tc.gif?raw=true"/>
+<img src="https://keploy.io/docs/gif/replay-tc.gif?raw=true" alt="Keploy replaying recorded test cases to measure code coverage"/>
 
 By generating additional tests that exercise different parts of your codebase, you can increase the percentage of code that is covered by your tests. For example, in case of NodeJS application you can use Jest. Jest provides a built-in code coverage tool that can help you measure the effectiveness of your tests and identify areas of the code that need additional testing. By adding Keploy SDK with Jest, you can easily generate test cases and increase your code coverage. Let's create a `Keploy.test.js`
 
@@ -90,3 +90,10 @@ Now when let's the test cases with Jest, you can see the code coverage report ge
 ```bash
 npm test
 ```
+
+## Related Terms
+
+- [Unit Testing](/docs/concepts/reference/glossary/unit-testing/) — the tests whose reach coverage measures.
+- [Unit Test Automation](/docs/concepts/reference/glossary/unit-test-automation/) — automating those tests to raise coverage.
+- [Test-Driven Development](/docs/concepts/reference/glossary/test-driven-development/) — writing tests first tends to lift coverage.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/component-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/component-testing.md
index abd44e5c9c..1baa583eff 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/component-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/component-testing.md
@@ -239,6 +239,14 @@ Component testing is pretty much testing on a single unit of your software. By t
 
 Using the Keploy tool makes it easier to do component testing. Keploy will create tests and mocks that derive from the ways real users use your app automatically, allowing you to spend less time writing tests and more time building features without worry. In summary, good component testing and effective tools such as Keploy can help you deliver better software, faster.
 
+## Related Terms
+
+- [Unit Testing](/docs/concepts/reference/glossary/unit-testing/) — tests the smallest isolated pieces of code.
+- [Integration Testing](/docs/concepts/reference/glossary/integration-testing/) — follows component testing to check interactions.
+- [Stubs](/docs/concepts/reference/glossary/stubs/) — simulate dependencies during component tests.
+- [Mocks](/docs/concepts/reference/glossary/mocks/) — stand in for external services in isolation.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQs
 
 ### 1. Is component testing the same as unit testing?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/cucumber-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/cucumber-testing.md
index 715fead287..1ccf729045 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/cucumber-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/cucumber-testing.md
@@ -104,6 +104,14 @@ While Cucumber is widely used for BDD and Gherkin-based testing, several alterna
 
 Cucumber testing revolutionizes software testing by enabling teams to collaborate effectively through executable specifications written in Gherkin. By bridging communication gaps between stakeholders and automating tests with reusable step definitions, Cucumber enhances the reliability, maintainability, and scalability of software applications. Incorporating Cucumber into BDD practices empowers teams to deliver high-quality software that meets business requirements and user expectations seamlessly.
 
+## Related Terms
+
+- [Behaviour Driven Development](/docs/concepts/reference/glossary/behaviour-driven-development/) — the methodology Cucumber implements.
+- [Acceptance Testing](/docs/concepts/reference/glossary/acceptance-testing/) — Cucumber writes human-readable acceptance tests.
+- [Data Driven Testing](/docs/concepts/reference/glossary/data-driven-testing/) — Cucumber supports it via examples tables.
+- [Test Driven Development](/docs/concepts/reference/glossary/test-driven-development/) — a related test-first development practice.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQ about Cucumber Testing
 
 ### 1. **What is Cucumber testing used for?**
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/data-driven-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/data-driven-testing.md
index 3ab3b4e1fc..4293bf6fa9 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/data-driven-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/data-driven-testing.md
@@ -81,6 +81,14 @@ Begin with a simple pilot project to demonstrate value. Choose a critical user w
 
 Focus on high-value scenarios where multiple data combinations are essential. Login functionality, payment processing, and form validations are excellent starting points.
 
+## Related Terms
+
+- [Test Data Generation](/docs/concepts/reference/glossary/test-data-generation/) — supplies the data sets these tests consume.
+- [QA Automation](/docs/concepts/reference/glossary/qa-automation/) — data-driven tests are typically automated.
+- [Regression Testing](/docs/concepts/reference/glossary/regression-testing/) — reruns many data sets to catch regressions.
+- [Cucumber Testing](/docs/concepts/reference/glossary/cucumber-testing/) — supports data-driven scenarios via examples tables.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## Frequently Asked Questions
 
 ### Q: How much effort does it take to implement data-driven testing?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/defect-management.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/defect-management.md
index 11d969f0dd..69b0f3b58b 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/defect-management.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/defect-management.md
@@ -254,6 +254,14 @@ With proper practices and tools, shipping **high-quality, reliable applications*
 
 Let's continue to pursue excellence in software quality!
 
+## Related Terms
+
+- [Software Testing Life Cycle](/docs/concepts/reference/glossary/software-testing-life-cycle/) — defect management spans the whole cycle.
+- [Regression Testing](/docs/concepts/reference/glossary/regression-testing/) — verifies fixed defects stay fixed.
+- [Error Guessing](/docs/concepts/reference/glossary/error-guessing/) — a technique for uncovering defects.
+- [Acceptance Testing](/docs/concepts/reference/glossary/acceptance-testing/) — catches defects before release.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQs
 
 ### What is a defect in software testing?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/end-to-end-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/end-to-end-testing.md
index 9f8d8b26ed..6de6986f04 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/end-to-end-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/end-to-end-testing.md
@@ -2,7 +2,7 @@
 id: end-to-end-testing
 title: Creating end to end tests with Keploy
 sidebar_label: End To End Testing
-description: This glossary has an explanation of all the terminologies that beginners find difficult to understand at first glance.
+description: What is end-to-end testing, and how to create E2E tests with Keploy by recording and replaying real API traffic across your services.
 tags:
   - explanation
   - Glossary
@@ -45,7 +45,7 @@ Despite the challenges, E2E testing is an important part of the software develop
 
 Keploy generate E2E API tests with built-in-mocks or stubs by recording your application network calls making your testing process not only faster than unit tests but also incredibly efficient.
 
-<img src="https://keploy.io/docs/gif/record-tc.gif"/>
+<img src="https://keploy.io/docs/gif/record-tc.gif" alt="Keploy recording end-to-end API test cases from live application traffic"/>
 
 ### How Keploy works?
 
@@ -65,6 +65,14 @@ Since you don't require to setup any test environment, Keploy can be used in any
 
 End-to-end (E2E) testing is a important component of the software development process, as it ensures that applications function correctly and meet user expectations across all integrated components. While E2E testing presents challenges, such as time consumption and automation complexity, tools like Keploy offer powerful solutions to streamline the process. By capturing and replaying real-world API interactions, Keploy enhances the efficiency and effectiveness of end-to-end testing, contributing to the delivery of high-quality software.
 
+## Related Terms
+
+- [Integration Testing](/docs/concepts/reference/glossary/integration-testing/) — checks module interactions before E2E.
+- [Acceptance Testing](/docs/concepts/reference/glossary/acceptance-testing/) — validates the finished product for users.
+- [Mocks](/docs/concepts/reference/glossary/mocks/) — Keploy uses mocks to replay E2E dependencies.
+- [Regression Testing](/docs/concepts/reference/glossary/regression-testing/) — reruns E2E flows to catch regressions.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQs
 
 ### What is End-to-End Testing?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/error-guessing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/error-guessing.md
index db4a8b2c26..b01341e0d0 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/error-guessing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/error-guessing.md
@@ -2,7 +2,7 @@
 id: error-guessing
 title: Error Guessing
 sidebar_label: Error Guessing
-description: This glossary has an explanation of all the terminologies that beginners find difficult to understand at first glance.
+description: What is error guessing in software testing? An experience-based technique for uncovering defects that formal test cases miss, with practical examples.
 tags:
   - explanation
   - glossary
@@ -38,3 +38,10 @@ Error guessing is an intuitive and experience-based software testing technique t
 ## Conclusion
 
 While error guessing is not systematic like other testing methods, it can be highly effective when combined with more structured approaches. It allows testers to explore edge cases and unusual scenarios that might be overlooked by conventional test cases. However, the success of error guessing largely depends on the tester's expertise and familiarity with the system. As such, it's often used as a complementary technique rather than a standalone method in comprehensive testing strategies.
+
+## Related Terms
+
+- [Negative Testing](/docs/concepts/reference/glossary/negative-testing/) — deliberately probing invalid inputs, a close cousin.
+- [Black-Box Testing](/docs/concepts/reference/glossary/black-box-testing/) — experience-based testing without seeing the code.
+- [Manual Testing](/docs/concepts/reference/glossary/manual-testing/) — where error guessing is most often applied.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/functional-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/functional-testing.md
index e27c525913..a3c5d1ac7e 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/functional-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/functional-testing.md
@@ -211,6 +211,14 @@ Integrate functional tests into your Continuous Integration (CI) pipelines. This
 
 Despite the challenges, functional testing is an important part of the software testing process. By following good functional testing practices, you can help to ensure that the software system meets the specified requirements and meets the intended business needs.
 
+## Related Terms
+
+- [Black Box Testing](/docs/concepts/reference/glossary/black-box-testing/) — functional testing is largely black-box.
+- [Integration Testing](/docs/concepts/reference/glossary/integration-testing/) — a functional testing type for module interactions.
+- [Regression Testing](/docs/concepts/reference/glossary/regression-testing/) — re-verifies functionality after changes.
+- [Unit Testing](/docs/concepts/reference/glossary/unit-testing/) — the most granular functional test level.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## Frequently Asked Questions
 
 ### 1. What is Functional Testing?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/grey-box-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/grey-box-testing.md
index 0851df2024..3fb9b5f509 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/grey-box-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/grey-box-testing.md
@@ -97,6 +97,14 @@ Some commonly used tools for gray box testing include:
 
 Gray box testing is a versatile and effective software testing approach that blends the principles of black box and white box testing. It enables testers to design test cases based on both functional specifications and partial internal knowledge of the application, leading to improved test coverage and defect identification. By leveraging techniques such as matrix testing, regression testing, pattern testing, and more, gray box testing strikes a balance between thoroughness and practicality. This approach is particularly beneficial in identifying security vulnerabilities, ensuring robust error handling, and enhancing overall software quality. Despite its challenges, including the need for intermediate skill levels and potentially higher complexity, the benefits of gray box testing make it a valuable component of a comprehensive testing strategy.
 
+## Related Terms
+
+- [Black Box Testing](/docs/concepts/reference/glossary/black-box-testing/) — tests with no internal knowledge.
+- [White Box Testing](/docs/concepts/reference/glossary/white-box-testing/) — tests with full code knowledge.
+- [Functional Testing](/docs/concepts/reference/glossary/functional-testing/) — gray box blends functional and structural views.
+- [Integration Testing](/docs/concepts/reference/glossary/integration-testing/) — gray box suits integrating complex systems.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQ's
 
 ### What is gray box testing?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/grpc.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/grpc.md
index 8f246258f2..9eb5240073 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/grpc.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/grpc.md
@@ -130,6 +130,14 @@ Performance optimizations continue to improve efficiency, with new compression a
 
 The growing ecosystem of tools and libraries makes gRPC increasingly accessible to developers. IDE integrations, debugging tools, and testing frameworks reduce the learning curve and improve developer productivity.
 
+## Related Terms
+
+- [Microservice Testing](/docs/concepts/reference/glossary/microservice-testing/) — gRPC powers microservice communication.
+- [Integration Testing](/docs/concepts/reference/glossary/integration-testing/) — validates gRPC service interactions.
+- [Mocks](/docs/concepts/reference/glossary/mocks/) — stand in for gRPC dependencies in tests.
+- [Idempotency](/docs/concepts/reference/glossary/idempotency/) — key to reliable RPC retries in distributed systems.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## Frequently Asked Questions
 
 ### What's the main difference between gRPC and REST?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/idempotency.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/idempotency.md
index 9419423589..84b60f0310 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/idempotency.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/idempotency.md
@@ -78,16 +78,16 @@ While **idempotent** methods guarantee the same outcome when repeated, **safe**
 ### How Keploy Ensures Idempotency
 
 - **Automated Test Cases for Idempotent Operations:**  
-   Keploy lets you create tests that simulate repeated API requests under various conditions—such as network failures, timeouts, or duplicate submissions—to confirm that operations like **PUT**, **DELETE**, and **GET** remain consistent.
+  Keploy lets you create tests that simulate repeated API requests under various conditions—such as network failures, timeouts, or duplicate submissions—to confirm that operations like **PUT**, **DELETE**, and **GET** remain consistent.
 
 - **Simulating Failures and Retrying Requests:**  
-   By simulating transient network issues or service unavailability, Keploy verifies that retry logic does not cause multiple, unintended modifications to the system.
+  By simulating transient network issues or service unavailability, Keploy verifies that retry logic does not cause multiple, unintended modifications to the system.
 
 - **Request and Response Pairing:**  
-   Keploy tracks request-response pairs to ensure that each repeated request produces an identical outcome, validating the correct handling of idempotent tokens (like UUIDs).
+  Keploy tracks request-response pairs to ensure that each repeated request produces an identical outcome, validating the correct handling of idempotent tokens (like UUIDs).
 
 - **Advanced Mocking and Stubbing:**  
-   With Keploy’s capabilities, you can simulate external service interactions, allowing you to test the idempotency of your APIs in isolation and under specific failure conditions.
+  With Keploy’s capabilities, you can simulate external service interactions, allowing you to test the idempotency of your APIs in isolation and under specific failure conditions.
 
 ### Example Use Case
 
@@ -101,6 +101,14 @@ Imagine an API that updates a user's profile using the **PUT** method. Automated
 
 Idempotency is a foundational principle in designing reliable, scalable RESTful APIs. By ensuring that operations can be retried safely without adverse effects, idempotent APIs contribute to system consistency, error recovery, and overall performance. Implementing idempotent methods involves careful design of HTTP methods, data handling, and error recovery mechanisms. Tools like Keploy simplify this process by providing robust testing frameworks that simulate real-world conditions, ensuring that your APIs maintain their idempotency under all circumstances.
 
+## Related Terms
+
+- [Reliability Testing](/docs/concepts/reference/glossary/reliability-testing/) — idempotency underpins fault-tolerant systems.
+- [Microservice Testing](/docs/concepts/reference/glossary/microservice-testing/) — idempotency matters across service retries.
+- [Integration Testing](/docs/concepts/reference/glossary/integration-testing/) — verifies idempotent behavior end to end.
+- [Mocks](/docs/concepts/reference/glossary/mocks/) — simulate failures to test safe retries.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQ
 
 ### What does it mean for an HTTP method to be idempotent?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/integration-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/integration-testing.md
index 3ab2b675f9..dc429244f9 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/integration-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/integration-testing.md
@@ -121,6 +121,14 @@ Furthermore, Keploy's native integration seamlessly integrates with development
 
 In conclusion, Keploy empowers development teams to overcome the challenges of integration testing effectively, enabling them to deliver high-quality software with confidence and efficiency.
 
+## Related Terms
+
+- [Unit Testing](/docs/concepts/reference/glossary/unit-testing/) — precedes integration testing in the pyramid.
+- [End-to-End Testing](/docs/concepts/reference/glossary/end-to-end-testing/) — follows integration testing across the full system.
+- [Component Testing](/docs/concepts/reference/glossary/component-testing/) — tests parts before they are integrated.
+- [Stubs](/docs/concepts/reference/glossary/stubs/) — simulate not-yet-ready modules during integration.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ### FAQs
 
 #### 1. What is the primary goal of integration testing?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/junit.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/junit.md
index 4b0a2cf5a9..96b0feb179 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/junit.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/junit.md
@@ -116,6 +116,14 @@ Finding the right balance of test coverage requires experience and judgment. Foc
 
 Tests that are difficult to maintain eventually become liabilities rather than assets. Regular refactoring of test code, just like production code, ensures tests remain valuable throughout the application lifecycle.
 
+## Related Terms
+
+- [Unit Testing](/docs/concepts/reference/glossary/unit-testing/) — JUnit is the standard Java unit-testing framework.
+- [Test Driven Development](/docs/concepts/reference/glossary/test-driven-development/) — JUnit enables fast red-green-refactor cycles.
+- [Code Coverage](/docs/concepts/reference/glossary/code-coverage/) — pair JUnit with JaCoCo to measure coverage.
+- [Unit Test Automation](/docs/concepts/reference/glossary/unit-test-automation/) — JUnit runs automatically in CI pipelines.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## Frequently Asked Questions
 
 ### Q: What's the difference between JUnit 4 and JUnit 5?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/load-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/load-testing.md
index 8266292cc9..40eee416b8 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/load-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/load-testing.md
@@ -151,6 +151,13 @@ Load testing is important in the SDLC, since it ensures applications can handle
 
 As the load testing market continues to expand, organizations that invest in robust load testing practices will be better positioned to deliver exceptional user experiences and maintain a competitive edge.
 
+## Related Terms
+
+- [Performance Testing](/docs/concepts/reference/glossary/performance-testing/) — load testing is a core type of performance testing.
+- [Reliability Testing](/docs/concepts/reference/glossary/reliability-testing/) — validates stability under sustained load.
+- [Observability Testing](/docs/concepts/reference/glossary/observability-testing/) — monitor system behavior during load tests.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQs
 
 ### What is load testing in software development?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/manual-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/manual-testing.md
index 8cd9ba5369..10f8bd5f03 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/manual-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/manual-testing.md
@@ -57,3 +57,10 @@ Automating manual testing with Keploy can provide several benefits. Such as:
 - Improved Quality: By catching issues early and ensuring that changes do not break existing functionality, automation testing can help improve the overall quality of the software.
 
 Overall, by automating testing processes with Keploy, you can improve testing efficiency, increase test coverage, and accelerate the delivery of high-quality software products while reducing manual effort and costs.
+
+## Related Terms
+
+- [QA Automation](/docs/concepts/reference/glossary/qa-automation/) — automate repetitive manual test execution.
+- [Regression Testing](/docs/concepts/reference/glossary/regression-testing/) — re-run manual test cases after code changes.
+- [Unit Testing](/docs/concepts/reference/glossary/unit-testing/) — a foundational automated alternative to manual checks.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/microservice-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/microservice-testing.md
index 96e839c322..21e0bff0cc 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/microservice-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/microservice-testing.md
@@ -41,7 +41,7 @@ Microservice testing is the process of validating individual components of a mic
 ## Overcoming Challenges with Keploy
 
 Keploy is an innovative testing tool designed to address many of the challenges associated with microservices testing. Here's how it helps:
-<img src="https://keploy.io/docs/gif/record-replay.gif?raw=true"/>
+<img src="https://keploy.io/docs/gif/record-replay.gif?raw=true" alt="Keploy recording and replaying API calls across microservices"/>
 <br/>
 
 - **Automated Test Case Generation**: Keploy can generate test cases by recording your application's network calls. This automation significantly reduces the time and effort required to create comprehensive test suites.
@@ -52,3 +52,10 @@ Keploy is an innovative testing tool designed to address many of the challenges
 - **Performance Testing**: The recorded interactions can be used to simulate realistic load scenarios, aiding in performance testing of microservices.
 
 By leveraging Keploy's capabilities, development teams can overcome many of the traditional challenges associated with microservices testing, leading to more robust and reliable distributed systems.
+
+## Related Terms
+
+- [Integration Testing](/docs/concepts/reference/glossary/integration-testing/) — verify how services interact together.
+- [End-to-End Testing](/docs/concepts/reference/glossary/end-to-end-testing/) — validate complete flows across microservices.
+- [Mocks](/docs/concepts/reference/glossary/mocks/) — simulate service dependencies during isolated tests.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/mocks.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/mocks.md
index ae6136fb3a..b2c8086660 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/mocks.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/mocks.md
@@ -36,6 +36,13 @@ Data mocks refer to the synthetic data that mimics real-world datasets, which is
 
 Keploy can generate dependency mocks in addition to the testcases by recording your application network calls making your testing process not only faster than unit tests but also incredibly efficient.
 
-<img src="https://keploy.io/docs/gif/record-replay.gif?raw=true"/>
+<img src="https://keploy.io/docs/gif/record-replay.gif?raw=true" alt="Keploy recording API calls and replaying them using generated mocks"/>
 
 Since these data mocks are generated based on the real-time capturing of API calls from your application, they will be from real-world scenarios. This can help to ensure that the data mocks are accurate and that it represents the real data as closely as possible. As well as, it makes the data maintenance process easier by providing a same environment for testing. This can help to identify the source of bugs more easily.
+
+## Related Terms
+
+- [Stubs](/docs/concepts/reference/glossary/stubs/) — a simpler stand-in for dependencies, often confused with mocks.
+- [Unit Testing](/docs/concepts/reference/glossary/unit-testing/) — mocks isolate the unit under test.
+- [Integration Testing](/docs/concepts/reference/glossary/integration-testing/) — mock external systems between components.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/negative-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/negative-testing.md
index d8653499d9..a4115c3519 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/negative-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/negative-testing.md
@@ -107,6 +107,13 @@ The evolution of testing tools like Keploy demonstrates the growing sophisticati
 
 Success in negative testing requires a combination of systematic methodology, appropriate tooling, and continuous adaptation to emerging challenges. Organizations that invest in comprehensive negative testing approaches will be better positioned to deliver reliable, secure, and user-friendly software systems that can withstand the challenges of real-world deployment.
 
+## Related Terms
+
+- [Error Guessing](/docs/concepts/reference/glossary/error-guessing/) — experience-based way to find failure inputs.
+- [Functional Testing](/docs/concepts/reference/glossary/functional-testing/) — the positive counterpart to negative testing.
+- [Black Box Testing](/docs/concepts/reference/glossary/black-box-testing/) — test invalid inputs without internal knowledge.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## Frequently Asked Questions
 
 ### 1. What is the primary difference between positive and negative testing?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/observability-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/observability-testing.md
index 9d00f02b82..f5c77b3d1f 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/observability-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/observability-testing.md
@@ -116,6 +116,13 @@ Observability testing continues to evolve as systems become more complex and mon
 
 **Security Observability**: Security monitoring becomes increasingly important as systems face evolving threats. Observability testing must validate that security monitoring capabilities provide comprehensive threat detection and response capabilities.
 
+## Related Terms
+
+- [Reliability Testing](/docs/concepts/reference/glossary/reliability-testing/) — observability underpins reliability assessment.
+- [Microservice Testing](/docs/concepts/reference/glossary/microservice-testing/) — traces span distributed microservices.
+- [Performance Testing](/docs/concepts/reference/glossary/performance-testing/) — metrics reveal performance under load.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## Frequently Asked Questions
 
 ### Q: What's the difference between traditional monitoring and observability testing?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/performance-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/performance-testing.md
index 566eac1b69..1f08547925 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/performance-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/performance-testing.md
@@ -106,3 +106,10 @@ Using Keploy for performance testing offers several benefits:
 - **Early Detection**: Identifies performance issues early in the development cycle, reducing the risk of critical problems in production.
 
 By leveraging Keploy, teams can streamline their performance testing process, enhance test accuracy, and ensure that their software delivers optimal performance in real-world conditions.
+
+## Related Terms
+
+- [Load Testing](/docs/concepts/reference/glossary/load-testing/) — a key type of performance testing under expected load.
+- [Reliability Testing](/docs/concepts/reference/glossary/reliability-testing/) — extends performance checks to long-term stability.
+- [Observability Testing](/docs/concepts/reference/glossary/observability-testing/) — capture metrics during performance runs.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/qa-automation.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/qa-automation.md
index 679d2d974d..201187ea3a 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/qa-automation.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/qa-automation.md
@@ -150,6 +150,14 @@ The future of QA automation looks promising with advancements in **AI and machin
 
 QA automation is essential for modern software development. It enables **faster releases, higher quality, and better collaboration between teams.** By understanding the key components, types of testing, and best practices, organizations can effectively implement QA automation and reap its many benefits. As the field continues to evolve, staying updated with the latest tools and trends will be crucial for maintaining a competitive edge in software quality assurance.
 
+## Related Terms
+
+- [Regression Testing](/docs/concepts/reference/glossary/regression-testing/) — a prime candidate for automation.
+- [Unit Test Automation](/docs/concepts/reference/glossary/unit-test-automation/) — automate tests at the unit level.
+- [Manual Testing](/docs/concepts/reference/glossary/manual-testing/) — the approach QA automation replaces or complements.
+- [Performance Testing](/docs/concepts/reference/glossary/performance-testing/) — automate load and speed checks.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQs
 
 ### What is QA Automation?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/regression-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/regression-testing.md
index da79717eae..8c5e4d15b8 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/regression-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/regression-testing.md
@@ -74,6 +74,13 @@ On the other hand, automated regression testing provides consistent, repeatable,
 
 Ultimately, the decision should consider the specific needs of the project, balancing the benefits of human judgment in manual testing with the efficiency and scalability offered by automation. Many teams opt for a hybrid approach, combining both methods to maximize test coverage and effectiveness throughout the software development lifecycle.
 
+## Related Terms
+
+- [QA Automation](/docs/concepts/reference/glossary/qa-automation/) — automate regression suites for faster releases.
+- [Unit Testing](/docs/concepts/reference/glossary/unit-testing/) — unit tests catch regressions early.
+- [Visual Regression Testing](/docs/concepts/reference/glossary/visual-regression-testing/) — detect unintended UI changes.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## Frequently Asked Questions
 
 ### What is regression testing and why is it important?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/reliability-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/reliability-testing.md
index 27b6d37a8c..1ba15ff02a 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/reliability-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/reliability-testing.md
@@ -117,6 +117,13 @@ Organizations that invest in robust reliability testing practices will be better
 
 ---
 
+## Related Terms
+
+- [Load Testing](/docs/concepts/reference/glossary/load-testing/) — assess stability under expected load.
+- [Performance Testing](/docs/concepts/reference/glossary/performance-testing/) — reliability builds on performance results.
+- [Observability Testing](/docs/concepts/reference/glossary/observability-testing/) — monitor failures and recovery over time.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## Frequently Asked Questions
 
 ### 1. What is the difference between reliability testing and performance testing?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/software-testing-life-cycle.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/software-testing-life-cycle.md
index 6341652382..6ee52e7a7c 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/software-testing-life-cycle.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/software-testing-life-cycle.md
@@ -83,6 +83,13 @@ Software Testing Life Cycle (STLC) is integral to ensuring software quality and
 
 Incorporating STLC best practices and leveraging advanced testing tools empower organizations to achieve higher quality standards, enhance customer satisfaction, and maintain competitive advantage in the dynamic software landscape.
 
+## Related Terms
+
+- [Regression Testing](/docs/concepts/reference/glossary/regression-testing/) — a key phase within the STLC.
+- [Defect Management](/docs/concepts/reference/glossary/defect-management/) — track defects reported during testing.
+- [QA Automation](/docs/concepts/reference/glossary/qa-automation/) — automate STLC test execution phases.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQs
 
 ### 1. **What are the key phases of the Software Testing Life Cycle?**
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/stubs.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/stubs.md
index 29c3b5fda2..2690d7c2f1 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/stubs.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/stubs.md
@@ -50,6 +50,13 @@ Overall, stubs are a valuable tool for software development and testing. They ca
 
 Keploy can generate dependency stubs in addition to the testcases by recording your application network calls making your testing process not only faster than unit tests but also incredibly efficient.
 
-<img src="https://keploy.io/docs/gif/record-replay.gif?raw=true"/>
+<img src="https://keploy.io/docs/gif/record-replay.gif?raw=true" alt="Keploy recording API calls and replaying them using generated stubs"/>
 
 Since the data stubs are generated based on the real-time capturing of API calls from your application, they will be from real-world scenarios. This can help to ensure that the mock data is accurate and that it represents the real data as closely as possible. As well as, it makes the data maintenance process easier by providing a same environment for testing. This can help to identify the source of bugs more easily.
+
+## Related Terms
+
+- [Mocks](/docs/concepts/reference/glossary/mocks/) — the closely related test double often paired with stubs.
+- [Unit Testing](/docs/concepts/reference/glossary/unit-testing/) — stubs isolate the unit under test.
+- [Integration Testing](/docs/concepts/reference/glossary/integration-testing/) — stub external systems between modules.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/test-data-generation.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/test-data-generation.md
index c7fc7db16d..07be4eea3a 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/test-data-generation.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/test-data-generation.md
@@ -53,3 +53,10 @@ Keploy offers a comprehensive solution for test data generation, addressing the
 In conclusion, effective test data generation is essential for ensuring the reliability, accuracy, and performance of software applications. By leveraging automated solutions like Keploy, software development teams can overcome the challenges associated with manual test data management and streamline their testing processes.
 
 With Keploy's dynamic test data generation capabilities, teams can accelerate testing cycles, enhance testing coverage, and ultimately deliver high-quality software products to market faster and more efficiently. By embracing modern test data generation practices facilitated by tools like Keploy, organizations can stay ahead in today's competitive landscape and meet the ever-growing demands for software reliability and innovation.
+
+## Related Terms
+
+- [Data-Driven Testing](/docs/concepts/reference/glossary/data-driven-testing/) — feed generated data sets into tests.
+- [Mocks](/docs/concepts/reference/glossary/mocks/) — synthetic data mocks stand in for real sources.
+- [Test-Driven Development](/docs/concepts/reference/glossary/test-driven-development/) — generated data supports test-first workflows.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/test-driven-development.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/test-driven-development.md
index 416c2e2937..8504805040 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/test-driven-development.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/test-driven-development.md
@@ -170,6 +170,14 @@ Implementing TDD comes with challenges that teams should be aware of:
 
 Test Driven Development (TDD) is a powerful methodology that fosters robust, maintainable, and reliable code. By writing tests before code, developers are forced to clarify requirements, catch bugs early, and design modular components that are easier to maintain and scale. While TDD has its challenges, its benefits in enhancing code quality, enabling safe refactoring, and integrating seamlessly with CI/CD pipelines (especially when paired with tools like Keploy) make it a valuable approach in modern software development.
 
+## Related Terms
+
+- [Unit Testing](/docs/concepts/reference/glossary/unit-testing/) — TDD is driven by writing unit tests first.
+- [Behaviour Driven Development](/docs/concepts/reference/glossary/behaviour-driven-development/) — a collaboration-focused alternative to TDD.
+- [Code Coverage](/docs/concepts/reference/glossary/code-coverage/) — measure how much code your tests exercise.
+- [Mocks](/docs/concepts/reference/glossary/mocks/) — isolate units while writing tests first.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQ
 
 ### What is Test Driven Development (TDD)?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/unit-test-automation.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/unit-test-automation.md
index e90cff4cf9..c03c503c83 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/unit-test-automation.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/unit-test-automation.md
@@ -145,6 +145,14 @@ TestNG is another testing framework for Java, designed to cover a broader range
 
 Unit test automation is a fundamental practice in modern software development. By implementing effective unit testing strategies and utilizing the right tools, developers can improve code quality, reduce bugs, and enhance the overall efficiency of their development processes. Whether you're a seasoned developer or new to coding, investing in unit test automation will pay dividends in the long run.
 
+## Related Terms
+
+- [Unit Testing](/docs/concepts/reference/glossary/unit-testing/) — the practice being automated here.
+- [Test-Driven Development](/docs/concepts/reference/glossary/test-driven-development/) — write automated unit tests first.
+- [Mocks](/docs/concepts/reference/glossary/mocks/) — isolate units during automated tests.
+- [JUnit](/docs/concepts/reference/glossary/junit/) — a popular unit test automation framework.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## Frequently Asked Questions (FAQ)
 
 ### What is the difference between unit testing and integration testing?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/unit-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/unit-testing.md
index 2da1aa7a66..b7e330b034 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/unit-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/unit-testing.md
@@ -82,6 +82,14 @@ Keploy enhances the unit testing process by providing automated test case genera
 
 By incorporating Keploy into their testing workflows, developers can detect errors early in the development process, ensure comprehensive test coverage, and collaborate effectively with their teams to drive continuous improvement in testing practices. With its innovative features and seamless integration capabilities, Keploy empowers developers to write better code and deliver high-quality software products with confidence.
 
+## Related Terms
+
+- [Unit Test Automation](/docs/concepts/reference/glossary/unit-test-automation/) — automate running your unit tests.
+- [Test-Driven Development](/docs/concepts/reference/glossary/test-driven-development/) — write unit tests before code.
+- [Mocks](/docs/concepts/reference/glossary/mocks/) — isolate the unit under test.
+- [Integration Testing](/docs/concepts/reference/glossary/integration-testing/) — verify units work together.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQs
 
 ### 1. **What is Unit Testing?**
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/visual-regression-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/visual-regression-testing.md
index 40f6c9d7b1..01e3c58651 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/visual-regression-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/visual-regression-testing.md
@@ -151,6 +151,13 @@ Visual regression testing continues to evolve as applications become more comple
 
 **Performance-Aware Visual Testing**: Future visual regression testing will integrate performance considerations, ensuring that visual quality improvements don't come at the expense of application performance.
 
+## Related Terms
+
+- [Regression Testing](/docs/concepts/reference/glossary/regression-testing/) — visual regression is a specialized form of it.
+- [Functional Testing](/docs/concepts/reference/glossary/functional-testing/) — complements visual checks with behavior validation.
+- [Component Testing](/docs/concepts/reference/glossary/component-testing/) — test isolated UI components visually.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## Frequently Asked Questions
 
 ### Q: Can Keploy handle dynamic content and API-dependent visual states in regression testing?
diff --git a/versioned_docs/version-4.0.0/concepts/reference/glossary/white-box-testing.md b/versioned_docs/version-4.0.0/concepts/reference/glossary/white-box-testing.md
index 2d0600ba0b..529796dcb5 100644
--- a/versioned_docs/version-4.0.0/concepts/reference/glossary/white-box-testing.md
+++ b/versioned_docs/version-4.0.0/concepts/reference/glossary/white-box-testing.md
@@ -119,6 +119,14 @@ Firstly, install [Keploy](https://keploy.io/), a testing tool that helps you aut
 
 White box testing is invaluable for uncovering hidden errors and optimizing performance. While it requires technical expertise, its thorough approach ensures robust, secure, and high-performing software. Combining white box testing with black box testing offers comprehensive coverage, enhancing the overall quality of your applications.
 
+## Related Terms
+
+- [Black Box Testing](/docs/concepts/reference/glossary/black-box-testing/) — the opposite approach with no internal knowledge.
+- [Grey Box Testing](/docs/concepts/reference/glossary/gray-box-testing/) — a hybrid of white and black box testing.
+- [Code Coverage](/docs/concepts/reference/glossary/code-coverage/) — measure which code paths tests exercise.
+- [Unit Testing](/docs/concepts/reference/glossary/unit-testing/) — a common white box technique.
+- [Browse all testing terms](/docs/concepts/reference/glossary/) — the full Keploy glossary.
+
 ## FAQs
 
 ### What is white box testing?
diff --git a/versioned_docs/version-4.0.0/keploy-cloud/deduplication.md b/versioned_docs/version-4.0.0/keploy-cloud/deduplication.md
index 75795233a4..840bfb0bf8 100644
--- a/versioned_docs/version-4.0.0/keploy-cloud/deduplication.md
+++ b/versioned_docs/version-4.0.0/keploy-cloud/deduplication.md
@@ -261,3 +261,10 @@ This reads `dedupData.yaml` and writes `duplicates.yaml`, listing the testcases
 ```bash
 keploy dedup --rm
 ```
+
+## Related
+
+- [Static Deduplication](/docs/keploy-cloud/static-deduplication/) — drop duplicate shapes at record time.
+- [Auto Test Generation](/docs/keploy-cloud/auto-test-generation/) — generate tests from an OpenAPI schema.
+- [Cloud Replay Command Reference](/docs/keploy-cloud/cloud-replay/) — replay with the `--dedup` flag.
+- [LLM Workflow (Smart Tests)](/docs/keploy-cloud/smart-set-agent/) — deduplicated smart-set workflow.
diff --git a/versioned_docs/version-4.0.0/keploy-cloud/gitops-argocd.md b/versioned_docs/version-4.0.0/keploy-cloud/gitops-argocd.md
index 9ca0c6fe46..61365fcbd5 100644
--- a/versioned_docs/version-4.0.0/keploy-cloud/gitops-argocd.md
+++ b/versioned_docs/version-4.0.0/keploy-cloud/gitops-argocd.md
@@ -322,3 +322,10 @@ To add Keploy to an existing ArgoCD setup, you need:
 | Kubernetes Secret  | `kubectl create secret` (manual) | Access key for Keploy cloud authentication  |
 
 Your existing application code, manifests, and ArgoCD Applications remain **completely untouched**. Keploy works alongside your app—not inside it.
+
+## Related
+
+- [Deploy Keploy with Flux CD](/docs/keploy-cloud/gitops-flux/) — the same deployment with Flux GitOps.
+- [Kubernetes Setup](/docs/keploy-cloud/kubernetes/) — prerequisite cluster and k8s-proxy setup.
+- [Kubernetes Local Setup (Kind)](/docs/keploy-cloud/kubernetes-local-setup/) — spin up a local Kind cluster.
+- [Keploy Enterprise Installation](/docs/keploy-cloud/cloud-installation/) — install the Enterprise agent.
diff --git a/versioned_docs/version-4.0.0/keploy-cloud/gitops-flux.md b/versioned_docs/version-4.0.0/keploy-cloud/gitops-flux.md
index 4a519b0530..40ff6f2aee 100644
--- a/versioned_docs/version-4.0.0/keploy-cloud/gitops-flux.md
+++ b/versioned_docs/version-4.0.0/keploy-cloud/gitops-flux.md
@@ -260,3 +260,10 @@ To add Keploy to an existing Flux setup, you need:
 | Kubernetes Secret | `kubectl create secret` (manual) | Access key for Keploy cloud authentication  |
 
 Your existing application manifests and Flux configurations remain **completely untouched**. Keploy works alongside your app—not inside it.
+
+## Related
+
+- [Deploy Keploy with ArgoCD](/docs/keploy-cloud/gitops-argocd/) — the same deployment with ArgoCD GitOps.
+- [Kubernetes Setup](/docs/keploy-cloud/kubernetes/) — prerequisite cluster and k8s-proxy setup.
+- [Kubernetes Local Setup (Kind)](/docs/keploy-cloud/kubernetes-local-setup/) — spin up a local Kind cluster.
+- [Keploy Enterprise Installation](/docs/keploy-cloud/cloud-installation/) — install the Enterprise agent.
diff --git a/versioned_docs/version-4.0.0/keploy-cloud/installation.md b/versioned_docs/version-4.0.0/keploy-cloud/installation.md
index decffbc36b..d9d918b911 100644
--- a/versioned_docs/version-4.0.0/keploy-cloud/installation.md
+++ b/versioned_docs/version-4.0.0/keploy-cloud/installation.md
@@ -71,3 +71,10 @@ b1dNl....
 ```
 
 Once the API key is successfully validated, the Keploy Enterprise Agent will begin recording API calls.
+
+## Related
+
+- [Kubernetes Setup](/docs/keploy-cloud/kubernetes/) — connect a cluster for live record and replay.
+- [Keploy Cloud Application Settings Guide](/docs/keploy-cloud/application-settings/) — add your first application.
+- [Keploy Console](/docs/keploy-cloud/keploy-console/) — visualize and edit test results.
+- [Time Freezing](/docs/keploy-cloud/time-freezing/) — keep time-sensitive tests reliable.
diff --git a/versioned_docs/version-4.0.0/keploy-cloud/keploy-console.md b/versioned_docs/version-4.0.0/keploy-cloud/keploy-console.md
index 41d4e3d6e8..af98a1292e 100644
--- a/versioned_docs/version-4.0.0/keploy-cloud/keploy-console.md
+++ b/versioned_docs/version-4.0.0/keploy-cloud/keploy-console.md
@@ -81,6 +81,13 @@ You'd see the changes in the test-case file locally, new noisy fields are added
 
 Similarly, if the test case result is the new expected response, we can normalise the test report or a particular test case. This will update the expected result of the test case locally.
 
+## Related
+
+- [Keploy Enterprise Installation](/docs/keploy-cloud/cloud-installation/) — prerequisite before starting the console.
+- [Keploy Cloud Application Settings Guide](/docs/keploy-cloud/application-settings/) — add an application to the console.
+- [Mock Registry](/docs/keploy-cloud/mock-registry/) — manage mocks used during test runs.
+- [Time Freezing](/docs/keploy-cloud/time-freezing/) — stabilize time-sensitive test results.
+
 ## Need Help?
 
 If you have any questions or need assistance, our support team is here to help. You can reach out to us through our support portal, Slack or by emailing us.
diff --git a/versioned_docs/version-4.0.0/keploy-cloud/kubernetes-local-setup.md b/versioned_docs/version-4.0.0/keploy-cloud/kubernetes-local-setup.md
index 41d1e998dc..9161f7eb93 100644
--- a/versioned_docs/version-4.0.0/keploy-cloud/kubernetes-local-setup.md
+++ b/versioned_docs/version-4.0.0/keploy-cloud/kubernetes-local-setup.md
@@ -237,3 +237,10 @@ kube-system          coredns-7d764666f9-r82lr                          1/1     R
 ✅ Once deployments are visible, you can start **recording on any Pod** and later **replay**.
 
 ![Keploy Kubernetes Interface](/img/k8s-local-cluster-ui.png)
+
+## Related
+
+- [Kubernetes Setup](/docs/keploy-cloud/kubernetes/) — full cluster setup including ingress and GitOps.
+- [Deploy Keploy with ArgoCD](/docs/keploy-cloud/gitops-argocd/) — deploy the k8s-proxy declaratively with ArgoCD.
+- [Deploy Keploy with Flux CD](/docs/keploy-cloud/gitops-flux/) — deploy the k8s-proxy declaratively with Flux.
+- [Keploy Enterprise Installation](/docs/keploy-cloud/cloud-installation/) — install the Enterprise agent.
diff --git a/versioned_docs/version-4.0.0/keploy-cloud/kubernetes.md b/versioned_docs/version-4.0.0/keploy-cloud/kubernetes.md
index e5414384f5..7587aae47c 100644
--- a/versioned_docs/version-4.0.0/keploy-cloud/kubernetes.md
+++ b/versioned_docs/version-4.0.0/keploy-cloud/kubernetes.md
@@ -653,3 +653,9 @@ curl -sk https://<YOUR_INGRESS_HOST>:30080/healthz
 ```
 
 ✅ Open the Keploy UI → **Clusters** → your cluster should show as **Connected**. You can now record and replay traffic on any deployment.
+
+## Related
+
+- [Kubernetes Local Setup (Kind)](/docs/keploy-cloud/kubernetes-local-setup/) — spin up a local Kind cluster.
+- [Keploy Enterprise Installation](/docs/keploy-cloud/cloud-installation/) — install the Enterprise agent.
+- [Deploy Keploy with ArgoCD](/docs/keploy-cloud/gitops-argocd/) — GitOps deployment on the cluster.
diff --git a/versioned_docs/version-4.0.0/keploy-cloud/mock-registry.md b/versioned_docs/version-4.0.0/keploy-cloud/mock-registry.md
index bc868bebfd..e1ac555068 100644
--- a/versioned_docs/version-4.0.0/keploy-cloud/mock-registry.md
+++ b/versioned_docs/version-4.0.0/keploy-cloud/mock-registry.md
@@ -85,3 +85,9 @@ Public mocks are accessible by all users and can be shared across multiple proje
 #### Private Mocks 🔐
 
 Private mocks are restricted to specific users or projects. Use private mocks for sensitive or project-specific data to ensure security and privacy.
+
+## Related
+
+- [Dynamic Deduplication](/docs/keploy-cloud/deduplication/) — remove duplicate recorded interactions.
+- [Static Deduplication](/docs/keploy-cloud/static-deduplication/) — dedupe without running tests.
+- [Keploy Console](/docs/keploy-cloud/keploy-console/) — manage mocks and suites in the console.
diff --git a/versioned_docs/version-4.0.0/keploy-cloud/new-application.md b/versioned_docs/version-4.0.0/keploy-cloud/new-application.md
index c5b1d1d3b8..eacc3066b9 100644
--- a/versioned_docs/version-4.0.0/keploy-cloud/new-application.md
+++ b/versioned_docs/version-4.0.0/keploy-cloud/new-application.md
@@ -48,3 +48,9 @@ Finally, edit the default [Keploy Config](/docs/running-keploy/configuration-fil
 ### Need Help?
 
 If you have any questions or need assistance, our support team is here to help. You can reach out to us through our support portal, Slack or by emailing us.
+
+## Related
+
+- [Keploy Console](/docs/keploy-cloud/keploy-console/) — where applications are managed.
+- [Keploy Enterprise Installation](/docs/keploy-cloud/cloud-installation/) — install before adding an app.
+- [Auto Test Generation](/docs/keploy-cloud/auto-test-generation/) — generate tests for the new app.
diff --git a/versioned_docs/version-4.0.0/keploy-cloud/testgeneration.md b/versioned_docs/version-4.0.0/keploy-cloud/testgeneration.md
index 07f1cc5ee9..bf4d28a01a 100644
--- a/versioned_docs/version-4.0.0/keploy-cloud/testgeneration.md
+++ b/versioned_docs/version-4.0.0/keploy-cloud/testgeneration.md
@@ -436,3 +436,9 @@ keploy generate-tests -c "java -jar <JAR_FILE_PATH>" -s "schema.json"
 We will get similar output: -
 
 <img width="881" alt="image" src="https://github.com/keploy/docs/assets/53110238/2586dd57-dee8-46dd-9886-08ad729685c1"/>
+
+## Related
+
+- [Keploy Console](/docs/keploy-cloud/keploy-console/) — trigger and view generation.
+- [LLM Workflow (Smart Tests)](/docs/keploy-cloud/smart-set-agent/) — smarter AI-driven generation.
+- [Keploy Cloud Application Settings Guide](/docs/keploy-cloud/application-settings/) — configure the app first.
diff --git a/versioned_docs/version-4.0.0/keploy-cloud/time-freezing.md b/versioned_docs/version-4.0.0/keploy-cloud/time-freezing.md
index d919b48bfd..106227d8cc 100644
--- a/versioned_docs/version-4.0.0/keploy-cloud/time-freezing.md
+++ b/versioned_docs/version-4.0.0/keploy-cloud/time-freezing.md
@@ -142,3 +142,9 @@ keploy test -c "<appCmd>" --freeze-time
 ```
 
 Voila! Your tests will now run with time freezing enabled.
+
+## Related
+
+- [Dynamic Deduplication](/docs/keploy-cloud/deduplication/) — related test-stability feature.
+- [Static Deduplication](/docs/keploy-cloud/static-deduplication/) — dedupe recorded tests.
+- [Mock Registry](/docs/keploy-cloud/mock-registry/) — manage the mocks time-freezing relies on.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/ai-models.md b/versioned_docs/version-4.0.0/keploy-explained/ai-models.md
index 58513df5ca..f0c2717f9b 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/ai-models.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/ai-models.md
@@ -38,3 +38,10 @@ By combining different models, Keploy can generate better test cases, filter out
 - **Model Selection:** We choose models for you automatically, but always with a focus on security, reliability, and test quality.
 
 Want to learn more about how AI powers Keploy? [Contact us](mailto:support@keploy.io)
+
+## Related
+
+- [Unit Testing FAQ](/docs/keploy-explained/unit-testing-faq/) — which AI models power test generation.
+- [API Testing – Frequently Asked Questions](/docs/keploy-explained/api-testing-faq/) — how AI handles API testing.
+- [Supported Languages for Unit Testing](/docs/keploy-explained/supported-languages/) — languages our AI supports.
+- [Code Privacy & Data Protection](/docs/keploy-explained/keploy-privacy/) — your code never trains models.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/api-testing-faq.md b/versioned_docs/version-4.0.0/keploy-explained/api-testing-faq.md
index fa82c39ea1..47d86d08e3 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/api-testing-faq.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/api-testing-faq.md
@@ -102,3 +102,10 @@ Have questions or need a security report for your team? [Contact us!](mailto:sup
 Your code, your data, your control. 🔐
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [Integration Testing FAQ](/docs/keploy-explained/integration-testing-faq/) — questions on integration testing.
+- [Unit Testing FAQ](/docs/keploy-explained/unit-testing-faq/) — questions on unit test generation.
+- [How Keploy Works?](/docs/keploy-explained/how-keploy-works/) — the architecture behind API testing.
+- [Keploy Troubleshooting Guide](/docs/keploy-explained/common-errors/) — fix common recording and replay errors.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/common-errors.md b/versioned_docs/version-4.0.0/keploy-explained/common-errors.md
index 18adb288ef..ab184db1bf 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/common-errors.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/common-errors.md
@@ -227,3 +227,10 @@ See [MySQL port detection](../running-keploy/configuration-file.md#mysql-port-de
 If you’re still encountering issues after trying these solutions, feel free to reach out to the Keploy team on [Slack](https://keploy.io/slack).
 
 Happy Testing!
+
+## Related
+
+- [Debugger Guide](/docs/keploy-explained/debugger-guide/) — debug Keploy with the VS Code debugger.
+- [Running Keploy Natively on Windows](/docs/keploy-explained/windows-wsl/) — Windows setup and fixes.
+- [Running Keploy Natively on MacOS by setting up a linux env](/docs/keploy-explained/mac-linux/) — macOS setup with Lima.
+- [API Testing – Frequently Asked Questions](/docs/keploy-explained/api-testing-faq/) — common API testing questions.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/debugger-guide.md b/versioned_docs/version-4.0.0/keploy-explained/debugger-guide.md
index 4a2204fbf3..00f90abe36 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/debugger-guide.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/debugger-guide.md
@@ -100,3 +100,10 @@ You can either add more objects in the "configurations" array or modify the "arg
 Click the **Start Debugging** button to witness the magic of debugging unfold seamlessly.
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [Testing Guide](/docs/keploy-explained/testing-guide/) — how Keploy's test bench works.
+- [Contribution Guide](/docs/keploy-explained/contribution-guide/) — set up Keploy locally for development.
+- [Keploy Troubleshooting Guide](/docs/keploy-explained/common-errors/) — resolve common errors while debugging.
+- [IDE Integrations — VS Code](/docs/keploy-explained/integrations-vscode/) — Keploy inside VS Code.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/dev-guide.md b/versioned_docs/version-4.0.0/keploy-explained/dev-guide.md
index a4a6b6b79c..61ed70d3f3 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/dev-guide.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/dev-guide.md
@@ -310,3 +310,10 @@ curl --silent -O -L https://keploy.io/install.sh && source install.sh --oss
 </Tabs>
 </TabItem>
 </Tabs>
+
+## Related
+
+- [Keploy Docs Contribution Guide](/docs/keploy-explained/docs-dev-guide/) — contribute to the documentation.
+- [Testing Guide](/docs/keploy-explained/testing-guide/) — how Keploy's test bench works.
+- [Debugger Guide](/docs/keploy-explained/debugger-guide/) — debug Keploy while developing.
+- [How Keploy Works?](/docs/keploy-explained/how-keploy-works/) — the internal architecture.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/docs-dev-guide.md b/versioned_docs/version-4.0.0/keploy-explained/docs-dev-guide.md
index 1e5bbf2a44..8fec24ab79 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/docs-dev-guide.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/docs-dev-guide.md
@@ -166,3 +166,9 @@ If you have ideas on how we can improve, please share them with us by creating a
 Right now our interfaces do not support translations and we also don't have a translation strategy in place. But we want to change this. We want our projects to be accessible to non-English speakers. If you have any ideas then please share them with us by creating a [new issue].
 
 Hope this helps you out, if you still have any questions, reach out to us
+
+## Related
+
+- [Contribution Guide](/docs/keploy-explained/contribution-guide/) — contribute to Keploy itself.
+- [How Keploy Works?](/docs/keploy-explained/how-keploy-works/) — architecture background for contributors.
+- [What is Keploy?](/docs/keploy-explained/introduction/) — project overview.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/how-keploy-works.md b/versioned_docs/version-4.0.0/keploy-explained/how-keploy-works.md
index c5dee33809..4d087b5ee2 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/how-keploy-works.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/how-keploy-works.md
@@ -69,3 +69,9 @@ Consider an application server serving HTTP APIs for clients like web/mobile app
 - **Test Mode:** Keploy reads the YAML files for test cases and stubs/mocks. It starts the application, sends recorded HTTP test cases, and mocks responses for outgoing calls. This ensures no side effects due to non-idempotency.
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [What is Keploy?](/docs/keploy-explained/introduction/) — start-here overview.
+- [Why Keploy?](/docs/keploy-explained/why-keploy/) — the problems it solves.
+- [How Keploy Uses AI Models for Testing](/docs/keploy-explained/ai-models/) — the AI layer.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/integration-testing-faq.md b/versioned_docs/version-4.0.0/keploy-explained/integration-testing-faq.md
index 10d5a739d9..0175920091 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/integration-testing-faq.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/integration-testing-faq.md
@@ -64,3 +64,9 @@ Yes, Keploy is open-source and free to use under the Apache 2.0 license. You can
 Yes, Keploy provides configuration options to customize recording, replay, and comparison logic for specific APIs, giving users control over how their APIs are tested.
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [API Testing – Frequently Asked Questions](/docs/keploy-explained/api-testing-faq/) — API testing FAQ.
+- [Unit Testing FAQ](/docs/keploy-explained/unit-testing-faq/) — unit testing FAQ.
+- [How Keploy Works?](/docs/keploy-explained/how-keploy-works/) — how integration tests are captured.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/integrations-pr-agent.md b/versioned_docs/version-4.0.0/keploy-explained/integrations-pr-agent.md
index eba900f91e..d063c2ab90 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/integrations-pr-agent.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/integrations-pr-agent.md
@@ -13,10 +13,20 @@ tags:
 
 Keploy’s PR Agent helps automate code reviews, testing, and feedback—right where you work.
 
+## What the PR Agent does
+
+The PR Agent runs Keploy inside your source-control workflow and comments back on the pull request itself, so test feedback lives next to the code being reviewed instead of in a separate dashboard. On each pull request it can:
+
+- **Generate and run tests** against the changed code and report pass/fail status as a PR check.
+- **Surface coverage** so reviewers can see whether new code is exercised by tests before merging.
+- **Leave inline feedback** on the diff, highlighting untested paths or regressions the recorded suites catch.
+
+This keeps the "did this change break anything?" question answerable at review time, rather than after a merge.
+
 ## ✅ Currently Supported
 
 **GitHub:**  
- Our PR Agent seamlessly integrates with GitHub repositories for test automation, coverage checks, and intelligent feedback on your pull requests.
+Our PR Agent seamlessly integrates with GitHub repositories for test automation, coverage checks, and intelligent feedback on your pull requests. If you already run Keploy in CI, the PR Agent complements the [CI/CD GitHub setup](/docs/ci-cd/github/) by adding review-time feedback on top of your pipeline runs.
 
 ## 💡 Need Support for Another Platform?
 
@@ -27,3 +37,9 @@ Want Keploy’s PR Agent on GitLab, Bitbucket, or another platform?
 We’re always open to feedback and requests as we expand our integration support.
 
 **More integrations are coming soon—stay tuned!**
+
+## Related
+
+- [Generate API tests using AI](/docs/running-keploy/generate-api-tests-using-ai/) — the test-generation engine the PR Agent runs on your changes.
+- [UTG PR Agent (unit-test generation on PRs)](/docs/running-keploy/utg-pr-agent/) — the companion agent for unit tests.
+- [CI/CD with GitHub Actions](/docs/ci-cd/github/) — wire Keploy into your GitHub pipeline.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/integrations-vscode.md b/versioned_docs/version-4.0.0/keploy-explained/integrations-vscode.md
index 6026aaacc4..ae5cba93ea 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/integrations-vscode.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/integrations-vscode.md
@@ -16,7 +16,7 @@ Keploy aims to make AI-powered unit testing as seamless as possible—right insi
 ## ✅ Currently Supported
 
 **Visual Studio Code (VS Code):**  
- We offer smooth integration with VS Code, so you can generate, view, and manage AI-generated unit tests without leaving your IDE.
+We offer smooth integration with VS Code, so you can generate, view, and manage AI-generated unit tests without leaving your IDE.
 
 ## 💡 Want Support for Another IDE?
 
@@ -27,3 +27,9 @@ Need Keploy in JetBrains, Neovim, or another editor?
 Your feedback shapes our roadmap!
 
 More IDE integrations are coming soon—stay tuned.
+
+## Related
+
+- [SCM Integrations — PR Agent](/docs/keploy-explained/integrations-pr-agent/) — the pull-request integration.
+- [Keploy Troubleshooting Guide](/docs/keploy-explained/common-errors/) — fix common setup issues.
+- [What is Keploy?](/docs/keploy-explained/introduction/) — project overview.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/introduction.md b/versioned_docs/version-4.0.0/keploy-explained/introduction.md
index 832fb0a1c0..a3ccd72d79 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/introduction.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/introduction.md
@@ -12,3 +12,9 @@ import WhatIsKeploy from '../concepts/what-is-keploy.md'
 import WhatAreKeployFeatures from '../concepts/what-are-keploy-features.md'
 
 <WhatAreKeployFeatures/>
+
+## Related
+
+- [Why Keploy?](/docs/keploy-explained/why-keploy/) — the motivation and benefits.
+- [How Keploy Works?](/docs/keploy-explained/how-keploy-works/) — the underlying mechanism.
+- [Supported Languages for Unit Testing](/docs/keploy-explained/supported-languages/) — language coverage.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/keploy-privacy.md b/versioned_docs/version-4.0.0/keploy-explained/keploy-privacy.md
index 119ef95547..b9eb2b1cac 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/keploy-privacy.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/keploy-privacy.md
@@ -31,3 +31,9 @@ Keploy is built with privacy as a core value. Here’s how we keep your code and
 We’re committed to making privacy non-negotiable.
 
 Have questions, concerns, or requests? [Contact our team](mailto:support@keploy.io)—we’re here to help.
+
+## Related
+
+- [Security & Compliance at Keploy](/docs/keploy-explained/keploy-security/) — the security counterpart.
+- [What is Keploy?](/docs/keploy-explained/introduction/) — project overview.
+- [Why Keploy?](/docs/keploy-explained/why-keploy/) — where privacy fits in.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/keploy-security.md b/versioned_docs/version-4.0.0/keploy-explained/keploy-security.md
index 88f233c2c2..2566bdf211 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/keploy-security.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/keploy-security.md
@@ -38,3 +38,9 @@ Your data remains confidential and secure—whether you’re a startup or an ent
 - **Full Transparency:** We are open about our processes and happy to answer any questions you have about security or privacy.
 
 Have questions or need a security report for your team? [Contact us!](mailto:support@keploy.io)
+
+## Related
+
+- [Code Privacy & Data Protection](/docs/keploy-explained/keploy-privacy/) — the privacy counterpart.
+- [What is Keploy?](/docs/keploy-explained/introduction/) — project overview.
+- [How Keploy Works?](/docs/keploy-explained/how-keploy-works/) — where data is processed.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/mac-linux.md b/versioned_docs/version-4.0.0/keploy-explained/mac-linux.md
index 42ef246f79..4c9436dfd8 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/mac-linux.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/mac-linux.md
@@ -62,3 +62,9 @@ Congratulations! You've successfully set up Keploy natively on MacOS.
 Begin recording your API calls and generating test cases with Keploy.
 
 #### [Back to Installation Guide](/docs/server/installation/)
+
+## Related
+
+- [Running Keploy Natively on Windows](/docs/keploy-explained/windows-wsl/) — the Windows setup.
+- [Keploy Troubleshooting Guide](/docs/keploy-explained/common-errors/) — fix common install issues.
+- [Keploy CLI Commands](/docs/running-keploy/cli-commands/) — commands to run after install.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/supported-languages.md b/versioned_docs/version-4.0.0/keploy-explained/supported-languages.md
index fd385be1bc..abbe7bc793 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/supported-languages.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/supported-languages.md
@@ -49,3 +49,9 @@ We’re expanding—tell us what language you need next!
 
 **Our Promise:**  
 No matter the language, Keploy helps you create _meaningful_, _maintainable_ tests that genuinely improve your code—not just sample outputs.
+
+## Related
+
+- [What is Keploy?](/docs/keploy-explained/introduction/) — project overview.
+- [Best practices for unit testing and UTG?](/docs/keploy-explained/utg-best-practices/) — get the most per language.
+- [Testing Guide](/docs/keploy-explained/testing-guide/) — testing concepts and workflow.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/testing-guide.md b/versioned_docs/version-4.0.0/keploy-explained/testing-guide.md
index 93cb587d89..6bee3f6ee3 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/testing-guide.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/testing-guide.md
@@ -145,3 +145,9 @@ If both scenarios yield a "passed" result, it signifies that this approach mirro
 <!-- To understand the internals you can refer to this [blog](blog link). -->
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [What is Keploy?](/docs/keploy-explained/introduction/) — project overview.
+- [Best practices for unit testing and UTG?](/docs/keploy-explained/utg-best-practices/) — practical guidance.
+- [Supported Languages for Unit Testing](/docs/keploy-explained/supported-languages/) — language coverage.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/unit-testing-faq.md b/versioned_docs/version-4.0.0/keploy-explained/unit-testing-faq.md
index 3b1df8de25..c39885d1cd 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/unit-testing-faq.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/unit-testing-faq.md
@@ -103,3 +103,9 @@ We’re committed to keeping your trust.
 - Deeper IDE and CI/CD integrations
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [Integration Testing FAQ](/docs/keploy-explained/integration-testing-faq/) — integration testing FAQ.
+- [API Testing – Frequently Asked Questions](/docs/keploy-explained/api-testing-faq/) — API testing FAQ.
+- [Best practices for unit testing and UTG?](/docs/keploy-explained/utg-best-practices/) — unit testing tips.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/utg-best-practices.md b/versioned_docs/version-4.0.0/keploy-explained/utg-best-practices.md
index 2af7dfe78a..b41b67c7e4 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/utg-best-practices.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/utg-best-practices.md
@@ -278,3 +278,9 @@ Seamlessly blend test generation with existing development practices:
 - **Continuous Learning**: Stay updated with testing industry best practices
 
 _Remember: Automated testing tools are force multipliers, not replacements for thoughtful testing strategy. The goal is to amplify human expertise, not replace human judgment._
+
+## Related
+
+- [Supported Languages for Unit Testing](/docs/keploy-explained/supported-languages/) — language coverage.
+- [Testing Guide](/docs/keploy-explained/testing-guide/) — broader testing workflow.
+- [Unit Testing FAQ](/docs/keploy-explained/unit-testing-faq/) — common unit testing questions.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/why-keploy.md b/versioned_docs/version-4.0.0/keploy-explained/why-keploy.md
index 7e3f3495ac..ab2745aa61 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/why-keploy.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/why-keploy.md
@@ -30,3 +30,9 @@ tags:
 ⭐ If you're excited about what's coming, show some love by [starring Keploy on GitHub](https://github.com/keploy/keploy)
 
 🤙 We're happy to hear from you in-case you want to deep-dive. [Schedule a demo](https://calendar.app.google/3mHeyaoKg3A2qkqF6) – because the best tests are yet to come! 🚀🎉
+
+## Related
+
+- [What is Keploy?](/docs/keploy-explained/introduction/) — project overview.
+- [How Keploy Works?](/docs/keploy-explained/how-keploy-works/) — the mechanism behind the benefits.
+- [Security & Compliance at Keploy](/docs/keploy-explained/keploy-security/) — enterprise readiness.
diff --git a/versioned_docs/version-4.0.0/keploy-explained/windows-wsl.md b/versioned_docs/version-4.0.0/keploy-explained/windows-wsl.md
index a9c9123a02..0dddd109a3 100644
--- a/versioned_docs/version-4.0.0/keploy-explained/windows-wsl.md
+++ b/versioned_docs/version-4.0.0/keploy-explained/windows-wsl.md
@@ -15,19 +15,49 @@ keywords:
   - installation
 ---
 
-On Windows, WSL is required to run Keploy Binary. You must be running Windows 10 version 2004 and higher (Build 19041
-and higher) or Windows 11 to use the commands below.
+import HowTo from '@site/src/components/HowTo';
+
+<HowTo
+name="Run Keploy natively on Windows via WSL"
+description="Set up WSL and install the Keploy binary inside a Linux distribution to run Keploy on Windows."
+totalTime="PT10M"
+tools={["Windows", "WSL", "Ubuntu", "Keploy CLI"]}
+steps={[
+{name: "Check prerequisites", text: "Ensure you are on Windows 10 version 2004+ (build 19041+) or Windows 11 with admin access."},
+{name: "Install WSL + Ubuntu", text: "Run wsl --install -d Ubuntu-22.04 from an elevated terminal and set up your Linux user."},
+{name: "Install the Keploy binary", text: "Inside the WSL shell download the Keploy release tarball and move the binary to /usr/local/bin."},
+{name: "Verify", text: "Run keploy in the WSL shell to confirm the CLI is installed."},
+]}
+visible={false}
+/>
+
+Keploy relies on the Linux kernel's eBPF subsystem to capture network traffic, so it does not run directly on the Windows kernel. On Windows you run Keploy inside **WSL (Windows Subsystem for Linux)**, which gives you a real Linux kernel while keeping your Windows development environment. This page covers the WSL prerequisites and installs the Keploy binary inside that Linux environment.
+
+## Prerequisites
+
+- **Windows 10** version 2004 or higher (Build 19041 and higher), or **Windows 11**.
+- Administrator access to run `wsl --install` the first time.
+- A working internet connection to pull the WSL distribution and the Keploy release.
+
+## Enable WSL and install a Linux distribution
+
+Open PowerShell or Windows Terminal **as Administrator** and run:
 
 ```shell
 wsl --install -d <Distribution Name>
 ```
 
-Recommended to use "Ubuntu-22.04"
+We recommend **"Ubuntu-22.04"**:
 
-This command will enable the features necessary to run WSL and install the Ubuntu distribution of Linux. (This default
-distribution can be changed).
+```shell
+wsl --install -d Ubuntu-22.04
+```
+
+This command enables the features necessary to run WSL and installs the chosen Ubuntu distribution of Linux. (The default distribution can be changed.) You may be prompted to restart Windows and to create a Linux username and password on first launch.
+
+## Install the Keploy binary
 
-Install "Keploy Binary" :
+Once you are inside your WSL Ubuntu shell, install the Keploy binary:
 
 ```shell
 curl --silent --location "https://github.com/keploy/keploy/releases/latest/download/keploy_linux_amd64.tar.gz" | tar xz -C /tmp
@@ -35,6 +65,8 @@ curl --silent --location "https://github.com/keploy/keploy/releases/latest/downl
 sudo mkdir -p /usr/local/bin && sudo mv /tmp/keploy /usr/local/bin && keploy
 ```
 
+Running `keploy` should print the CLI help, confirming the binary is on your `PATH`. From here on, run every Keploy command from inside the WSL shell (not native PowerShell), and keep your application code on the WSL filesystem for the best performance.
+
 Congratulations! You've successfully set up Keploy natively on Windows.
 
 ## What's Next?
@@ -44,3 +76,9 @@ Congratulations! You've successfully set up Keploy natively on Windows.
 Begin recording your API calls and generating test cases with Keploy.
 
 #### [Back to Installation Guide](/docs/server/installation/)
+
+## Related
+
+- [Running Keploy on macOS and Linux](/docs/keploy-explained/mac-linux/) — the equivalent setup for other operating systems.
+- [CLI commands reference](/docs/running-keploy/cli-commands/) — every `keploy` command and flag.
+- [Common errors and fixes](/docs/keploy-explained/common-errors/) — troubleshooting, including WSL-specific issues.
diff --git a/versioned_docs/version-4.0.0/quickstart/code-coverage.md b/versioned_docs/version-4.0.0/quickstart/code-coverage.md
index 24abcb386f..c5945db539 100644
--- a/versioned_docs/version-4.0.0/quickstart/code-coverage.md
+++ b/versioned_docs/version-4.0.0/quickstart/code-coverage.md
@@ -32,8 +32,8 @@ High code coverage does not always mean good tests, but it ensures that critical
 <Tabs>
 
   <TabItem value="qa" label="For QA">
-  
-  ## ✅ Schema Coverage
+
+## ✅ Schema Coverage
 
 Schema coverage measures how much of your **API schema** (endpoints, request/response fields, contracts) is exercised during testing.
 
@@ -70,3 +70,10 @@ Statement coverage measures how many **individual lines/statements of code** are
 </TabItem>
 
 </Tabs>
+
+## Related
+
+- [Sample Golang Apps](/docs/quickstart/golang-filter/) — Go samples to measure coverage.
+- [Sample Java Apps](/docs/quickstart/java-springboot-filter/) — Java samples with coverage reports.
+- [Sample Python Apps](/docs/quickstart/python-filter/) — Python samples to try coverage.
+- [Keploy Integration with PetClinic App](/docs/quickstart/pet-clinic/) — Java app with Jacoco coverage.
diff --git a/versioned_docs/version-4.0.0/quickstart/csharp-dotnet-postgres.md b/versioned_docs/version-4.0.0/quickstart/csharp-dotnet-postgres.md
index 772a12efae..f84aa68b4e 100644
--- a/versioned_docs/version-4.0.0/quickstart/csharp-dotnet-postgres.md
+++ b/versioned_docs/version-4.0.0/quickstart/csharp-dotnet-postgres.md
@@ -205,3 +205,10 @@ Final thoughts? Dive deeper! Try different API calls, tweak the DB response in t
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible. 😊🚀
 
 Happy coding! ✨👩‍💻👨‍💻✨
+
+## Related
+
+- [Sample CRUD App (Golang)](/docs/quickstart/samples-fasthttp/) — another Postgres-backed CRUD app.
+- [Sample Product Catalog App (Golang)](/docs/quickstart/samples-mux/) — Go app using Postgres.
+- [Express + PostgreSQL + Prisma Sample Application](/docs/quickstart/express-postgresql-prisma/) — Postgres with an ORM.
+- [NextJs Sample Application](/docs/quickstart/samples-nextjs/) — NextJS app on Postgres.
diff --git a/versioned_docs/version-4.0.0/quickstart/express-postgresql-prisma.md b/versioned_docs/version-4.0.0/quickstart/express-postgresql-prisma.md
index 13585a1b88..92c9a78909 100644
--- a/versioned_docs/version-4.0.0/quickstart/express-postgresql-prisma.md
+++ b/versioned_docs/version-4.0.0/quickstart/express-postgresql-prisma.md
@@ -440,3 +440,10 @@ Node.js v22.7.0
 ```
 
 Voila! 🎉 You have successfully tested the application using Keploy. Keploy also generates coverage reports for the test-suites.
+
+## Related
+
+- [Sample JavaScript Apps](/docs/quickstart/javascript-filter/) — browse more JS samples.
+- [Node.js Express Mongoose Sample](/docs/quickstart/samples-nodejs/) — Express with a different datastore.
+- [NodeJS - JWT Sample Application](/docs/quickstart/samples-node-jwt/) — Node app on Postgres.
+- [NextJs Sample Application](/docs/quickstart/samples-nextjs/) — another Postgres-backed JS app.
diff --git a/versioned_docs/version-4.0.0/quickstart/flask-redis.md b/versioned_docs/version-4.0.0/quickstart/flask-redis.md
index c9277d6cd6..8f4951bf50 100644
--- a/versioned_docs/version-4.0.0/quickstart/flask-redis.md
+++ b/versioned_docs/version-4.0.0/quickstart/flask-redis.md
@@ -172,3 +172,10 @@ You can also check the test summary from your cli
 ### Wrapping it up 🎉
 
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible. 😊🚀
+
+## Related
+
+- [Sample Python Apps](/docs/quickstart/python-filter/) — browse more Python samples.
+- [Sample User Authentication App (Golang)](/docs/quickstart/samples-redis/) — another Redis-backed app.
+- [Sample Task Creation CRUD App](/docs/quickstart/samples-flask/) — another Flask sample.
+- [Sample Student Data CRUD App](/docs/quickstart/samples-fastapi/) — Python CRUD API.
diff --git a/versioned_docs/version-4.0.0/quickstart/go-fasthttp-postgres.md b/versioned_docs/version-4.0.0/quickstart/go-fasthttp-postgres.md
index 706c3a8096..c2f94998cd 100644
--- a/versioned_docs/version-4.0.0/quickstart/go-fasthttp-postgres.md
+++ b/versioned_docs/version-4.0.0/quickstart/go-fasthttp-postgres.md
@@ -149,3 +149,10 @@ Final thoughts? Dive deeper! Try different API calls, tweak the DB response in t
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible
 
 Happy coding! ✨👩‍💻👨‍💻✨
+
+## Related
+
+- [Sample Golang Apps](/docs/quickstart/golang-filter/) — browse more Go samples.
+- [Sample Product Catalog App (Golang)](/docs/quickstart/samples-mux/) — another Go Postgres app.
+- [Mux MySQL Sample Application](/docs/quickstart/samples-mysql/) — Go with a SQL datastore.
+- [Sample URL Shortener App (Golang)](/docs/quickstart/samples-gin/) — another Go sample.
diff --git a/versioned_docs/version-4.0.0/quickstart/go-gin-redis.md b/versioned_docs/version-4.0.0/quickstart/go-gin-redis.md
index c95f3cbbff..9433640d17 100644
--- a/versioned_docs/version-4.0.0/quickstart/go-gin-redis.md
+++ b/versioned_docs/version-4.0.0/quickstart/go-gin-redis.md
@@ -472,3 +472,10 @@ Final thoughts? Dive deeper! Try different API calls, tweak the DB response in t
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible. 😊🚀
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [Sample Golang Apps](/docs/quickstart/golang-filter/) — browse more Go samples.
+- [Sample Product Catalog App (Golang)](/docs/quickstart/samples-mux/) — another Go sample.
+- [Sample URL Shortener App (Golang)](/docs/quickstart/samples-gin/) — another Gin-based Go app.
+- [Sample Library App (Flask + Redis)](/docs/quickstart/flask-redis/) — another Redis-backed app.
diff --git a/versioned_docs/version-4.0.0/quickstart/go-mux-mysql.md b/versioned_docs/version-4.0.0/quickstart/go-mux-mysql.md
index d8816e42ae..247418238b 100644
--- a/versioned_docs/version-4.0.0/quickstart/go-mux-mysql.md
+++ b/versioned_docs/version-4.0.0/quickstart/go-mux-mysql.md
@@ -249,3 +249,10 @@ We will get output something like this:
 ### Wrapping it up 🎉
 
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible.😊🚀
+
+## Related
+
+- [Sample Golang Apps](/docs/quickstart/golang-filter/) — browse more Go samples.
+- [Sample Product Catalog App (Golang)](/docs/quickstart/samples-mux/) — Mux with Postgres.
+- [Sample CRUD App (Golang)](/docs/quickstart/samples-fasthttp/) — another Go SQL app.
+- [Echo SQL Sample Application](/docs/quickstart/samples-echo/) — another Go SQL sample.
diff --git a/versioned_docs/version-4.0.0/quickstart/go-mux-sql.md b/versioned_docs/version-4.0.0/quickstart/go-mux-sql.md
index c34976dc06..b5b4c0d839 100644
--- a/versioned_docs/version-4.0.0/quickstart/go-mux-sql.md
+++ b/versioned_docs/version-4.0.0/quickstart/go-mux-sql.md
@@ -439,3 +439,10 @@ Final thoughts? Dive deeper! Try different API calls, tweak the DB response in t
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible. 😊🚀
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [Sample Golang Apps](/docs/quickstart/golang-filter/) — browse more Go samples.
+- [Sample CRUD App (Golang)](/docs/quickstart/samples-fasthttp/) — another Go Postgres app.
+- [Mux MySQL Sample Application](/docs/quickstart/samples-mysql/) — Mux with MySQL.
+- [Sample URL Shortener App (Golang)](/docs/quickstart/samples-gin/) — another Go sample.
diff --git a/versioned_docs/version-4.0.0/quickstart/golang-recommendation.md b/versioned_docs/version-4.0.0/quickstart/golang-recommendation.md
index c573b2405d..982b8cb203 100644
--- a/versioned_docs/version-4.0.0/quickstart/golang-recommendation.md
+++ b/versioned_docs/version-4.0.0/quickstart/golang-recommendation.md
@@ -9,3 +9,10 @@ hide_table_of_contents: true
 import QuickStartFilter from '../../../src/components/QuickStartFilter'
 
 <QuickStartFilter defaultLanguage="Go" />
+
+## Related
+
+- [Sample Product Catalog App (Golang)](/docs/quickstart/samples-mux/) — Mux with Postgres.
+- [Sample CRUD App (Golang)](/docs/quickstart/samples-fasthttp/) — FastHttp with Postgres.
+- [Sample User Authentication App (Golang)](/docs/quickstart/samples-redis/) — Gin with Redis.
+- [Sample URL Shortener App (Golang)](/docs/quickstart/samples-gin/) — Gin with MongoDB.
diff --git a/versioned_docs/version-4.0.0/quickstart/java-quickstart-recommendation.md b/versioned_docs/version-4.0.0/quickstart/java-quickstart-recommendation.md
index 82bc844dab..cfff8f1e92 100644
--- a/versioned_docs/version-4.0.0/quickstart/java-quickstart-recommendation.md
+++ b/versioned_docs/version-4.0.0/quickstart/java-quickstart-recommendation.md
@@ -9,3 +9,10 @@ hide_table_of_contents: true
 import QuickStartFilter from '../../../src/components/QuickStartFilter'
 
 <QuickStartFilter defaultLanguage="Java" />
+
+## Related
+
+- [Sample Rest API with Spring-Boot and MongoDB](/docs/quickstart/java-spring-boot-mongo/) — Spring Boot with MongoDB.
+- [Keploy Integration with PetClinic App](/docs/quickstart/pet-clinic/) — Spring Boot with Postgres.
+- [Sample REST API with Spring-Boot and XML](/docs/quickstart/java-spring-boot-xml/) — Spring Boot serving XML.
+- [Java Sample Application](/docs/quickstart/samples-java/) — another Java sample.
diff --git a/versioned_docs/version-4.0.0/quickstart/java-spring-boot-mongo.md b/versioned_docs/version-4.0.0/quickstart/java-spring-boot-mongo.md
index 7e52c0deb7..f465dba6f1 100644
--- a/versioned_docs/version-4.0.0/quickstart/java-spring-boot-mongo.md
+++ b/versioned_docs/version-4.0.0/quickstart/java-spring-boot-mongo.md
@@ -180,3 +180,10 @@ Final thoughts? Dive deeper! Try different API calls, tweak the DB response in t
 ## Wrapping it up 🎉
 
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible. 😊🚀
+
+## Related
+
+- [Sample Java Apps](/docs/quickstart/java-springboot-filter/) — browse more Java samples.
+- [Keploy Integration with PetClinic App](/docs/quickstart/pet-clinic/) — Spring Boot with Postgres.
+- [Sample REST API with Spring-Boot and XML](/docs/quickstart/java-spring-boot-xml/) — Spring Boot serving XML.
+- [Keploy with OpenHospital](/docs/quickstart/openhospital/) — larger Spring Boot app.
diff --git a/versioned_docs/version-4.0.0/quickstart/java-spring-boot-openhospital.md b/versioned_docs/version-4.0.0/quickstart/java-spring-boot-openhospital.md
index 83a78497ba..136888b50a 100644
--- a/versioned_docs/version-4.0.0/quickstart/java-spring-boot-openhospital.md
+++ b/versioned_docs/version-4.0.0/quickstart/java-spring-boot-openhospital.md
@@ -150,3 +150,10 @@ Here `delay` is the time it takes for your application to get started, after whi
 `buildDelay` is the time that it takes for the image to get built. This is useful when you are building the docker image from your docker compose file itself.
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [Sample Java Apps](/docs/quickstart/java-springboot-filter/) — browse more Java samples.
+- [Keploy Integration with PetClinic App](/docs/quickstart/pet-clinic/) — another Spring Boot Postgres app.
+- [Sample Rest API with Spring-Boot and MongoDB](/docs/quickstart/java-spring-boot-mongo/) — Spring Boot with MongoDB.
+- [Sample REST API with Spring-Boot and XML](/docs/quickstart/java-spring-boot-xml/) — Spring Boot serving XML.
diff --git a/versioned_docs/version-4.0.0/quickstart/java-spring-boot-xml.md b/versioned_docs/version-4.0.0/quickstart/java-spring-boot-xml.md
index 4a939ecdcc..b5725efa3b 100644
--- a/versioned_docs/version-4.0.0/quickstart/java-spring-boot-xml.md
+++ b/versioned_docs/version-4.0.0/quickstart/java-spring-boot-xml.md
@@ -170,3 +170,10 @@ After updating `keploy.yml` with the above configuration, rerun your tests, and
 ## Wrapping Up 🎉
 
 Fantastic! You've successfully navigated creating and testing XML APIs with Spring Boot and Keploy. Keep exploring, experimenting, and innovating! If you have any queries, we're here to help!
+
+## Related
+
+- [Sample Java Apps](/docs/quickstart/java-springboot-filter/) — browse more Java samples.
+- [Sample Rest API with Spring-Boot and MongoDB](/docs/quickstart/java-spring-boot-mongo/) — Spring Boot with MongoDB.
+- [Keploy Integration with PetClinic App](/docs/quickstart/pet-clinic/) — Spring Boot with Postgres.
+- [Java Sample Application](/docs/quickstart/samples-java/) — another Java sample.
diff --git a/versioned_docs/version-4.0.0/quickstart/java-spring-postgres.md b/versioned_docs/version-4.0.0/quickstart/java-spring-postgres.md
index f5638750e0..a903ccf4a3 100644
--- a/versioned_docs/version-4.0.0/quickstart/java-spring-postgres.md
+++ b/versioned_docs/version-4.0.0/quickstart/java-spring-postgres.md
@@ -212,3 +212,10 @@ Here `delay` is the time it takes for your application to get started, after whi
 `buildDelay` is the time that it takes for the image to get built. This is useful when you are building the docker image from your docker compose file itself.
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [Sample Java Apps](/docs/quickstart/java-springboot-filter/) — browse more Java samples.
+- [Keploy with OpenHospital](/docs/quickstart/openhospital/) — another Spring Boot Postgres app.
+- [Sample Rest API with Spring-Boot and MongoDB](/docs/quickstart/java-spring-boot-mongo/) — Spring Boot with MongoDB.
+- [Sample REST API with Spring-Boot and XML](/docs/quickstart/java-spring-boot-xml/) — Spring Boot serving XML.
diff --git a/versioned_docs/version-4.0.0/quickstart/javascript-recommendation.md b/versioned_docs/version-4.0.0/quickstart/javascript-recommendation.md
index bad5dc7cdd..8141bf3b18 100644
--- a/versioned_docs/version-4.0.0/quickstart/javascript-recommendation.md
+++ b/versioned_docs/version-4.0.0/quickstart/javascript-recommendation.md
@@ -9,3 +9,10 @@ hide_table_of_contents: true
 import QuickStartFilter from '../../../src/components/QuickStartFilter';
 
 <QuickStartFilter defaultLanguage="JS/TS" />
+
+## Related
+
+- [Node.js Express Mongoose Sample](/docs/quickstart/samples-nodejs/) — Express with MongoDB.
+- [NodeJS - JWT Sample Application](/docs/quickstart/samples-node-jwt/) — Node with JWT and Postgres.
+- [Express + PostgreSQL + Prisma Sample Application](/docs/quickstart/express-postgresql-prisma/) — Express with Prisma and Postgres.
+- [Typescript Sample Application](/docs/quickstart/samples-typescript/) — TypeScript sample app.
diff --git a/versioned_docs/version-4.0.0/quickstart/k8s-proxy-developer-workflow.md b/versioned_docs/version-4.0.0/quickstart/k8s-proxy-developer-workflow.md
index e4040e71a4..a68dad05c7 100644
--- a/versioned_docs/version-4.0.0/quickstart/k8s-proxy-developer-workflow.md
+++ b/versioned_docs/version-4.0.0/quickstart/k8s-proxy-developer-workflow.md
@@ -214,3 +214,9 @@ A typical day with this workflow looks like:
 5. CI replays the branch and either passes or asks for review via the approval gate.
 6. A reviewer approves the test-data diff in the dashboard.
 7. On PR merge, CI runs `keploy cloud branch-merge` and the new test data lands on `main`.
+
+## Related
+
+- [K8s Record Replay](/docs/quickstart/k8s-proxy/) — record and replay in Kubernetes.
+- [Developer + LLM Workflow with Keploy Proxy](/docs/quickstart/k8s-proxy-llm-workflow/) — the same flow driven by an LLM.
+- [E-commerce Microservices](/docs/quickstart/samples-microservices/) — multi-service app to record.
diff --git a/versioned_docs/version-4.0.0/quickstart/k8s-proxy-llm-workflow.md b/versioned_docs/version-4.0.0/quickstart/k8s-proxy-llm-workflow.md
index d46127f42b..872285dcbc 100644
--- a/versioned_docs/version-4.0.0/quickstart/k8s-proxy-llm-workflow.md
+++ b/versioned_docs/version-4.0.0/quickstart/k8s-proxy-llm-workflow.md
@@ -606,3 +606,9 @@ B0 → B1 (`git diff origin/main...HEAD --name-only` surfaces the new route). B2
 Across every scenario, you only ever spoke one of two sentences. You push your code change (and, for Case 1, the agent's app-side edit). CI replays the branch on the PR; merge runs `keploy cloud branch-merge` and the test data lands on main.
 
 For the same flow done manually (CLI / dashboard, no agent), see [Developer Workflow with Keploy Proxy](/docs/quickstart/k8s-proxy-developer-workflow).
+
+## Related
+
+- [K8s Record Replay](/docs/quickstart/k8s-proxy/) — record and replay in Kubernetes.
+- [Developer Workflow with Keploy Proxy](/docs/quickstart/k8s-proxy-developer-workflow/) — the same flow done manually.
+- [E-commerce Microservices](/docs/quickstart/samples-microservices/) — multi-service app to record.
diff --git a/versioned_docs/version-4.0.0/quickstart/k8s-proxy.md b/versioned_docs/version-4.0.0/quickstart/k8s-proxy.md
index e2f35e4693..f1129b871e 100644
--- a/versioned_docs/version-4.0.0/quickstart/k8s-proxy.md
+++ b/versioned_docs/version-4.0.0/quickstart/k8s-proxy.md
@@ -1,7 +1,7 @@
 ---
 id: k8s-proxy
 title: K8s Record Replay
-description: The following sample app to test Keploy integration capabilities using NextJS,Drizzle and Postgres.
+description: Record and replay API tests inside a Kubernetes cluster using the Keploy proxy — capture live traffic and rerun it as tests with no code changes.
 tags:
   - K8s
   - Microservices
@@ -343,3 +343,9 @@ After test generation, you can view the total number of test suites categorized
 In this quickstart, we demonstrated how to use the Keploy Proxy in Kubernetes to record live traffic and generate tests using AI—all without writing manual tests. This is only a quickstart; you can follow the same steps to record real, production-like traffic and generate tests using AI.
 
 Happy Testing with Keploy
+
+## Related
+
+- [Developer Workflow with Keploy Proxy](/docs/quickstart/k8s-proxy-developer-workflow/) — branch, replay, and gate PRs.
+- [Developer + LLM Workflow with Keploy Proxy](/docs/quickstart/k8s-proxy-llm-workflow/) — the same flow driven by an LLM.
+- [E-commerce Microservices](/docs/quickstart/samples-microservices/) — multi-service app to record.
diff --git a/versioned_docs/version-4.0.0/quickstart/nextjs-postgres.md b/versioned_docs/version-4.0.0/quickstart/nextjs-postgres.md
index 202dd1f8a9..ff57f65c57 100644
--- a/versioned_docs/version-4.0.0/quickstart/nextjs-postgres.md
+++ b/versioned_docs/version-4.0.0/quickstart/nextjs-postgres.md
@@ -138,3 +138,10 @@ Final thoughts? Dive deeper! Try different API calls, tweak the DB response in t
 ### Wrapping it up 🎉
 
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible. 😊🚀
+
+## Related
+
+- [Sample JavaScript Apps](/docs/quickstart/javascript-filter/) — browse more JS samples.
+- [Express + PostgreSQL + Prisma Sample Application](/docs/quickstart/express-postgresql-prisma/) — another Postgres JS app.
+- [NodeJS - JWT Sample Application](/docs/quickstart/samples-node-jwt/) — Node app on Postgres.
+- [Node.js Express Mongoose Sample](/docs/quickstart/samples-nodejs/) — another Node.js sample.
diff --git a/versioned_docs/version-4.0.0/quickstart/node-express-mongoose.md b/versioned_docs/version-4.0.0/quickstart/node-express-mongoose.md
index 2d514a86ca..7a0a426b2d 100644
--- a/versioned_docs/version-4.0.0/quickstart/node-express-mongoose.md
+++ b/versioned_docs/version-4.0.0/quickstart/node-express-mongoose.md
@@ -253,3 +253,10 @@ output should look like
 ### Wrapping it up 🎉
 
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible.😊🚀
+
+## Related
+
+- [Sample JavaScript Apps](/docs/quickstart/javascript-filter/) — browse more JS samples.
+- [Node.js MongoDB Sample](/docs/quickstart/crud-nodejs/) — another Node MongoDB app.
+- [sample course selling api (express)](/docs/quickstart/express-mongoose-application/) — Express with Mongoose.
+- [NodeJS - JWT Sample Application](/docs/quickstart/samples-node-jwt/) — another Node.js sample.
diff --git a/versioned_docs/version-4.0.0/quickstart/node-jwt-sql.md b/versioned_docs/version-4.0.0/quickstart/node-jwt-sql.md
index 0a5f923cbf..64dca412d5 100644
--- a/versioned_docs/version-4.0.0/quickstart/node-jwt-sql.md
+++ b/versioned_docs/version-4.0.0/quickstart/node-jwt-sql.md
@@ -395,3 +395,10 @@ But wait — one test is still failing due to the time-freezing. To try out the
 ### Wrapping it up 🎉
 
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible.😊🚀
+
+## Related
+
+- [Sample JavaScript Apps](/docs/quickstart/javascript-filter/) — browse more JS samples.
+- [Node.js Express Mongoose Sample](/docs/quickstart/samples-nodejs/) — another Node.js sample.
+- [Express + PostgreSQL + Prisma Sample Application](/docs/quickstart/express-postgresql-prisma/) — another Postgres JS app.
+- [NextJs Sample Application](/docs/quickstart/samples-nextjs/) — NextJS app on Postgres.
diff --git a/versioned_docs/version-4.0.0/quickstart/python-django-sql.md b/versioned_docs/version-4.0.0/quickstart/python-django-sql.md
index aab8688381..c1a98f7189 100644
--- a/versioned_docs/version-4.0.0/quickstart/python-django-sql.md
+++ b/versioned_docs/version-4.0.0/quickstart/python-django-sql.md
@@ -499,3 +499,10 @@ Final thoughts? Dive deeper! Try different API calls, tweak the DB response in t
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible. 😊🚀
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [Sample Python Apps](/docs/quickstart/python-filter/) — Browse more Python Keploy samples.
+- [Sample Student Data CRUD App](/docs/quickstart/samples-fastapi/) — Another Python SQL CRUD app.
+- [Sample Task Creation CRUD App](/docs/quickstart/samples-flask/) — Python Flask CRUD sample.
+- [Sample SMS Sending App](/docs/quickstart/samples-fastapi-twilio/) — Python FastAPI external API sample.
diff --git a/versioned_docs/version-4.0.0/quickstart/python-fastapi-sql.md b/versioned_docs/version-4.0.0/quickstart/python-fastapi-sql.md
index c3d8dedcab..11d34f3941 100644
--- a/versioned_docs/version-4.0.0/quickstart/python-fastapi-sql.md
+++ b/versioned_docs/version-4.0.0/quickstart/python-fastapi-sql.md
@@ -426,3 +426,10 @@ Final thoughts? Dive deeper! Try different API calls, tweak the DB response in t
 ### Wrapping it up 🎉
 
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible. 😊🚀
+
+## Related
+
+- [Sample Python Apps](/docs/quickstart/python-filter/) — Browse more Python Keploy samples.
+- [Sample User Data CRUD App (Django)](/docs/quickstart/samples-django/) — Another Python SQL CRUD app.
+- [Sample Task Creation CRUD App](/docs/quickstart/samples-flask/) — Python Flask CRUD sample.
+- [Sample SMS Sending App](/docs/quickstart/samples-fastapi-twilio/) — FastAPI with external API integration.
diff --git a/versioned_docs/version-4.0.0/quickstart/python-fastapi-twilio.md b/versioned_docs/version-4.0.0/quickstart/python-fastapi-twilio.md
index af0711f532..594359ef5d 100644
--- a/versioned_docs/version-4.0.0/quickstart/python-fastapi-twilio.md
+++ b/versioned_docs/version-4.0.0/quickstart/python-fastapi-twilio.md
@@ -474,3 +474,10 @@ Final thoughts? Dive deeper! Try different API calls, tweak the Twilio response
 ### Wrapping it up 🎉
 
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible. 😊🚀
+
+## Related
+
+- [Sample Python Apps](/docs/quickstart/python-filter/) — Browse more Python Keploy samples.
+- [Sample Student Data CRUD App](/docs/quickstart/samples-fastapi/) — Another FastAPI sample app.
+- [Sample Task Creation CRUD App](/docs/quickstart/samples-flask/) — Python Flask CRUD sample.
+- [Sample User Data CRUD App (Django)](/docs/quickstart/samples-django/) — Python Django CRUD sample.
diff --git a/versioned_docs/version-4.0.0/quickstart/python-flask-mongo.md b/versioned_docs/version-4.0.0/quickstart/python-flask-mongo.md
index 64dc2729a0..1a9133719e 100644
--- a/versioned_docs/version-4.0.0/quickstart/python-flask-mongo.md
+++ b/versioned_docs/version-4.0.0/quickstart/python-flask-mongo.md
@@ -233,3 +233,10 @@ python3 -m coverage html
 ## Wrapping it up 🎉
 
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible.😊🚀
+
+## Related
+
+- [Sample Python Apps](/docs/quickstart/python-filter/) — Browse more Python Keploy samples.
+- [Sample Student Data CRUD App](/docs/quickstart/samples-fastapi/) — Python FastAPI CRUD sample.
+- [Sample User Data CRUD App (Django)](/docs/quickstart/samples-django/) — Python Django CRUD sample.
+- [Sample Movie API with Sanic and MongoDB](/docs/quickstart/sanic-mongo/) — Another Python MongoDB app.
diff --git a/versioned_docs/version-4.0.0/quickstart/python-microservices.md b/versioned_docs/version-4.0.0/quickstart/python-microservices.md
index 156c8f9503..07027d5c64 100644
--- a/versioned_docs/version-4.0.0/quickstart/python-microservices.md
+++ b/versioned_docs/version-4.0.0/quickstart/python-microservices.md
@@ -2406,18 +2406,18 @@ code={`
 # Create an order
 
 curl --request POST \
- --url http://localhost:8080/api/v1/orders \
- --header 'Connection: keep-alive' \
- --header 'Idempotency-Key: f0f86385-1d98-438c-b5a0-2b70385a4f8e' \
- --header 'User-Agent: PostmanRuntime/7.49.1' \
- --header 'Postman-Token: 24ef30da-b00d-46d6-ba1b-93578987e51a' \
- --header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY*2cQ' \
- --header 'Accept: */\_' \
- --header 'Cache-Control: no-cache' \
- --header 'Host: localhost:8080' \
- --header 'Content-Type: application/json' \
- --header 'Accept-Encoding: gzip, deflate, br' \
- --data '{
+--url http://localhost:8080/api/v1/orders \
+--header 'Connection: keep-alive' \
+--header 'Idempotency-Key: f0f86385-1d98-438c-b5a0-2b70385a4f8e' \
+--header 'User-Agent: PostmanRuntime/7.49.1' \
+--header 'Postman-Token: 24ef30da-b00d-46d6-ba1b-93578987e51a' \
+--header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY*2cQ' \
+--header 'Accept: */\_' \
+--header 'Cache-Control: no-cache' \
+--header 'Host: localhost:8080' \
+--header 'Content-Type: application/json' \
+--header 'Accept-Encoding: gzip, deflate, br' \
+--data '{
 "userId": "6b6c9d87-92b0-4007-87ce-6356699648a8",
 "items": [
 {
@@ -2431,70 +2431,70 @@ curl --request POST \
 # Get last order
 
 curl --request GET \
- --url http://localhost:8080/api/v1/orders/%7B%7Blast*order_id%7D%7D \
- --header 'Accept-Encoding: gzip, deflate, br' \
- --header 'Connection: keep-alive' \
- --header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY_2cQ' \
- --header 'User-Agent: PostmanRuntime/7.49.1' \
- --header 'Accept: */\_' \
- --header 'Cache-Control: no-cache' \
- --header 'Postman-Token: 6109e22b-dfb5-4394-b74e-5d0e8ce5466e' \
- --header 'Host: localhost:8080'
+--url http://localhost:8080/api/v1/orders/%7B%7Blast*order_id%7D%7D \
+--header 'Accept-Encoding: gzip, deflate, br' \
+--header 'Connection: keep-alive' \
+--header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY_2cQ' \
+--header 'User-Agent: PostmanRuntime/7.49.1' \
+--header 'Accept: */\_' \
+--header 'Cache-Control: no-cache' \
+--header 'Postman-Token: 6109e22b-dfb5-4394-b74e-5d0e8ce5466e' \
+--header 'Host: localhost:8080'
 
 # Get last order (alternate call)
 
 curl --request GET \
- --url http://localhost:8080/api/v1/orders/%7B%7Blast*order_id%7D%7D \
- --header 'User-Agent: PostmanRuntime/7.49.1' \
- --header 'Accept: */\_' \
- --header 'Cache-Control: no-cache' \
- --header 'Postman-Token: 0f9a2f3e-6248-404a-adbf-74fcb9c68ff7' \
- --header 'Host: localhost:8080' \
- --header 'Accept-Encoding: gzip, deflate, br' \
- --header 'Connection: keep-alive' \
- --header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY_2cQ'
+--url http://localhost:8080/api/v1/orders/%7B%7Blast*order_id%7D%7D \
+--header 'User-Agent: PostmanRuntime/7.49.1' \
+--header 'Accept: */\_' \
+--header 'Cache-Control: no-cache' \
+--header 'Postman-Token: 0f9a2f3e-6248-404a-adbf-74fcb9c68ff7' \
+--header 'Host: localhost:8080' \
+--header 'Accept-Encoding: gzip, deflate, br' \
+--header 'Connection: keep-alive' \
+--header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY_2cQ'
 
 # Get order details
 
 curl --request GET \
- --url http://localhost:8080/api/v1/orders/%7B%7Blast*order_id%7D%7D/details \
- --header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY_2cQ' \
- --header 'User-Agent: PostmanRuntime/7.49.1' \
- --header 'Accept: */\_' \
- --header 'Cache-Control: no-cache' \
- --header 'Postman-Token: 3b8a7f27-4ada-4486-b27c-845d6a874763' \
- --header 'Host: localhost:8080' \
- --header 'Accept-Encoding: gzip, deflate, br' \
- --header 'Connection: keep-alive'
+--url http://localhost:8080/api/v1/orders/%7B%7Blast*order_id%7D%7D/details \
+--header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY_2cQ' \
+--header 'User-Agent: PostmanRuntime/7.49.1' \
+--header 'Accept: */\_' \
+--header 'Cache-Control: no-cache' \
+--header 'Postman-Token: 3b8a7f27-4ada-4486-b27c-845d6a874763' \
+--header 'Host: localhost:8080' \
+--header 'Accept-Encoding: gzip, deflate, br' \
+--header 'Connection: keep-alive'
 
 # Cancel an order
 
 curl --request POST \
- --url http://localhost:8080/api/v1/orders/%7B%7Blast*order_id%7D%7D/cancel \
- --header 'Accept: */\_' \
- --header 'Postman-Token: 9743c0e3-7b2b-4909-818d-6fe73311bc24' \
- --header 'Accept-Encoding: gzip, deflate, br' \
- --header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY_2cQ' \
- --header 'Host: localhost:8080' \
- --header 'Connection: keep-alive' \
- --header 'User-Agent: PostmanRuntime/7.49.1' \
- --header 'Cache-Control: no-cache'
+--url http://localhost:8080/api/v1/orders/%7B%7Blast*order_id%7D%7D/cancel \
+--header 'Accept: */\_' \
+--header 'Postman-Token: 9743c0e3-7b2b-4909-818d-6fe73311bc24' \
+--header 'Accept-Encoding: gzip, deflate, br' \
+--header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY_2cQ' \
+--header 'Host: localhost:8080' \
+--header 'Connection: keep-alive' \
+--header 'User-Agent: PostmanRuntime/7.49.1' \
+--header 'Cache-Control: no-cache'
 
 # Create another order with new idempotency key
 
 curl --request POST \
- --url http://localhost:8080/api/v1/orders \
- --header 'Host: localhost:8080' \
- --header 'Accept-Encoding: gzip, deflate, br' \
- --header 'Accept: _/_' \
- --header 'User-Agent: PostmanRuntime/7.49.1' \
- --header 'Content-Type: application/json' \
- --header 'Postman-Token: d494c3c8-8c24-437f-8ed7-f0d1527bf989' \
- --header 'Idempotency-Key: 2fb62e17-8ace-4528-ab51-0e7cf025237a' \
- --header 'Connection: keep-alive' \
- --header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY_2cQ' \
- --header 'Cache-Control: no-cache' \
- --data '{
+--url http://localhost:8080/api/v1/orders \
+--header 'Host: localhost:8080' \
+--header 'Accept-Encoding: gzip, deflate, br' \
+--header 'Accept: _/_' \
+--header 'User-Agent: PostmanRuntime/7.49.1' \
+--header 'Content-Type: application/json' \
+--header 'Postman-Token: d494c3c8-8c24-437f-8ed7-f0d1527bf989' \
+--header 'Idempotency-Key: 2fb62e17-8ace-4528-ab51-0e7cf025237a' \
+--header 'Connection: keep-alive' \
+--header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY_2cQ' \
+--header 'Cache-Control: no-cache' \
+--data '{
 "userId": "6b6c9d87-92b0-4007-87ce-6356699648a8",
 "items": [
 {
@@ -2508,28 +2508,28 @@ curl --request POST \
 # Pay for an order
 
 curl --request POST \
- --url http://localhost:8080/api/v1/orders/%7B%7Blast*order_id%7D%7D/pay \
- --header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY_2cQ' \
- --header 'Accept: */\_' \
- --header 'Postman-Token: 1925ffdf-3aa4-41a3-8b5a-9a7a56c96932' \
- --header 'Accept-Encoding: gzip, deflate, br' \
- --header 'Connection: keep-alive' \
- --header 'Host: localhost:8080' \
- --header 'User-Agent: PostmanRuntime/7.49.1' \
- --header 'Cache-Control: no-cache'
+--url http://localhost:8080/api/v1/orders/%7B%7Blast*order_id%7D%7D/pay \
+--header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY_2cQ' \
+--header 'Accept: */\_' \
+--header 'Postman-Token: 1925ffdf-3aa4-41a3-8b5a-9a7a56c96932' \
+--header 'Accept-Encoding: gzip, deflate, br' \
+--header 'Connection: keep-alive' \
+--header 'Host: localhost:8080' \
+--header 'User-Agent: PostmanRuntime/7.49.1' \
+--header 'Cache-Control: no-cache'
 
 # Get all orders for a user
 
 curl --request GET \
- --url 'http://localhost:8080/api/v1/orders?userId=6b6c9d87-92b0-4007-87ce-6356699648a8' \
- --header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY*2cQ' \
- --header 'User-Agent: PostmanRuntime/7.49.1' \
- --header 'Accept: */\_' \
- --header 'Cache-Control: no-cache' \
- --header 'Postman-Token: 4a3c9621-52ef-48f8-8a9e-01acff2353b0' \
- --header 'Host: localhost:8080' \
- --header 'Accept-Encoding: gzip, deflate, br' \
- --header 'Connection: keep-alive'
+--url 'http://localhost:8080/api/v1/orders?userId=6b6c9d87-92b0-4007-87ce-6356699648a8' \
+--header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmMzEwNzA0NC1iYjA1LTExZjAtYTZlMi1hZWVmN2RjNDBlNjYiLCJ1c2VybmFtZSI6ImFkbWluIiwiaWF0IjoxNzYyNTAwNzMzLCJleHAiOjE3NjUwOTI3MzN9.pZejD-sAGDMXW9cgGYnS9ReqG-TXFFFnyQZeMMY*2cQ' \
+--header 'User-Agent: PostmanRuntime/7.49.1' \
+--header 'Accept: */\_' \
+--header 'Cache-Control: no-cache' \
+--header 'Postman-Token: 4a3c9621-52ef-48f8-8a9e-01acff2353b0' \
+--header 'Host: localhost:8080' \
+--header 'Accept-Encoding: gzip, deflate, br' \
+--header 'Connection: keep-alive'
 `
 }
 />
@@ -2827,3 +2827,10 @@ _Also Paste the OpenAPI schema into the Schema Document section. Once completed,
 ## Conclusion 🎉
 
 Well done! You’ve seen how Keploy helps test your microservices without writing any code. You've generated test cases, run tests, and checked coverage—all with just a few steps.
+
+## Related
+
+- [Sample Python Apps](/docs/quickstart/python-filter/) — Browse more Python Keploy samples.
+- [Sample Student Data CRUD App](/docs/quickstart/samples-fastapi/) — Python FastAPI CRUD sample.
+- [Sample Task Creation CRUD App](/docs/quickstart/samples-flask/) — Python Flask CRUD sample.
+- [Sample User Data CRUD App (Django)](/docs/quickstart/samples-django/) — Python Django CRUD sample.
diff --git a/versioned_docs/version-4.0.0/quickstart/python-quickstart-recommendation.md b/versioned_docs/version-4.0.0/quickstart/python-quickstart-recommendation.md
index d0f5a0db33..2f4533c1d8 100644
--- a/versioned_docs/version-4.0.0/quickstart/python-quickstart-recommendation.md
+++ b/versioned_docs/version-4.0.0/quickstart/python-quickstart-recommendation.md
@@ -9,3 +9,10 @@ hide_table_of_contents: true
 import QuickStartFilter from '../../../src/components/QuickStartFilter'
 
 <QuickStartFilter defaultLanguage="Python" />
+
+## Related
+
+- [Sample Student Data CRUD App](/docs/quickstart/samples-fastapi/) — Python FastAPI CRUD sample.
+- [Sample Task Creation CRUD App](/docs/quickstart/samples-flask/) — Python Flask CRUD sample.
+- [Sample User Data CRUD App (Django)](/docs/quickstart/samples-django/) — Python Django CRUD sample.
+- [Sample Movie API with Sanic and MongoDB](/docs/quickstart/sanic-mongo/) — Python Sanic with MongoDB.
diff --git a/versioned_docs/version-4.0.0/quickstart/rust-recommendation.md b/versioned_docs/version-4.0.0/quickstart/rust-recommendation.md
index 75b38327ae..b5dcbd6030 100644
--- a/versioned_docs/version-4.0.0/quickstart/rust-recommendation.md
+++ b/versioned_docs/version-4.0.0/quickstart/rust-recommendation.md
@@ -9,3 +9,9 @@ hide_table_of_contents: true
 import QuickStartFilter from '../../../src/components/QuickStartFilter'
 
 <QuickStartFilter defaultLanguage="Rust" />
+
+## Related
+
+- [GraphQL Application with MongoDB](/docs/quickstart/samples-rust/) — a full Rust sample app.
+- [CRUD REST API with MongoDB](/docs/quickstart/sample-rust-crud-mongo/) — Rust CRUD sample.
+- [Rust Sample Application](/docs/quickstart/samples-rust-wrap/) — Rust wrap-mode sample.
diff --git a/versioned_docs/version-4.0.0/quickstart/rust-wrap-mongo.md b/versioned_docs/version-4.0.0/quickstart/rust-wrap-mongo.md
index 7a8436c335..2f8ba2c6dc 100644
--- a/versioned_docs/version-4.0.0/quickstart/rust-wrap-mongo.md
+++ b/versioned_docs/version-4.0.0/quickstart/rust-wrap-mongo.md
@@ -134,3 +134,9 @@ sudo -E env PATH=$PATH keploy test -c 'cargo run'
 _Voila!! Our testcases has passed 🌟_
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [GraphQL Application with MongoDB](/docs/quickstart/samples-rust/) — another Rust + MongoDB sample.
+- [CRUD REST API with MongoDB](/docs/quickstart/sample-rust-crud-mongo/) — Rust CRUD walkthrough.
+- [Sample Rust Apps](/docs/quickstart/rust-filter/) — browse all Rust quickstarts.
diff --git a/versioned_docs/version-4.0.0/quickstart/sample-apps.md b/versioned_docs/version-4.0.0/quickstart/sample-apps.md
index 0decb47220..e69a9e2b98 100644
--- a/versioned_docs/version-4.0.0/quickstart/sample-apps.md
+++ b/versioned_docs/version-4.0.0/quickstart/sample-apps.md
@@ -16,3 +16,9 @@ import QuickStartFilter from '../../../src/components/QuickStartFilter'
 Find the right quickstart for your project 👇
 
 <QuickStartFilter />
+
+## Related
+
+- [Sample Golang Apps](/docs/quickstart/golang-filter/) — Go quickstarts.
+- [Sample Python Apps](/docs/quickstart/python-filter/) — Python quickstarts.
+- [Sample JavaScript Apps](/docs/quickstart/javascript-filter/) — JavaScript quickstarts.
diff --git a/versioned_docs/version-4.0.0/quickstart/sample-rust-crud-mongo.md b/versioned_docs/version-4.0.0/quickstart/sample-rust-crud-mongo.md
index 94525358f0..eaeca51aad 100644
--- a/versioned_docs/version-4.0.0/quickstart/sample-rust-crud-mongo.md
+++ b/versioned_docs/version-4.0.0/quickstart/sample-rust-crud-mongo.md
@@ -138,3 +138,9 @@ We get the following output in the terminal -
 
 ![TestRun](/img/rust-mongo-rest-test-run-2.png?raw=true)
 _Voila!! Our testcases has passed 🌟_
+
+## Related
+
+- [GraphQL Application with MongoDB](/docs/quickstart/samples-rust/) — another Rust + MongoDB sample.
+- [Rust Sample Application](/docs/quickstart/samples-rust-wrap/) — Rust wrap-mode sample.
+- [Sample Rust Apps](/docs/quickstart/rust-filter/) — browse all Rust quickstarts.
diff --git a/versioned_docs/version-4.0.0/quickstart/sample-ts.md b/versioned_docs/version-4.0.0/quickstart/sample-ts.md
index 75c466ce78..a8d4980fa9 100644
--- a/versioned_docs/version-4.0.0/quickstart/sample-ts.md
+++ b/versioned_docs/version-4.0.0/quickstart/sample-ts.md
@@ -336,3 +336,9 @@ This is what your response should look like!
 🎉 **Congratulations on Reaching This Milestone!** 🎉
 
 You've successfully tested the tool and created your mocks and test cases—fantastic work! Now that you've laid a solid foundation, it's time to elevate your achievements even further.
+
+## Related
+
+- [Node.js Express Mongoose Sample](/docs/quickstart/samples-nodejs/) — a related Node/JS sample.
+- [BunJS Sample Application](/docs/quickstart/samples-bunjs/) — TypeScript-friendly Bun runtime.
+- [Sample JavaScript Apps](/docs/quickstart/javascript-filter/) — browse all JS/TS quickstarts.
diff --git a/versioned_docs/version-4.0.0/quickstart/samples-bunjs.md b/versioned_docs/version-4.0.0/quickstart/samples-bunjs.md
index 1863a99fcd..017a985607 100644
--- a/versioned_docs/version-4.0.0/quickstart/samples-bunjs.md
+++ b/versioned_docs/version-4.0.0/quickstart/samples-bunjs.md
@@ -402,3 +402,9 @@ Final thoughts? Dive deeper! Try different API calls, tweak the DB response in t
 ### Wrapping it up 🎉
 
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible. 😊🚀
+
+## Related
+
+- [Typescript Sample Application](/docs/quickstart/samples-typescript/) — TypeScript on Node.
+- [Node.js Express Mongoose Sample](/docs/quickstart/samples-nodejs/) — Node/Express counterpart.
+- [Sample JavaScript Apps](/docs/quickstart/javascript-filter/) — browse all JS/TS quickstarts.
diff --git a/versioned_docs/version-4.0.0/quickstart/samples-echo.md b/versioned_docs/version-4.0.0/quickstart/samples-echo.md
index 40076e4cf2..44f7558601 100644
--- a/versioned_docs/version-4.0.0/quickstart/samples-echo.md
+++ b/versioned_docs/version-4.0.0/quickstart/samples-echo.md
@@ -55,7 +55,7 @@ text: "Run keploy test -c \"CMD_TO_RUN_APP\" --delay 10 to replay the recorded t
 import InstallReminder from '@site/src/components/InstallReminder';
 import SectionDivider from '@site/src/components/SectionDivider';
 
-# Using Docker Compose 🐳
+## Using Docker Compose 🐳
 
 import ProductTier from '@site/src/components/ProductTier';
 
@@ -150,7 +150,7 @@ Happy coding! ✨👩‍💻👨‍💻✨
 
 ---
 
-# Running App Locally on Linux/WSL 🐧
+## Running App Locally on Linux/WSL 🐧
 
 <ProductTier tiers="Open Source, Enterprise" offerings="Self-Hosted, Dedicated" />
 
@@ -243,3 +243,9 @@ We will get output something like this:
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible.😊🚀
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [Sample Product Catalog App (Golang)](/docs/quickstart/samples-mux/) — another Go sample.
+- [Mux MySQL Sample Application](/docs/quickstart/samples-mysql/) — Go + MySQL sample.
+- [Sample Golang Apps](/docs/quickstart/golang-filter/) — browse all Go quickstarts.
diff --git a/versioned_docs/version-4.0.0/quickstart/samples-express-mongoose.md b/versioned_docs/version-4.0.0/quickstart/samples-express-mongoose.md
index 4fee34a98f..9e04ddbc5a 100644
--- a/versioned_docs/version-4.0.0/quickstart/samples-express-mongoose.md
+++ b/versioned_docs/version-4.0.0/quickstart/samples-express-mongoose.md
@@ -310,3 +310,9 @@ npm run coverage
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible.😊🚀
 
 Happy coding! ✨👩‍💻👨‍💻✨
+
+## Related
+
+- [Node.js MongoDB Sample](/docs/quickstart/crud-nodejs/) — Node + MongoDB CRUD.
+- [Node.js Express Mongoose Sample](/docs/quickstart/samples-nodejs/) — closely related Express app.
+- [Sample JavaScript Apps](/docs/quickstart/javascript-filter/) — browse all JS quickstarts.
diff --git a/versioned_docs/version-4.0.0/quickstart/samples-go-gin-mongo.md b/versioned_docs/version-4.0.0/quickstart/samples-go-gin-mongo.md
index b78fe94f26..ac6f821f49 100644
--- a/versioned_docs/version-4.0.0/quickstart/samples-go-gin-mongo.md
+++ b/versioned_docs/version-4.0.0/quickstart/samples-go-gin-mongo.md
@@ -434,3 +434,9 @@ Final thoughts? Dive deeper! Try different API calls, tweak the DB response in t
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible. 😊🚀
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [Sample User Authentication App (Golang)](/docs/quickstart/samples-redis/) — Go + Redis sample.
+- [Sample Product Catalog App (Golang)](/docs/quickstart/samples-mux/) — Go + SQL sample.
+- [Sample Golang Apps](/docs/quickstart/golang-filter/) — browse all Go quickstarts.
diff --git a/versioned_docs/version-4.0.0/quickstart/samples-go-sse-svelte.md b/versioned_docs/version-4.0.0/quickstart/samples-go-sse-svelte.md
index 1b21888e2c..033c0efbc1 100644
--- a/versioned_docs/version-4.0.0/quickstart/samples-go-sse-svelte.md
+++ b/versioned_docs/version-4.0.0/quickstart/samples-go-sse-svelte.md
@@ -124,3 +124,9 @@ Output should look like : -
 ![Testrun](https://github.com/keploy/samples-go/raw/main/sse-svelte/img/testrun.png?raw=true)
 
 So no need to setup fake database/apis like Postgres or write mocks for them. Keploy automatically mocks them and, **The application thinks it's talking to MongoDb 😄**. And with just few clicks we were able to get 42% code coverage of our go backend application.
+
+## Related
+
+- [Sample URL Shortener App (Golang)](/docs/quickstart/samples-gin/) — another Go + Gin sample.
+- [Sample Product Catalog App (Golang)](/docs/quickstart/samples-mux/) — Go + SQL sample.
+- [Sample Golang Apps](/docs/quickstart/golang-filter/) — browse all Go quickstarts.
diff --git a/versioned_docs/version-4.0.0/quickstart/samples-java.md b/versioned_docs/version-4.0.0/quickstart/samples-java.md
index 178f316a2d..5c01fdab84 100644
--- a/versioned_docs/version-4.0.0/quickstart/samples-java.md
+++ b/versioned_docs/version-4.0.0/quickstart/samples-java.md
@@ -338,3 +338,9 @@ Here `delay` is the time it takes for your application to get started, after whi
 ### 🎉 Wrapping it up
 
 Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible. 😊🚀
+
+## Related
+
+- [Sample Rest API with Spring-Boot and MongoDB](/docs/quickstart/java-spring-boot-mongo/) — Spring Boot + Mongo.
+- [Sample REST API with Spring-Boot and XML](/docs/quickstart/java-spring-boot-xml/) — Spring Boot + XML.
+- [Sample Java Apps](/docs/quickstart/java-springboot-filter/) — browse all Java quickstarts.
diff --git a/versioned_docs/version-4.0.0/quickstart/samples-node-mongo.md b/versioned_docs/version-4.0.0/quickstart/samples-node-mongo.md
index 5cd4f87ac3..76d57f8c81 100644
--- a/versioned_docs/version-4.0.0/quickstart/samples-node-mongo.md
+++ b/versioned_docs/version-4.0.0/quickstart/samples-node-mongo.md
@@ -295,3 +295,9 @@ npm run coverage
 Congratulations! You've conquered Keploy and unleashed its power for effortless testing in your NodeJS application. With Jest by your side, you can ensure rock-solid code coverage. Time to go forth and build amazing things! 🧑🏻‍💻
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [Node.js Express Mongoose Sample](/docs/quickstart/samples-nodejs/) — Express + Mongoose variant.
+- [sample course selling api (express)](/docs/quickstart/express-mongoose-application/) — another Express + Mongo app.
+- [Sample JavaScript Apps](/docs/quickstart/javascript-filter/) — browse all JS quickstarts.
diff --git a/versioned_docs/version-4.0.0/quickstart/samples-rust.md b/versioned_docs/version-4.0.0/quickstart/samples-rust.md
index 331fa0e3c4..0fcd9a93db 100644
--- a/versioned_docs/version-4.0.0/quickstart/samples-rust.md
+++ b/versioned_docs/version-4.0.0/quickstart/samples-rust.md
@@ -97,3 +97,9 @@ sudo -E env PATH=$PATH keploy test -c 'cargo run'
 _Voila!! Our testcases has passed 🌟_
 
 Hope this helps you out, if you still have any questions, reach out to us .
+
+## Related
+
+- [CRUD REST API with MongoDB](/docs/quickstart/sample-rust-crud-mongo/) — Rust CRUD sample.
+- [Rust Sample Application](/docs/quickstart/samples-rust-wrap/) — Rust wrap-mode sample.
+- [Sample Rust Apps](/docs/quickstart/rust-filter/) — browse all Rust quickstarts.
diff --git a/versioned_docs/version-4.0.0/quickstart/sanic-mongo.md b/versioned_docs/version-4.0.0/quickstart/sanic-mongo.md
index e70c831b38..b70687250e 100644
--- a/versioned_docs/version-4.0.0/quickstart/sanic-mongo.md
+++ b/versioned_docs/version-4.0.0/quickstart/sanic-mongo.md
@@ -196,3 +196,9 @@ This is how your terminal would look like :
 <img src="https://keploy-devrel.s3.us-west-2.amazonaws.com/Keploy-test-sanic-python.png" alt="Sample Keploy Test Sanic Mongo" width="100%" style={{ borderRadius: '5px' }} />
 
 You can experiment with different API calls, modify the database response in mocks.yml, or adjust the request or response in test-x.yml. Then, run the tests again to see the change in response
+
+## Related
+
+- [Sample Student Data CRUD App](/docs/quickstart/samples-fastapi/) — another Python async API.
+- [Sample Task Creation CRUD App](/docs/quickstart/samples-flask/) — Python + Mongo CRUD.
+- [Sample Python Apps](/docs/quickstart/python-filter/) — browse all Python quickstarts.
diff --git a/versioned_docs/version-4.0.0/running-keploy/about-api-testing.md b/versioned_docs/version-4.0.0/running-keploy/about-api-testing.md
index 02f9f7171d..5c14597f7b 100644
--- a/versioned_docs/version-4.0.0/running-keploy/about-api-testing.md
+++ b/versioned_docs/version-4.0.0/running-keploy/about-api-testing.md
@@ -64,3 +64,10 @@ APIs act as the _bridge_ between different software systems — enabling communi
 - Testing across multiple environments (dev, staging, prod)
 - Ensuring version compatibility and backward support
 - Automating complex workflows involving chained API calls
+
+## Related
+
+- [API Test Architecture](/docs/running-keploy/api-test-architecture/) — how Keploy generates API tests.
+- [API Test Generator](/docs/running-keploy/api-test-generator/) — generate API test suites with AI.
+- [What is Unit Testing?](/docs/running-keploy/about-unit-testing/) — compare with unit testing basics.
+- [Best Practices for API testing](/docs/running-keploy/best-practices-api-testing/) — recommended API testing practices.
diff --git a/versioned_docs/version-4.0.0/running-keploy/about-unit-testing.md b/versioned_docs/version-4.0.0/running-keploy/about-unit-testing.md
index 276b7cd72b..45231c3020 100644
--- a/versioned_docs/version-4.0.0/running-keploy/about-unit-testing.md
+++ b/versioned_docs/version-4.0.0/running-keploy/about-unit-testing.md
@@ -34,3 +34,9 @@ Think of it as checking each LEGO brick before building the whole castle.
 - **Flaky Tests:** Unstable tests that sometimes pass, sometimes fail (super annoying).
 - **Coverage Gaps:** Missing tests for edge cases or tricky logic.
 - **Maintenance:** Keeping tests up to date as code evolves.
+
+## Related
+
+- [Unit Test Architecture](/docs/running-keploy/unit-test-architecture/) — how Keploy builds unit tests.
+- [Keploy Unit Test Generator](/docs/running-keploy/unit-test-generator/) — generate unit tests automatically.
+- [What is API testing?](/docs/running-keploy/about-api-testing/) — compare with API testing basics.
diff --git a/versioned_docs/version-4.0.0/running-keploy/agent-test-generation.md b/versioned_docs/version-4.0.0/running-keploy/agent-test-generation.md
index da6496a199..d88c9ac991 100644
--- a/versioned_docs/version-4.0.0/running-keploy/agent-test-generation.md
+++ b/versioned_docs/version-4.0.0/running-keploy/agent-test-generation.md
@@ -430,3 +430,10 @@ When `--spec` is provided, every `run` output includes a `coverage` section:
 The agent reads `next_steps` and generates targeted tests for uncovered endpoints. This loop continues automatically until coverage targets are met.
 
 Without an OpenAPI spec, you can still run tests and sync results. The Keploy platform builds schema coverage progressively from your test execution data over time.
+
+## Related
+
+- [Generate API Tests using AI](/docs/running-keploy/generate-api-tests-using-ai/) — generate API tests with AI.
+- [AI-Powered API Test Generation](/docs/running-keploy/test-generate/) — AI-powered test generation workflow.
+- [Run AI-Generated API Tests](/docs/running-keploy/run-ai-generated-api-tests/) — run the generated tests.
+- [API Test Generator](/docs/running-keploy/api-test-generator/) — how AI test generation works.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-test-architecture.md b/versioned_docs/version-4.0.0/running-keploy/api-test-architecture.md
index 5812922126..fad82a191d 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-test-architecture.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-test-architecture.md
@@ -49,3 +49,10 @@ Keploy needs to interact with your live API endpoints to generate and validate t
 Ready to try it? [app.keploy.io](https://app.keploy.io)
 
 Questions? [Contact our team](mailto:support@keploy.io).
+
+## Related
+
+- [What is API testing?](/docs/running-keploy/about-api-testing/) — understand API testing fundamentals.
+- [API Test Generator](/docs/running-keploy/api-test-generator/) — generate test suites with AI.
+- [Authentication Setup for API Testing](/docs/running-keploy/api-testing-auth-setup/) — configure auth before generation.
+- [Best Practices for API testing](/docs/running-keploy/best-practices-api-testing/) — recommended API testing practices.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-add-suite.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-add-suite.md
index 154a2575f9..23917ab0b3 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-add-suite.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-add-suite.md
@@ -9,6 +9,7 @@ tags:
   - test-suite
   - test-management
 ---
+
 import ProductTier from '@site/src/components/ProductTier';
 
 <ProductTier tiers="Free, Teams, Scale, Enterprise" offerings="Self-Hosted, Dedicated" />
@@ -27,7 +28,7 @@ In this guide, we will walk through the process of adding a test suite in Keploy
      - **Details**: Provide a brief description of the test suite.
      - **Request**: Specify the request details, such as the HTTP method, URL, headers, and body.
      - **Assertions**: Define any Assertions related to the test suite.
-![Add Suite](https://keploy-devrel.s3.us-west-2.amazonaws.com/add-new-suite-1.png)
+       ![Add Suite](https://keploy-devrel.s3.us-west-2.amazonaws.com/add-new-suite-1.png)
 
 3. **Import a Curl Command (Optional)**
    - If you have a curl command, you can directly import it to create the test suite.
@@ -40,6 +41,7 @@ In this guide, we will walk through the process of adding a test suite in Keploy
 ## Example
 
 ### Manual Entry
+
 ```json
 {
   "name": "User Authentication",
@@ -59,10 +61,18 @@ In this guide, we will walk through the process of adding a test suite in Keploy
 ```
 
 ### Importing a Curl Command
+
 ```bash
 curl -X POST https://api.example.com/login \
   -H "Content-Type: application/json" \
   -d '{"username": "test_user", "password": "secure_password"}'
 ```
 
-By following these steps, you can easily create and manage test suites in Keploy.
\ No newline at end of file
+By following these steps, you can easily create and manage test suites in Keploy.
+
+## Related
+
+- [Edit Test Suites](/docs/running-keploy/api-testing-edit-suites/) — edit suites after creating them.
+- [Test Suite Settings & Actions](/docs/running-keploy/api-testing-suite-settings/) — manage suite settings and actions.
+- [Adding Labels to Test Suites](/docs/running-keploy/api-testing-adding-labels/) — organize new suites with labels.
+- [Using Filtering in Test Suites](/docs/running-keploy/api-testing-filter-suites/) — filter across your test suites.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-adding-labels.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-adding-labels.md
index de7c2a91cd..ed8aa6b372 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-adding-labels.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-adding-labels.md
@@ -46,6 +46,7 @@ The labeling system includes:
 When you open the label assignment dialog, you'll see:
 
 ### Existing Labels Section
+
 ```
 🏷️ Available Labels
 ├── 📊 Priority
@@ -77,11 +78,11 @@ When you open the label assignment dialog, you'll see:
    - Follow the steps above to open the label assignment interface
 
 2. **Create New Label**
-   - Click **"Create Custom Label"** 
+   - Click **"Create Custom Label"**
    - Enter label details in the creation form
 
 3. **Label Creation Form**
-    - For Example:
+   - For Example:
    ```
    Label Name: [smoke-critical]
    Color: [🔴] (color picker)
@@ -101,13 +102,14 @@ When you open the label assignment dialog, you'll see:
 ### Naming Conventions
 
 1. **Use Consistent Formatting**
+
    ```
    ✅ Good Examples:
    - team-frontend
    - priority-high
    - env-production
    - type-smoke-test
-   
+
    ❌ Avoid:
    - TeamFrontend
    - HIGH_PRIORITY
@@ -131,4 +133,4 @@ When you open the label assignment dialog, you'll see:
 - **[Test Reports](./api-testing-sharing-reports.md)**: Generate reports filtered by labels
 - **[Custom Assertions](./api-testing-custom-assertions.md)**: Create assertions for labeled suites
 
-Labels are a powerful organizational tool that help you maintain order in large test collections and enable efficient test management workflows.
\ No newline at end of file
+Labels are a powerful organizational tool that help you maintain order in large test collections and enable efficient test management workflows.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-assertion-tree.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-assertion-tree.md
index a89527c4ba..1352fcbfb7 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-assertion-tree.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-assertion-tree.md
@@ -36,21 +36,22 @@ Instead of viewing tests as isolated steps, the Assertion Tree gives you a compl
 3. The system renders the full test suite in a **tree format**
 
 ---
+
 ![Assertion tree](https://keploy-devrel.s3.us-west-2.amazonaws.com/assertion-tree-1.png)
 
 ## What You Can See
 
 The Assertion Tree provides a visual representation of:
 
-- All test steps in execution order  
-- Request details for each step  
-- Attached assertions  
+- All test steps in execution order
+- Request details for each step
+- Attached assertions
 
 Each node in the tree represents a test step and contains:
 
-- Request configuration  
-- Associated assertions  
-- Execution dependencies  
+- Request configuration
+- Associated assertions
+- Execution dependencies
 
 This makes it easier to understand how your test suite behaves as a complete workflow.
 
@@ -59,16 +60,18 @@ This makes it easier to understand how your test suite behaves as a complete wor
 The Assertion Tree is fully interactive. You can:
 
 ### 1. View Complete Flow
+
 Understand the entire API workflow from start to finish without switching between screens.
 
 ### 2. Inspect Assertions Inline
+
 Quickly see which assertions are attached to each step, including:
 
-- Status code validations  
-- JSON validations  
-- Header validations  
-- Schema validations  
-- Custom function validations  
+- Status code validations
+- JSON validations
+- Header validations
+- Schema validations
+- Custom function validations
 
 ### 3. Add a New Step in the Flow
 
@@ -97,11 +100,11 @@ It transforms test management from a flat list into a structured execution graph
 
 ## Typical Use Cases
 
-- Authentication → Resource Creation → Validation → Cleanup flows  
-- Multi-step payment processing validations  
-- E-commerce checkout journeys  
-- Webhook-triggered event testing  
-- Integration testing across services  
+- Authentication → Resource Creation → Validation → Cleanup flows
+- Multi-step payment processing validations
+- E-commerce checkout journeys
+- Webhook-triggered event testing
+- Integration testing across services
 
 ## Best Practices
 
@@ -111,5 +114,11 @@ It transforms test management from a flat list into a structured execution graph
 - Review flow dependencies to avoid unintended execution order
 - Use visualization to debug failing multi-step tests faster
 
-
 The Assertion Tree enables you to design, inspect, and extend complex API workflows with clarity and precision — all from a single visual interface.
+
+## Related
+
+- [Custom Assertions](/docs/running-keploy/api-testing-custom-assertions/) — define validation rules.
+- [Functions & Schema Assertions](/docs/running-keploy/api-testing-functions/) — schema and function assertions.
+- [Editing Test Suites and Custom Assertions](/docs/running-keploy/api-testing-edit-assertions/) — edit assertions in a suite.
+- [Bulk Assertions and Schema Validation](/docs/running-keploy/api-testing-bulk-assertions/) — apply assertions in bulk.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-auth-setup.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-auth-setup.md
index 866e2db577..c925b28f14 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-auth-setup.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-auth-setup.md
@@ -1,8 +1,8 @@
 ---
 id: api-testing-auth-setup
-title: Auth Setup
+title: Authentication Setup for API Testing
 sidebar_label: Auth Setup
-description: Auth setup for API Testing
+description: Configure authentication for Keploy API testing — set up bearer tokens, API keys, and custom auth headers so recorded suites replay against protected endpoints.
 tags:
   - API testing
   - webhooks
@@ -41,3 +41,10 @@ Cookie - Keploy will execute this API and take the cookie from response headers
 ![Keploy](../../../static/img/jwt.png)
 
 This Auth option is for the application which can be authenticated using jwt token. This token is used in all the API calls that are done by Keploy to the application.
+
+## Related
+
+- [Adding New Test Suites](/docs/running-keploy/api-testing-add-suite/) — add suites for protected endpoints.
+- [Using Keploy Local Agent](/docs/running-keploy/api-testing-local-agent/) — test private endpoints locally.
+- [API Test Generator](/docs/running-keploy/api-test-generator/) — generate tests after auth setup.
+- [API Test Recorder (Chrome Extension)](/docs/running-keploy/api-testing-chrome-extension/) — capture authenticated traffic.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-buggy-suites.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-buggy-suites.md
index 31f3289fe4..104423f579 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-buggy-suites.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-buggy-suites.md
@@ -9,6 +9,7 @@ tags:
   - test-failures
   - troubleshooting
 ---
+
 import ProductTier from '@site/src/components/ProductTier';
 
 <ProductTier tiers="Free, Teams, Scale, Enterprise" offerings="Self-Hosted, Dedicated" />
@@ -20,8 +21,8 @@ When Keploy generates tests, some test cases might fail due to various reasons s
 Navigate to the test suites generated with the red exclamation icon to view all test suites that contain failing test cases. Each buggy suite displays:
 
 - **Suite Name**: The name of the test suite containing failed tests
-- **Test Steps**: Steps in the suite 
-- **Failure Reason**: Reason why the test suite is buggy 
+- **Test Steps**: Steps in the suite
+- **Failure Reason**: Reason why the test suite is buggy
 
 ## Understanding Failure Reasons
 
@@ -30,16 +31,19 @@ For each buggy test suite, you can find the detailed explanations of why tests a
 ### 1. Endpoint Not Found (404 Errors)
 
 **Example Failure Reason:**
+
 ```
 The response returned a 404 status code for the 'Create Owner' step, indicating the endpoint '/owners' was not found. This contradicts the documented cURL examples and schema, which show that this endpoint should exist and return a 201 status code upon successful creation.
 ```
 
 **What this means:**
+
 - The API endpoint that was working during recording is no longer available
 - The endpoint URL might have changed
 - The API server might be down or misconfigured
 
 **How to fix:**
+
 1. Verify the endpoint URL is correct
 2. Check if the API server is running
 3. Review API documentation for any endpoint changes
@@ -48,11 +52,13 @@ The response returned a 404 status code for the 'Create Owner' step, indicating
 ### 2. Schema Validation Failures
 
 **Example Failure Reason:**
+
 ```
 Response schema validation failed. Expected property 'id' of type 'number' but received 'string'. The API response structure has changed from the recorded version.
 ```
 
 **What this means:**
+
 - The API response format has changed since recording
 - Data types don't match the expected schema
 - New required fields might have been added
@@ -60,11 +66,13 @@ Response schema validation failed. Expected property 'id' of type 'number' but r
 ### 3. Authentication Issues
 
 **Example Failure Reason:**
+
 ```
 Authentication failed with 401 Unauthorized. The API key or token used during recording may have expired or been revoked.
 ```
 
 **What this means:**
+
 - API credentials have expired or changed
 - Authentication method has been updated
 - Permission levels may have changed
@@ -74,6 +82,7 @@ Authentication failed with 401 Unauthorized. The API key or token used during re
 The buggy suites page provides detailed assertion failure information to help you understand exactly what went wrong:
 
 ### Response Status Assertions
+
 ```yaml
 Expected: 201 Created
 Actual: 404 Not Found
@@ -82,6 +91,7 @@ Message: The endpoint returned an unexpected status code
 ```
 
 ### Response Body Assertions
+
 ```yaml
 Expected: {"id": 123, "name": "John Doe", "email": "john@example.com"}
 Actual: {"error": "User not found", "code": 404}
@@ -94,19 +104,25 @@ Message: Response body structure completely different from expected
 For each buggy test case, you can take several debugging actions:
 
 ### 1. View Full Test Details
+
 Click on any failed test to see:
+
 - Complete request details (URL, headers, body)
 - Full response details (status, headers, body)
 - All assertion results with expected vs actual values
 
 ### 2. Compare with Recorded Version
+
 View the side-by-side comparison between:
+
 - **Original Recording**: The request/response captured during recording
 - **Current Execution**: The actual request/response during test execution
 - **Differences Highlighted**: Visual indicators showing what changed
 
 ### 3. Manual Test Execution
+
 Test the endpoint manually to verify:
+
 ```bash
 # Example manual cURL test
 curl -X POST \
@@ -120,7 +136,9 @@ curl -X POST \
 ```
 
 ### 4. Update Test Expectations
+
 If the API behavior has legitimately changed:
+
 1. **Re-record the test**: Capture new expected behavior
 2. **Update assertions**: Modify expected values to match new API
 3. **Add new test cases**: Cover additional scenarios if needed
@@ -134,4 +152,11 @@ If you're unable to resolve buggy test suites:
 3. **Community Forums**: Ask questions in Keploy community channels
 4. **Share Test Details**: Provide complete test execution logs when seeking help
 
-Remember, buggy test suites often indicate real issues with your API or environment. Use them as an early warning system to maintain API quality and reliability.
\ No newline at end of file
+Remember, buggy test suites often indicate real issues with your API or environment. Use them as an early warning system to maintain API quality and reliability.
+
+## Related
+
+- [Mark Test Suite as Unbuggy](/docs/running-keploy/api-testing-mark-unbuggy/) — mark suites fixed as unbuggy.
+- [Fix with AI](/docs/running-keploy/api-testing-fix-with-ai/) — auto-repair failing suites.
+- [Test Run Reports](/docs/running-keploy/api-testing-run-report/) — review failures in run reports.
+- [Edit Test Suites](/docs/running-keploy/api-testing-edit-suites/) — manually fix suite issues.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-bulk-assertions.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-bulk-assertions.md
index 11300bd9f1..77a655e064 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-bulk-assertions.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-bulk-assertions.md
@@ -26,6 +26,7 @@ Schema assertions allow you to validate the structure and format of API response
 ### 1. Filter Your Test Suites
 
 First, use the filtering options to narrow down the tests you want to assert:
+
 - **Filter by Endpoint**: Select specific API endpoints
 - **Filter by HTTP Method**: Choose methods like GET, POST, PUT, DELETE, etc.
 - **Filter by Status Code**: Filter by response status codes (2xx, 4xx, 5xx, etc.)
@@ -35,6 +36,7 @@ First, use the filtering options to narrow down the tests you want to assert:
 
 Select the configure schema assertions option
 From the entire response body, you can choose which fields to assert:
+
 - **Response Body Fields**: Select individual fields from the JSON response
 - **Data Types**: Ensure fields have correct types (string, number, boolean, etc.)
 - **Required Fields**: Verify that mandatory fields are present
@@ -42,6 +44,7 @@ From the entire response body, you can choose which fields to assert:
 ### 4. Apply Schema Assertions
 
 Schema assertions validate the structure of your API responses:
+
 - **Field Presence**: Ensure required fields exist in the response
 - **Data Type Validation**: Verify that fields have the correct data type
 - **Format Validation**: Check formats like email, URL, date, etc.
@@ -55,6 +58,7 @@ Schema assertions validate the structure of your API responses:
 ## Example Use Cases
 
 ### Example: Asserting User Endpoints
+
 ```
 Filter by:
 - Endpoint: /api/v1/users/*
@@ -67,7 +71,6 @@ Bulk Assert:
 - Email format validation
 ```
 
-
 ## Benefits of Bulk Assertions
 
 - **Time Efficiency**: Apply assertions to multiple tests simultaneously
@@ -82,4 +85,11 @@ Bulk Assert:
 - **Use realistic data**: Test with production-like data for accurate validation
 - **Regular updates**: Update schemas when API contracts change
 
-By leveraging bulk assertions and schema validation, you can ensure comprehensive API testing while minimizing manual effort and maintaining high test coverage across your application.
\ No newline at end of file
+By leveraging bulk assertions and schema validation, you can ensure comprehensive API testing while minimizing manual effort and maintaining high test coverage across your application.
+
+## Related
+
+- [Custom Assertions](/docs/running-keploy/api-testing-custom-assertions/) — define individual assertions.
+- [Functions & Schema Assertions](/docs/running-keploy/api-testing-functions/) — schema and function assertions.
+- [Using Filtering in Test Suites](/docs/running-keploy/api-testing-filter-suites/) — filter suites before asserting.
+- [Assertion Tree](/docs/running-keploy/api-testing-assertion-tree/) — visualize assertion flow.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-chrome-extension.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-chrome-extension.md
index 64c8f8dcba..dac5179d83 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-chrome-extension.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-chrome-extension.md
@@ -94,3 +94,10 @@ Records repaired: 15
 | ------------------------------------------------------------ | -------------------------------------------- | ------------------------------------------------------------------ |
 | `Captured calls` increments, but `Complete req/resp` stays 0 | Responses blocked by CORS or Service Worker. | Click **Debug**, or whitelist the domain in extension permissions. |
 | “Network error” when pressing **Generate Tests**             | Auth token expired.                          | Log out, log back in.                                              |
+
+## Related
+
+- [Using Keploy Local Agent](/docs/running-keploy/api-testing-local-agent/) — alternative for local endpoints.
+- [Adding New Test Suites](/docs/running-keploy/api-testing-add-suite/) — create suites from captured calls.
+- [API Test Generator](/docs/running-keploy/api-test-generator/) — generate tests from traffic.
+- [Authentication Setup for API Testing](/docs/running-keploy/api-testing-auth-setup/) — handle authenticated replay.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-cicd.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-cicd.md
index 7aea265099..4c39abc14c 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-cicd.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-cicd.md
@@ -96,3 +96,10 @@ Failed suites:      0
 ## That's it!
 
 With just a few lines of YAML, you’ve added **AI-powered API test automation** into your GitHub CI pipeline. Now every PR or deployment will be automatically tested with Keploy’s smart test engine.
+
+## Related
+
+- [Test Run Reports](/docs/running-keploy/api-testing-run-report/) — review CI test run reports.
+- [Test Suite Settings & Actions](/docs/running-keploy/api-testing-suite-settings/) — configure run-in-CI settings.
+- [Running Selective Test Suites](/docs/running-keploy/api-testing-running-selective/) — run selected suites in CI.
+- [Sharing Reports](/docs/running-keploy/api-testing-sharing-reports/) — share CI results with team.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-custom-assertions.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-custom-assertions.md
index 7a934d0ecb..8cb325f6cf 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-custom-assertions.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-custom-assertions.md
@@ -15,7 +15,6 @@ keywords:
   - header validation
   - schema validation
   - custom functions
-
 ---
 
 import ProductTier from '@site/src/components/ProductTier';
@@ -26,24 +25,25 @@ Custom assertions allow you to precisely validate API responses beyond basic sta
 
 Keploy supports the following assertion categories:
 
-| Scenario | Recommended Assertion |
-|----------|----------------------|
-| Exact status code validation | Status Code |
-| Accept any success response | Status Code Class |
-| Partial JSON validation | JSON Contains |
-| Strict field validation | JSON Equal |
-| Response structure consistency | Schema |
-| Dynamic value comparison | Custom Function |
-| Validate only important fields | Selected Fields |
-| Security header enforcement | Header Exists / Header Equal |
-
+| Scenario                       | Recommended Assertion        |
+| ------------------------------ | ---------------------------- |
+| Exact status code validation   | Status Code                  |
+| Accept any success response    | Status Code Class            |
+| Partial JSON validation        | JSON Contains                |
+| Strict field validation        | JSON Equal                   |
+| Response structure consistency | Schema                       |
+| Dynamic value comparison       | Custom Function              |
+| Validate only important fields | Selected Fields              |
+| Security header enforcement    | Header Exists / Header Equal |
 
 ## For specific Selected Fields
 
 ### Selected Fields
+
 Allows you to validate only specific parts of a response instead of the entire body.
 
 Useful when:
+
 - Response includes dynamic metadata
 - You want to ignore volatile fields (timestamps, request IDs, etc.)
 - Only certain business-critical fields matter
@@ -53,6 +53,7 @@ Useful when:
 For complex validation logic, Keploy supports custom functions inside assertions.
 
 Custom functions allow you to:
+
 - Write JavaScript expressions
 - Perform conditional validation
 - Compare multiple fields
@@ -60,6 +61,7 @@ Custom functions allow you to:
 - Enforce business rules
 
 ### Example Use Cases
+
 - Validate `totalAmount = sum(lineItems)`
 - Ensure timestamp is within last 5 minutes
 - Compare response field with environment variable
@@ -70,31 +72,33 @@ Custom functions allow you to:
 Consider an e-commerce API that returns order details. You want to validate that the total amount equals the sum of all line items plus tax.
 
 **API Response:**
+
 ```json
 {
   "orderId": "ORD-12345",
   "items": [
-    { "name": "Laptop", "price": 1200.00, "quantity": 1 },
-    { "name": "Mouse", "price": 25.50, "quantity": 2 }
+    {"name": "Laptop", "price": 1200.0, "quantity": 1},
+    {"name": "Mouse", "price": 25.5, "quantity": 2}
   ],
-  "subtotal": 1251.00,
-  "tax": 125.10,
-  "total": 1376.10,
+  "subtotal": 1251.0,
+  "tax": 125.1,
+  "total": 1376.1,
   "timestamp": "2026-02-11T10:30:00Z"
 }
 ```
 
 **Custom Function for Total Validation:**
+
 ```javascript
 // Validate that total = subtotal + tax
 function validateOrderTotal(response) {
   const data = JSON.parse(response.body);
   const expectedTotal = data.subtotal + data.tax;
   const actualTotal = data.total;
-  
+
   return {
     passed: Math.abs(expectedTotal - actualTotal) < 0.01, // Handle floating point precision
-    message: `Expected total ${expectedTotal}, but got ${actualTotal}`
+    message: `Expected total ${expectedTotal}, but got ${actualTotal}`,
   };
 }
 
@@ -102,17 +106,18 @@ function validateOrderTotal(response) {
 function validateSubtotal(response) {
   const data = JSON.parse(response.body);
   const calculatedSubtotal = data.items.reduce((sum, item) => {
-    return sum + (item.price * item.quantity);
+    return sum + item.price * item.quantity;
   }, 0);
-  
+
   return {
     passed: Math.abs(calculatedSubtotal - data.subtotal) < 0.01,
-    message: `Calculated subtotal ${calculatedSubtotal}, but API returned ${data.subtotal}`
+    message: `Calculated subtotal ${calculatedSubtotal}, but API returned ${data.subtotal}`,
   };
 }
 ```
 
 **Usage in Keploy:**
+
 1. Navigate to your test step editor
 2. Add a new assertion
 3. Select "Custom Function" as assertion type
@@ -127,3 +132,10 @@ function validateSubtotal(response) {
 - **Use Custom Functions** for business logic validation
 - **Combine multiple assertions** for stronger test reliability
 - **Keep assertions focused and readable**
+
+## Related
+
+- [Functions & Schema Assertions](/docs/running-keploy/api-testing-functions/) — schema and function assertions.
+- [Bulk Assertions and Schema Validation](/docs/running-keploy/api-testing-bulk-assertions/) — apply assertions in bulk.
+- [Editing Test Suites and Custom Assertions](/docs/running-keploy/api-testing-edit-assertions/) — edit assertions in a suite.
+- [Assertion Tree](/docs/running-keploy/api-testing-assertion-tree/) — visualize assertion flow.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-edit-assertions.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-edit-assertions.md
index 429de14d24..fad4c26c76 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-edit-assertions.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-edit-assertions.md
@@ -29,7 +29,6 @@ Editing a test suite allows you to:
 
 This gives you fine-grained control over how your APIs are validated.
 
-
 ## Accessing Test Suite Edit Mode
 
 ### Step 1: Navigate to Test Suites
@@ -64,10 +63,17 @@ You can:
 - Inject variables into any field
 
 ## Editing Existing Assertions
+
 You can choose from multiple assertion categories:
+
 - Status Code Assertion
 - Header Assertion
 - Body / JSON Path Assertion
 - Schema Assertion
 
+## Related
 
+- [Custom Assertions](/docs/running-keploy/api-testing-custom-assertions/) — define validation rules.
+- [Functions & Schema Assertions](/docs/running-keploy/api-testing-functions/) — schema and function assertions.
+- [Edit Test Suites](/docs/running-keploy/api-testing-edit-suites/) — edit suite request details.
+- [Bulk Assertions and Schema Validation](/docs/running-keploy/api-testing-bulk-assertions/) — apply assertions in bulk.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-edit-suites.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-edit-suites.md
index 9b81c7d130..0e730a03f3 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-edit-suites.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-edit-suites.md
@@ -63,6 +63,7 @@ Keploy supports custom functions for advanced assertion logic. You can:
 - Reference external validation logic
 
 For detailed information on custom functions, [reference here](/versioned_docs/version-4.0.0/running-keploy/api-testing-functions.md).
+
 ### Creating and Using Variables
 
 Variables allow you to create reusable values across your test suite:
@@ -81,3 +82,10 @@ For in detail usage of variables refer here : [Using Variables](/versioned_docs/
 - **Group related tests**: Organize tests logically within suites (e.g., user authentication, payment processing, etc.)
 - **Keep suites focused**: Each test suite should test a specific feature or workflow
 - **Test multiple aspects**: Include assertions for status codes, response structure, and business logic
+
+## Related
+
+- [Adding New Test Suites](/docs/running-keploy/api-testing-add-suite/) — create suites to edit.
+- [Test Suite Settings & Actions](/docs/running-keploy/api-testing-suite-settings/) — manage suite settings.
+- [Editing Test Suites and Custom Assertions](/docs/running-keploy/api-testing-edit-assertions/) — edit assertions and variables.
+- [Using Filtering in Test Suites](/docs/running-keploy/api-testing-filter-suites/) — filter suites while editing.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-filter-suites.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-filter-suites.md
index 3cea7f7dff..727aaf4591 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-filter-suites.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-filter-suites.md
@@ -1,7 +1,7 @@
 ---
 id: api-testing-filter-suites
 title: Using Filtering in Test Suites
-description: Guide to add filters for test suites 
+description: Guide to add filters for test suites
 sidebar_label: Filter Test Suites
 tags:
   - api-testing
@@ -21,11 +21,13 @@ This guide explains how to filter test suites in Keploy to quickly find and mana
 Keploy provides multiple filtering options to help you efficiently locate and organize your test suites:
 
 ### 1. Filter by Test Suite
+
 - Filter test suites by their name or identifier
 - Quickly locate specific test suites from a large collection
 - Use search functionality to find test suites by partial name matching
 
 ### 2. Filter by Status Code
+
 - Filter tests based on HTTP response status codes
 - Common status code filters:
   - **2xx Success**: 200 OK, 201 Created, 204 No Content, etc.
@@ -35,6 +37,7 @@ Keploy provides multiple filtering options to help you efficiently locate and or
 - Useful for identifying failing tests or specific response patterns
 
 ### 3. Filter by HTTP Method
+
 - Filter tests based on the HTTP request method:
   - **GET**: Retrieve data from the server
   - **POST**: Submit data to create new resources
@@ -46,6 +49,7 @@ Keploy provides multiple filtering options to help you efficiently locate and or
 - Helps organize tests by the type of operation being tested
 
 ### 4. Filter by Endpoint
+
 - Filter tests based on the API endpoint or URL path
 - Search by:
   - Full endpoint URL
@@ -62,9 +66,11 @@ Keploy provides multiple filtering options to help you efficiently locate and or
 ## Example Use Cases
 
 ### Finding Failed Tests
+
 ```
 Filter by Status Code: 4xx, 5xx
 ```
+
 This will show all tests that resulted in client or server errors.
 
 ## Benefits of Filtering
@@ -75,4 +81,11 @@ This will show all tests that resulted in client or server errors.
 - **Test Analysis**: Understand patterns in your API behavior
 - **Maintenance**: Easier to update or remove tests for specific endpoints or methods
 
-By using these filtering options, you can efficiently manage and analyze your test suites.
\ No newline at end of file
+By using these filtering options, you can efficiently manage and analyze your test suites.
+
+## Related
+
+- [Adding Labels to Test Suites](/docs/running-keploy/api-testing-adding-labels/) — filter using labels.
+- [Running Selective Test Suites](/docs/running-keploy/api-testing-running-selective/) — run filtered suites.
+- [Test Suite Settings & Actions](/docs/running-keploy/api-testing-suite-settings/) — manage suite settings.
+- [Adding New Test Suites](/docs/running-keploy/api-testing-add-suite/) — add suites to filter.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-fixing-ai.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-fixing-ai.md
index de618d8b79..3c0d76570c 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-fixing-ai.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-fixing-ai.md
@@ -51,6 +51,7 @@ Use this feature when:
 3. Provide instructions describing what needs to be corrected
 
 Example instructions:
+
 - "Normalize dynamic fields like timestamps and request IDs"
 - "Update schema based on latest API response"
 - "Ignore volatile metadata fields"
@@ -66,13 +67,13 @@ Example instructions:
 
 The AI can intelligently update:
 
-- JSON assertions  
-- Schema validations  
-- Header validations  
-- Status code expectations  
-- Dynamic field handling  
-- Selected field configurations  
-- Request payload mismatches  
+- JSON assertions
+- Schema validations
+- Header validations
+- Status code expectations
+- Dynamic field handling
+- Selected field configurations
+- Request payload mismatches
 
 It ensures the suite reflects the current API behavior while preserving intended validation logic.
 
@@ -81,6 +82,7 @@ It ensures the suite reflects the current API behavior while preserving intended
 ## Example Scenario
 
 ### Problem
+
 Your API now returns:
 
 ```json
@@ -96,9 +98,11 @@ Previously, your test expected strict equality including `createdAt`.
 The test fails due to timestamp variance.
 
 ### Instruction to AI
+
 "Normalize dynamic fields like `createdAt` and ignore timestamp differences."
 
 ### Result
+
 AI updates the assertion to:
 
 - Use Schema validation instead of strict equality
@@ -129,4 +133,11 @@ Normalization focuses on making tests stable without reducing meaningful validat
 - **Clearly mention which fields should be ignored or updated**
 - **Review AI-generated changes before finalizing**
 - **Use normalization for dynamic fields, not business logic errors**
-- **Keep critical validations strict**
\ No newline at end of file
+- **Keep critical validations strict**
+
+## Related
+
+- [Buggy Test Suites](/docs/running-keploy/api-testing-buggy-suites/) — identify failing suites.
+- [Mark Test Suite as Unbuggy](/docs/running-keploy/api-testing-mark-unbuggy/) — mark suites fixed as unbuggy.
+- [Self-Healing API Tests](/docs/running-keploy/self-healing-ai-api-tests/) — self-healing test maintenance.
+- [Edit Test Suites](/docs/running-keploy/api-testing-edit-suites/) — manually adjust suites.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-functions.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-functions.md
index 5c0d4066d4..f18ce878ed 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-functions.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-functions.md
@@ -13,29 +13,31 @@ Assertions define the **"Pass/Fail"** criteria for your tests. While standard ch
 - **Custom Functions**: Use these for complex logic that simple matching cannot handle, such as verifying if a timestamp falls within a specific range.
 - **Global Functions**: Repeatable logic can be saved to the Global library for team-wide reuse.
 
-
-
 ## Hands-On: Schema Assertions
 
 ### 1. Selecting Fields to Assert
+
 Choose specifically which parts of a JSON response Keploy should validate during a replay.
 
-<img src="/docs/img/schema-assertion.png?raw=true"/>
+<img src="/docs/img/schema-assertion.png?raw=true" alt="Schema assertion configuration selecting response fields on a Keploy API test"/>
 
 **Example Context:** In this window, we are targeting a `GET` request on the `/visits/-1` endpoint that expects a `400` status code. Under **Response Fields**, specific keys like `className` and `exMessage` are selected. Toggling these ensures Keploy validates that these fields are returned as the correct data type (strings) during every replay.
 
 ### 2. Multi-Type Assertions
+
 Stack different assertion types, such as verifying a status code while simultaneously checking if a specific field contains a certain value.
 
-<img src="/docs/img/multi-assertion.png?raw=true"/>
+<img src="/docs/img/multi-assertion.png?raw=true" alt="Multiple assertion types applied to a single Keploy API test"/>
 
 **Example Context:** This setup enforces two rules simultaneously:
+
 1. **Status Code**: Validates that the server returns a `201` (Created).
 2. **JSON Contains**: Specifically checks the `city` header/field to ensure it matches the expected value `"sometown"`.
 
 ## Custom & Global Functions
 
 ### 1. Writing Inline Logic
+
 Access the `request` and `response` objects directly to create complex rules within the assertion panel.
 
 <img src="/docs/img/custom-function.png?raw=true" alt="Custom Functions"/>
@@ -43,9 +45,16 @@ Access the `request` and `response` objects directly to create complex rules wit
 **Example Context:** The editor shows a function signature: `function customFunction(request, response)`. This gives you direct access to the full objects, allowing you to write JavaScript logic to determine if the test should pass based on dynamic conditions.
 
 ### 2. Global Function Library
+
 Save repeatable validation rules to the Global Custom Functions library so they can be reused across your entire development team.
 
 <img src="/docs/img/global-functions.png?raw=true" alt="Global Functions"/>
 
+**Example Context:** The library shows reusable logic stored globally. For example, the `customFunction` at the bottom demonstrates an `assert.greater(response.status, 399)` utility, creating a standardized rule to verify error-level status codes across multiple suites.
+
+## Related
 
-**Example Context:** The library shows reusable logic stored globally. For example, the `customFunction` at the bottom demonstrates an `assert.greater(response.status, 399)` utility, creating a standardized rule to verify error-level status codes across multiple suites.
\ No newline at end of file
+- [Custom Assertions](/docs/running-keploy/api-testing-custom-assertions/) — define validation rules.
+- [Bulk Assertions and Schema Validation](/docs/running-keploy/api-testing-bulk-assertions/) — apply assertions in bulk.
+- [Assertion Tree](/docs/running-keploy/api-testing-assertion-tree/) — visualize assertion flow.
+- [Editing Test Suites and Custom Assertions](/docs/running-keploy/api-testing-edit-assertions/) — edit assertions in a suite.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-generation-history.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-generation-history.md
index 1680855c2b..db15c7c881 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-generation-history.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-generation-history.md
@@ -10,11 +10,12 @@ tags:
   - job-tracking
   - test-management
 ---
+
 import ProductTier from '@site/src/components/ProductTier';
 
 <ProductTier tiers="Free, Teams, Scale, Enterprise" offerings="Self-Hosted, Dedicated" />
 
-This guide explains how to use the generation history to track and manage your test generation jobs. 
+This guide explains how to use the generation history to track and manage your test generation jobs.
 
 ## Generation History Features
 
@@ -65,17 +66,20 @@ If you find rejected test suites that you want to include:
 ## Understanding Test Statuses
 
 ### Accepted Tests ✅
+
 - Tests that passed all validation checks
 - Successfully generated and ready to use
 - No issues detected in the test suite
 
 ### Rejected Tests ❌
+
 - Tests that failed validation checks
 - May have incorrect assertions or invalid configurations
 - Require manual review and fixes
 - Can be added back to the test suite list for modification
 
 ### Buggy Tests 🐛
+
 - Tests with identified bugs or issues
 - May have inconsistent behavior or errors
 - Need investigation and debugging
@@ -130,16 +134,19 @@ If you find rejected test suites that you want to include:
 ## Analyzing Generation Trends
 
 ### Success Rate Analysis
+
 - Track the percentage of accepted vs rejected tests over time
 - Identify patterns in test generation quality
 - Optimize inputs based on historical data
 
 ### Input Optimization
+
 - Review which inputs led to higher acceptance rates
 - Compare different configurations and their outcomes
 - Refine your test generation strategy
 
 ### Error Patterns
+
 - Identify common reasons for test rejection
 - Address recurring bugs or issues
 - Improve test generation quality
@@ -170,3 +177,10 @@ If you find rejected test suites that you want to include:
    - Archive old generation jobs periodically
    - Focus on recent and relevant generations
    - Keep track of successful generation patterns
+
+## Related
+
+- [Schema Coverage and Generation](/docs/running-keploy/api-testing-schema-coverage/) — generate tests for coverage gaps.
+- [API Test Generator](/docs/running-keploy/api-test-generator/) — how test generation works.
+- [Test Run Reports](/docs/running-keploy/api-testing-run-report/) — review resulting run reports.
+- [Adding New Test Suites](/docs/running-keploy/api-testing-add-suite/) — add suites manually.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-local-agent.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-local-agent.md
index 3481969751..b94a67e668 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-local-agent.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-local-agent.md
@@ -9,6 +9,7 @@ tags:
   - test-suite
   - test-management
 ---
+
 import ProductTier from '@site/src/components/ProductTier';
 
 <ProductTier tiers="Free, Teams, Scale, Enterprise" offerings="Self-Hosted, Dedicated" />
@@ -26,7 +27,7 @@ This guide explains how to use the local agent to test private or local endpoint
      - **Windows**
      - **Mac**
      - **Linux**
-![Local Agent](https://keploy-devrel.s3.us-west-2.amazonaws.com/local-agent-1.png)
+       ![Local Agent](https://keploy-devrel.s3.us-west-2.amazonaws.com/local-agent-1.png)
 
 3. **Start the Keploy Agent**
    - Once the agent is downloaded, start it on your device.
@@ -40,6 +41,13 @@ This guide explains how to use the local agent to test private or local endpoint
 
 5. **Troubleshooting Connection Issues**
    - Ensure that the agent is running and the endpoint URL is correct.
-   - If the local agent fails to connect, you can use the Keploy extension as an alternative  [Record API Tests via Chrome Extension](https://keploy.io/docs/running-keploy/api-testing-chrome-extension/)
+   - If the local agent fails to connect, you can use the Keploy extension as an alternative [Record API Tests via Chrome Extension](https://keploy.io/docs/running-keploy/api-testing-chrome-extension/)
+
+By following these steps, you can efficiently use the local agent to test your APIs and generate test suites automatically.
+
+## Related
 
-By following these steps, you can efficiently use the local agent to test your APIs and generate test suites automatically.
\ No newline at end of file
+- [API Test Recorder (Chrome Extension)](/docs/running-keploy/api-testing-chrome-extension/) — browser-based capture alternative.
+- [Adding New Test Suites](/docs/running-keploy/api-testing-add-suite/) — create suites for local endpoints.
+- [Authentication Setup for API Testing](/docs/running-keploy/api-testing-auth-setup/) — authenticate local endpoints.
+- [API Test Generator](/docs/running-keploy/api-test-generator/) — generate tests for local APIs.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-mark-unbuggy.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-mark-unbuggy.md
index b15975303e..5850bbaf3e 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-mark-unbuggy.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-mark-unbuggy.md
@@ -45,7 +45,7 @@ Once you're on the test suite page:
 
 ### Immediate Changes
 
-- **Status Update**: The suite status changes from "Buggy" to "Active" 
+- **Status Update**: The suite status changes from "Buggy" to "Active"
 - **Future Runs**: The suite will run normally in subsequent test executions
 - **Reporting**: The suite will be included in standard test reports
 - **Monitoring**: Keploy will continue monitoring the suite for new issues
@@ -56,6 +56,7 @@ Once you're on the test suite page:
 **Scenario**: A 404 error was resolved by fixing the API endpoint
 
 **Before marking unbuggy**:
+
 ```bash
 # Verify the endpoint is working
 curl -X POST https://api.example.com/owners \
@@ -68,10 +69,18 @@ curl -X POST https://api.example.com/owners \
 **Scenario**: Response schema validation was fixed by updating the API
 
 **Verification steps**:
+
 1. Check that response format matches expectations
 2. Verify all required fields are present
 3. Confirm data types are correct
 
 This ensures that suites are automatically marked as unbuggy when automated fixes resolve issues.
 
-Remember: Marking a suite as unbuggy should only be done after thoroughly verifying that all issues have been resolved and the suite is functioning correctly.
\ No newline at end of file
+Remember: Marking a suite as unbuggy should only be done after thoroughly verifying that all issues have been resolved and the suite is functioning correctly.
+
+## Related
+
+- [Buggy Test Suites](/docs/running-keploy/api-testing-buggy-suites/) — identify failing suites.
+- [Fix with AI](/docs/running-keploy/api-testing-fix-with-ai/) — auto-repair failing suites.
+- [Test Run Reports](/docs/running-keploy/api-testing-run-report/) — verify fixes in run reports.
+- [Edit Test Suites](/docs/running-keploy/api-testing-edit-suites/) — manually fix suite issues.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-run-report.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-run-report.md
index 721074be67..c5305ed9f8 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-run-report.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-run-report.md
@@ -10,11 +10,12 @@ tags:
   - test-results
   - test-management
 ---
+
 import ProductTier from '@site/src/components/ProductTier';
 
 <ProductTier tiers="Free, Teams, Scale, Enterprise" offerings="Self-Hosted, Dedicated" />
 
-This guide explains how to use the run report page to track and analyze your test execution results. 
+This guide explains how to use the run report page to track and analyze your test execution results.
 
 ## Run Report List View
 
@@ -60,23 +61,26 @@ Click on any report from the list to view detailed execution results:
 ### Understanding Test Results
 
 #### Passed Tests ✅
+
 - Tests that successfully completed all assertions
 - All validations matched expected results
 - No errors or warnings during execution
 
 #### Failed Tests ❌
+
 - Tests that did not meet assertion criteria
 - **Failure Reasons Displayed**:
   - Assertion mismatches
   - Unexpected response values
   - Status code mismatches
   - Timeout errors
-- **Association Failures**: 
+- **Association Failures**:
   - Failures from dependent services or associations
   - External API failures affecting the test
   - Database connection issues
 
-#### Buggy Tests 
+#### Buggy Tests
+
 - Tests with identified bugs or inconsistent behavior
 - **Buggy Reasons Displayed**:
   - Shown on top of the particular test step
@@ -91,14 +95,18 @@ The run report page provides powerful filtering options to help you analyze spec
 ### Available Filters
 
 #### 1. Filter by Suite Status
+
 Filter tests based on their execution outcome:
+
 - **Passed**: Show only successful tests
 - **Failed**: Show only failed tests
 - **Buggy**: Show only buggy tests
 - **All**: View all test results
 
 #### 2. Filter by Status Code
+
 Filter by HTTP response status codes:
+
 - **2xx Success**: 200 OK, 201 Created, 204 No Content
 - **3xx Redirection**: 301, 302, 304
 - **4xx Client Errors**: 400, 401, 403, 404
@@ -106,7 +114,9 @@ Filter by HTTP response status codes:
 - **Custom Code**: Filter by specific status codes
 
 #### 3. Filter by HTTP Method
+
 Filter tests by request method:
+
 - **GET**: Retrieve operations
 - **POST**: Create operations
 - **PUT**: Update operations
@@ -115,7 +125,9 @@ Filter tests by request method:
 - **OPTIONS, HEAD**: Other HTTP methods
 
 #### 4. Filter by Endpoint
+
 Filter by API endpoint or URL path:
+
 - Full endpoint URL
 - Partial path matching
 - Wildcard patterns
@@ -128,7 +140,6 @@ Filter by API endpoint or URL path:
    - Select desired filter criteria
    - You can also apply multiple filters simultaneously
 
-
 ## Detailed Test Step Information
 
 ### Viewing Step-by-Step Results
@@ -203,4 +214,11 @@ For each test case, you can see:
 - **Team Collaboration**: Share results and insights with team
 - **Data-Driven Decisions**: Use metrics to improve test quality
 
-By leveraging the run report features, you can maintain high-quality APIs, quickly identify and fix issues, and ensure comprehensive test coverage across your application.
\ No newline at end of file
+By leveraging the run report features, you can maintain high-quality APIs, quickly identify and fix issues, and ensure comprehensive test coverage across your application.
+
+## Related
+
+- [Sharing Reports](/docs/running-keploy/api-testing-sharing-reports/) — share reports with your team.
+- [Running Selective Test Suites](/docs/running-keploy/api-testing-running-selective/) — run selected suites.
+- [API Test Setup for GitHub CI/CD](/docs/running-keploy/api-testing-cicd/) — run reports in CI/CD.
+- [Buggy Test Suites](/docs/running-keploy/api-testing-buggy-suites/) — investigate failing suites.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-schema-coverage.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-schema-coverage.md
index e60b7f2fc9..91d54b0fab 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-schema-coverage.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-schema-coverage.md
@@ -35,6 +35,7 @@ The schema coverage page provides a comprehensive view of how well your test sui
 ### 1. Original Schema View
 
 The original schema section displays:
+
 - **Your API Schema**: The original OpenAPI/Swagger schema or manually defined schema
 - **Schema Structure**: Complete API specification including:
   - Endpoints and paths
@@ -46,6 +47,7 @@ The original schema section displays:
 ### 2. Total Coverage Metrics
 
 View comprehensive coverage statistics:
+
 - **Overall Coverage Percentage**: Total schema coverage across all endpoints
 - **Endpoint Coverage**: Coverage breakdown by API endpoint
 - **Covered Lines**: Number of schema lines with test coverage
@@ -54,6 +56,7 @@ View comprehensive coverage statistics:
 ### 3. Keploy Generated Schema
 
 The generated schema section shows:
+
 - **Auto-Generated Schema**: Schema derived from recorded API calls
 - **Coverage Highlights**: Visual indication of covered vs uncovered parts
 - **Field-Level Coverage**: Which fields have been tested
@@ -62,6 +65,7 @@ The generated schema section shows:
 ### Side-by-Side Comparison
 
 View original and generated schemas side by side:
+
 ```
 ┌──────────────────────────────────────────────────────────────────┐
 │ Schema Coverage Analysis                                         │
@@ -87,7 +91,7 @@ View original and generated schemas side by side:
 │ │   address: ❌ Not Covered   │   address: ❌ Missing        │  │
 │ │   role: ⚠️  Partial         │   role: ⚠️  Limited values   │  │
 │ │                             │                              │  │
-│ └─────────────────────────────┴──────────────────────────────┘  │ 
+│ └─────────────────────────────┴──────────────────────────────┘  │
 │                                                                 │
 │ [Cover Missing Lines]                                           │
 │                                                                 │
@@ -108,7 +112,6 @@ View original and generated schemas side by side:
      - **Status Codes**: Target specific response codes to test
      - **Data Variations**: Specify value ranges or combinations
 
-
 ## Coverage Visualization
 
 - **Heat Map View**: Visual representation of coverage density
@@ -121,6 +124,7 @@ View original and generated schemas side by side:
 ### Detailed Coverage Metrics
 
 #### Endpoint-Level Coverage
+
 ```
 /api/v1/users
 ├─ GET    ✅ 100% (All fields covered)
@@ -138,9 +142,17 @@ View original and generated schemas side by side:
 ### Coverage Gaps Identification
 
 Keploy automatically identifies:
+
 1. **Untested Endpoints**: API paths with no test coverage
 2. **Missing HTTP Methods**: CRUD operations not tested
 3. **Uncovered Fields**: Schema fields never validated
 4. **Missing Edge Cases**: Boundary conditions not tested
 
-By leveraging schema coverage analysis and automated test generation, you can ensure comprehensive API testing, maintain high code quality.
\ No newline at end of file
+By leveraging schema coverage analysis and automated test generation, you can ensure comprehensive API testing, maintain high code quality.
+
+## Related
+
+- [Test Generation History](/docs/running-keploy/api-testing-generation-history/) — track generation jobs.
+- [API Test Generator](/docs/running-keploy/api-test-generator/) — how test generation works.
+- [Bulk Assertions and Schema Validation](/docs/running-keploy/api-testing-bulk-assertions/) — validate schema in bulk.
+- [Functions & Schema Assertions](/docs/running-keploy/api-testing-functions/) — schema and function assertions.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-sharing-reports.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-sharing-reports.md
index 63e4b0cad1..25bacfa9d9 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-sharing-reports.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-sharing-reports.md
@@ -53,6 +53,7 @@ Once added, they become a workspace member and can access shared reports based o
 When you share a report, the recipient can view:
 
 ### Execution Summary
+
 - Total test cases executed
 - Passed / Failed count
 - Execution duration
@@ -65,3 +66,9 @@ When you share a report, the recipient can view:
 - Add relevant team members directly from the dashboard
 - Maintain proper role-based access control
 
+## Related
+
+- [Test Run Reports](/docs/running-keploy/api-testing-run-report/) — view detailed run reports.
+- [Test Suite Settings & Actions](/docs/running-keploy/api-testing-suite-settings/) — manage suite settings.
+- [API Test Setup for GitHub CI/CD](/docs/running-keploy/api-testing-cicd/) — generate reports in CI/CD.
+- [Running Selective Test Suites](/docs/running-keploy/api-testing-running-selective/) — run suites to report on.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-tool-ai-powered.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-tool-ai-powered.md
index b88f9868c0..f60427144b 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-tool-ai-powered.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-tool-ai-powered.md
@@ -109,3 +109,10 @@ Keploy is built with security-first principles and is compliant with major indus
 <img src="https://keploy-devrel.s3.us-west-2.amazonaws.com/compliance-images.png" alt="Keploy Record Test case" width="100%" />
 
 Your data and test traffic are handled securely, with the option to run Keploy entirely within your network using our self-hosted agent or BYOLLM infrastructure. To Learn more on our [security page](https://trust.keploy.io).
+
+## Related
+
+- [Generate API Tests using AI](/docs/running-keploy/generate-api-tests-using-ai/) — generate API tests with AI.
+- [API Test Architecture](/docs/running-keploy/api-test-architecture/) — architecture behind generation.
+- [Agent-Based API Test Generation](/docs/running-keploy/agent-test-generation/) — agent-based test generation.
+- [Adding New Test Suites](/docs/running-keploy/api-testing-add-suite/) — add suites to your tests.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-variables.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-variables.md
index 2e6dad6ce9..352c1d653d 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-variables.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-variables.md
@@ -15,30 +15,39 @@ Variables in Keploy act as placeholders for dynamic data that changes between te
 
 - **Extraction**: This involves identifying specific data points within an API response—such as an ID, a token, or a status string—and mapping them to a unique variable name in the **Variables** tab of the **Edit Test Step** panel.
 - **Injection**: Once a variable is captured, it can be dynamically inserted into subsequent URLs, Headers, or Request Bodies using the double-curly brace syntax: `{{variable_name}}`.
-- **Global vs. Suite Scope**: 
-    - **Suite Variables**: These are ephemeral and captured from previous steps within a specific test suite run to maintain state across a single workflow.
-    - **Global Variables**: These are persistent constants, such as base URLs, environment-specific keys, or static authentication tokens, available across all suites in the workspace.
+- **Global vs. Suite Scope**:
+  - **Suite Variables**: These are ephemeral and captured from previous steps within a specific test suite run to maintain state across a single workflow.
+  - **Global Variables**: These are persistent constants, such as base URLs, environment-specific keys, or static authentication tokens, available across all suites in the workspace.
 
 ## Hands-On: Implementation
 
 ### 1. Extraction from Responses
-To reuse data, you define a mapping that tells Keploy exactly where to look in a previous response. 
 
-<img src="/docs/img/var-extraction.png?raw=true" alt="Keploy Architecture"/>
+To reuse data, you define a mapping that tells Keploy exactly where to look in a previous response.
 
+<img src="/docs/img/var-extraction.png?raw=true" alt="Keploy Architecture"/>
 
 **Example Context:** In the view above, we are extracting the unique ID of a record. The mapping `steps["Create_Owner"].response.body.id` captures the value from the **Create_Owner** step. Note the **Unused** badge; Keploy provides this visual hint when a variable has been defined but hasn't been injected into any subsequent request yet.
 
 ### 2. Injection into Requests
+
 Injection allows you to replace static values with dynamic variables, ensuring your tests remain flexible across different environments and data states.
 
-<img src="/docs/img/var-injection.png?raw=true"/>
+<img src="/docs/img/var-injection.png?raw=true" alt="Injecting a dynamic variable into a Keploy API test request"/>
 
 **Example Context:** This view shows the **Request Details** for an API call to the `/owners` endpoint. By defining the method (e.g., **POST**), you can then use placeholders like `{{owner_id}}` in the URL path or body. Keploy will automatically swap the placeholder with the actual value captured during test execution.
 
 ### 3. Global Variable Management
+
 Global variables serve as the centralized source of truth for your testing environment.
 
-<img src="/docs/img/global-vars.png?raw=true"/>
+<img src="/docs/img/global-vars.png?raw=true" alt="Configuring global variables in Keploy API testing"/>
+
+**Example Context:** The **Global Variables** dashboard allows you to manage workspace-wide data. This includes static entries like the **base URL** and dynamic **Global Custom Functions**. For instance, `generateCompanyId()` is a function that returns a unique string starting with `COMP_` followed by a timestamp, ensuring unique identifiers for every test run.
+
+## Related
 
-**Example Context:** The **Global Variables** dashboard allows you to manage workspace-wide data. This includes static entries like the **base URL** and dynamic **Global Custom Functions**. For instance, `generateCompanyId()` is a function that returns a unique string starting with `COMP_` followed by a timestamp, ensuring unique identifiers for every test run.
\ No newline at end of file
+- [Functions & Schema Assertions](/docs/running-keploy/api-testing-functions/) — pair variables with custom functions.
+- [Custom Assertions](/docs/running-keploy/api-testing-custom-assertions/) — assert against captured variable values.
+- [Editing Test Suites and Custom Assertions](/docs/running-keploy/api-testing-edit-assertions/) — where variables are configured.
+- [Authentication Setup for API Testing](/docs/running-keploy/api-testing-auth-setup/) — inject tokens as global variables.
diff --git a/versioned_docs/version-4.0.0/running-keploy/api-testing-webhook.md b/versioned_docs/version-4.0.0/running-keploy/api-testing-webhook.md
index 72dfa54d95..a9f77e3e60 100644
--- a/versioned_docs/version-4.0.0/running-keploy/api-testing-webhook.md
+++ b/versioned_docs/version-4.0.0/running-keploy/api-testing-webhook.md
@@ -402,3 +402,10 @@ if *review.Request.StepPassed { // Only check steps that initially passed
 - **Respond Quickly:** Keploy will wait for your webhook's response. A slow webhook will slow down your entire test run. Aim for response times under 500ms.
 - **Log Everything:** Your webhook server should log every incoming request and the response it sends. This is invaluable for debugging.
 - **Handle Errors Gracefully:** If your server is down or returns a non-200 status code, Keploy will treat it as a transport failure and **fail the test step**. Ensure your server is robust.
+
+## Related
+
+- [Custom Assertions](/docs/running-keploy/api-testing-custom-assertions/) — add validation logic within Keploy itself.
+- [Functions & Schema Assertions](/docs/running-keploy/api-testing-functions/) — programmatic checks on responses.
+- [Public REST API](/docs/running-keploy/public-api/) — trigger runs programmatically from external systems.
+- [Test Run Reports](/docs/running-keploy/api-testing-run-report/) — see webhook pass/fail reasons in results.
diff --git a/versioned_docs/version-4.0.0/running-keploy/best-practices-api-testing.md b/versioned_docs/version-4.0.0/running-keploy/best-practices-api-testing.md
index b42e910e23..1891707512 100644
--- a/versioned_docs/version-4.0.0/running-keploy/best-practices-api-testing.md
+++ b/versioned_docs/version-4.0.0/running-keploy/best-practices-api-testing.md
@@ -82,3 +82,10 @@ keywords:
 
 - Output test name, request payload, status code, and failure reason.
 - Use structured reports for better traceability in CI/CD tools.
+
+## Related
+
+- [What is API testing?](/docs/running-keploy/about-api-testing/) — foundational concepts behind these practices.
+- [API Test Setup for GitHub CI/CD](/docs/running-keploy/api-testing-cicd/) — automate regression tests in pipelines.
+- [Variables in API Testing](/docs/running-keploy/api-testing-variables/) — chain requests for workflow validation.
+- [Bulk Assertions and Schema Validation](/docs/running-keploy/api-testing-bulk-assertions/) — validate response structure and schema.
diff --git a/versioned_docs/version-4.0.0/running-keploy/cli-commands.md b/versioned_docs/version-4.0.0/running-keploy/cli-commands.md
index cf80e4bf22..b579ed7bcc 100755
--- a/versioned_docs/version-4.0.0/running-keploy/cli-commands.md
+++ b/versioned_docs/version-4.0.0/running-keploy/cli-commands.md
@@ -463,3 +463,10 @@ keploy example [flags]
 <b> Available Flags: </b>
 
 - `--customSetup` - Displays commands tailored for custom user-defined setups.
+
+## Related
+
+- [Configuration File](/docs/running-keploy/configuration-file/) — set these flags once in `keploy.yaml`.
+- [Recording Filters](/docs/running-keploy/recording-filters/) — control which requests get recorded.
+- [Keploy Templatize](/docs/running-keploy/keploy-templatize/) — details on the `templatize` command.
+- [Keploy Passthrough](/docs/running-keploy/keploy-passthrough/) — using the `--passThroughPorts` flag.
diff --git a/versioned_docs/version-4.0.0/running-keploy/configuration-file.md b/versioned_docs/version-4.0.0/running-keploy/configuration-file.md
index 2e209b702d..0196e17780 100644
--- a/versioned_docs/version-4.0.0/running-keploy/configuration-file.md
+++ b/versioned_docs/version-4.0.0/running-keploy/configuration-file.md
@@ -85,7 +85,7 @@ keployNetwork: "keploy-network"
 
 ## Using the Config File
 
-The Keploy-config file eliminates the need to repeatedly specify parameters for each record or test command. The parameters in the file correspond to the flags in the Keploy [CLI Command Docs](http://keploy.io/docs/running-keploy/cli-commands/).Using keploy-config can help to reduce the record and test command to just:
+The Keploy-config file eliminates the need to repeatedly specify parameters for each record or test command. The parameters in the file correspond to the flags in the Keploy [CLI Command Docs](https://keploy.io/docs/running-keploy/cli-commands/).Using keploy-config can help to reduce the record and test command to just:
 
 ### Record Command:
 
@@ -99,7 +99,7 @@ keploy record
 keploy test
 ```
 
-Visit the [CLI Command Docs](http://keploy.io/docs/running-keploy/cli-commands/) to know more about the flags/parameters and their usage.
+Visit the [CLI Command Docs](https://keploy.io/docs/running-keploy/cli-commands/) to know more about the flags/parameters and their usage.
 
 ## Configuration Sections
 
@@ -380,7 +380,7 @@ In the provided example:
 
 ## Advanced Noise Filtering:
 
-Earlier the only way to add the [noisy fields](http://keploy.io/docs/concepts/general-glossary/#3-noisy-field) was by modifying individual test file (testcase level). Now, With the introduction of config file, users can add the noisy fields at test-set and global level through config file itself.
+Earlier the only way to add the [noisy fields](https://keploy.io/docs/concepts/general-glossary/#3-noisy-field) was by modifying individual test file (testcase level). Now, With the introduction of config file, users can add the noisy fields at test-set and global level through config file itself.
 
 ### Global Noise
 
@@ -485,6 +485,13 @@ The `globalNoise` and `test-sets` are optional fields in the config file. If not
 
 Congratulations! You've now explored the features and configuration options provided by `Keploy-config`.
 
-Now armed with Keploy-config, you are ready to embark on a more organized and productive journey of recording and testing APIs with Keploy. Feel free to explore additional features, customize configurations, and refer to the [CLI Command Docs](http://keploy.io/docs/running-keploy/cli-commands/) for more details on available flags and parameters.
+Now armed with Keploy-config, you are ready to embark on a more organized and productive journey of recording and testing APIs with Keploy. Feel free to explore additional features, customize configurations, and refer to the [CLI Command Docs](https://keploy.io/docs/running-keploy/cli-commands/) for more details on available flags and parameters.
 
 Happy testing and may your APIs always return the expected results! 🚀
+
+## Related
+
+- [Keploy CLI Commands](/docs/running-keploy/cli-commands/) — flags that map to config fields.
+- [Recording Filters](/docs/running-keploy/recording-filters/) — filter traffic during recording.
+- [Keploy Passthrough](/docs/running-keploy/keploy-passthrough/) — bypass rules and pass-through ports.
+- [Adding a custom Mock to the Keploy Mock File](/docs/running-keploy/custom-mocks/) — work with recorded mocks.
diff --git a/versioned_docs/version-4.0.0/running-keploy/custom-mocks.md b/versioned_docs/version-4.0.0/running-keploy/custom-mocks.md
index 5b39c625c4..81f02ba428 100644
--- a/versioned_docs/version-4.0.0/running-keploy/custom-mocks.md
+++ b/versioned_docs/version-4.0.0/running-keploy/custom-mocks.md
@@ -124,3 +124,10 @@ spec:
     timestamp: 2024-02-19T13:14:28.145240844Z
 ---
 ```
+
+## Related
+
+- [Configuration File](/docs/running-keploy/configuration-file/) — configure mock paths and bypass rules.
+- [Keploy Passthrough](/docs/running-keploy/keploy-passthrough/) — skip mocking for specific ports.
+- [Keploy CLI Commands](/docs/running-keploy/cli-commands/) — record commands that generate mock files.
+- [Keploy Templatize](/docs/running-keploy/keploy-templatize/) — templatize dynamic values in mocks.
diff --git a/versioned_docs/version-4.0.0/running-keploy/docker-tls.md b/versioned_docs/version-4.0.0/running-keploy/docker-tls.md
index 3132303a3c..deb10e3cc7 100644
--- a/versioned_docs/version-4.0.0/running-keploy/docker-tls.md
+++ b/versioned_docs/version-4.0.0/running-keploy/docker-tls.md
@@ -65,3 +65,10 @@ keploy test -c "Docker_CMD_to_run_user_container --network <network_name>" --con
 Voilà! 🧑🏻‍💻 We have the tests with data mocks running! 🐰🎉
 
 You'll be able to see the test cases that ran with the results report on the console as well as locally in the `testReport` directory.
+
+## Related
+
+- [Keploy CLI Commands](/docs/running-keploy/cli-commands/) — full record and test flag reference.
+- [Configuration File](/docs/running-keploy/configuration-file/) — set container and network names in `keploy.yaml`.
+- [Keploy Passthrough](/docs/running-keploy/keploy-passthrough/) — pass through ports for containerized dependencies.
+- [Adding a custom Mock to the Keploy Mock File](/docs/running-keploy/custom-mocks/) — mock services you cannot containerize.
diff --git a/versioned_docs/version-4.0.0/running-keploy/generate-api-tests-using-ai.md b/versioned_docs/version-4.0.0/running-keploy/generate-api-tests-using-ai.md
index 9ed8022b71..fc18477d07 100644
--- a/versioned_docs/version-4.0.0/running-keploy/generate-api-tests-using-ai.md
+++ b/versioned_docs/version-4.0.0/running-keploy/generate-api-tests-using-ai.md
@@ -78,3 +78,10 @@ Every test generated will include:
 [//]: # "- 🧹 [Review, clean, and improve test flows](/docs/running-keploy/review-and-improve-ai-generated-tests)"
 [//]: # "- 🤝 [Share tests and test-reports with your team](/docs/running-keploy/share-tests)"
 [//]: # "- 🚀 [Integrate tests in your CI/CD pipeline](/docs/running-keploy/ci-cd-ai-gen-api-tests)"
+
+## Related
+
+- [API Test Recorder (Chrome Extension)](/docs/running-keploy/api-testing-chrome-extension/) — capture flows via the browser instead.
+- [Run AI-Generated API Tests](/docs/running-keploy/run-ai-generated-api-tests/) — execute the tests you just generated.
+- [Review & Improve AI-Generated API Tests](/docs/running-keploy/review-and-improve-ai-generated-tests/) — refine and harden generated suites.
+- [Using Keploy Local Agent](/docs/running-keploy/api-testing-local-agent/) — proxy private endpoints for generation.
diff --git a/versioned_docs/version-4.0.0/running-keploy/k8s-proxy-daemonset-architecture.md b/versioned_docs/version-4.0.0/running-keploy/k8s-proxy-daemonset-architecture.md
index 9e91624688..c003ebfa91 100644
--- a/versioned_docs/version-4.0.0/running-keploy/k8s-proxy-daemonset-architecture.md
+++ b/versioned_docs/version-4.0.0/running-keploy/k8s-proxy-daemonset-architecture.md
@@ -254,3 +254,9 @@ Recording mode and replay environment are orthogonal—every combination is vali
 | Production with read-only RBAC on the source namespace, no spare K8s cluster but a Docker host | DaemonSet      | `runner`           |
 
 For the operational walkthrough of the cluster-mode setup, see the K8s Proxy REST API guide's setup section.
+
+## Related
+
+- [Kubernetes Proxy REST API](/docs/running-keploy/k8s-proxy-api/) — drive recording and replay via REST.
+- [Recording Filters](/docs/running-keploy/recording-filters/) — scope which requests get captured.
+- [Public REST API](/docs/running-keploy/public-api/) — Keploy Cloud control-plane API.
diff --git a/versioned_docs/version-4.0.0/running-keploy/keploy-karaf.md b/versioned_docs/version-4.0.0/running-keploy/keploy-karaf.md
index 168286ca31..a41a75e2da 100644
--- a/versioned_docs/version-4.0.0/running-keploy/keploy-karaf.md
+++ b/versioned_docs/version-4.0.0/running-keploy/keploy-karaf.md
@@ -115,3 +115,10 @@ Replace the placeholder values with actual paths and keys as needed.
 This assumes your Karaf application is running locally on port 8181.
 
 After running the tests, a `coverage.xml` file will be generated in the root directory of your project. This file contains the test coverage report, which can be used for further analysis or integrated with CI/CD pipelines.
+
+## Related
+
+- [Keploy CLI Commands](/docs/running-keploy/cli-commands/) — record and test command reference.
+- [Configuration File](/docs/running-keploy/configuration-file/) — persist settings in `keploy.yaml`.
+- [TLS Docker Support](/docs/running-keploy/docker-tls/) — run Keploy against containerized apps.
+- [Keploy Passthrough](/docs/running-keploy/keploy-passthrough/) — pass through dependency ports.
diff --git a/versioned_docs/version-4.0.0/running-keploy/keploy-passthrough.md b/versioned_docs/version-4.0.0/running-keploy/keploy-passthrough.md
index 9070ed554b..1f9c439ce3 100644
--- a/versioned_docs/version-4.0.0/running-keploy/keploy-passthrough.md
+++ b/versioned_docs/version-4.0.0/running-keploy/keploy-passthrough.md
@@ -31,3 +31,9 @@ sudo -E env 'PATH=$PATH' main.go record -c "java -jar path/to/user/jar" --passTh
 ```zsh
 sudo -E env 'PATH=$PATH' main.go test -c "java -jar path/to/user/jar" --delay 25  --passThroughPorts 5672,5432
 ```
+
+## Related
+
+- [Recording Filters](/docs/running-keploy/recording-filters/) — control which calls Keploy captures.
+- [Adding a custom Mock](/docs/running-keploy/custom-mocks/) — hand-author mocks for dependencies.
+- [Keploy CLI Commands](/docs/running-keploy/cli-commands/) — full command and flag reference.
diff --git a/versioned_docs/version-4.0.0/running-keploy/keploy-templatize.md b/versioned_docs/version-4.0.0/running-keploy/keploy-templatize.md
index 034a52a22d..be6e8cafca 100644
--- a/versioned_docs/version-4.0.0/running-keploy/keploy-templatize.md
+++ b/versioned_docs/version-4.0.0/running-keploy/keploy-templatize.md
@@ -39,3 +39,9 @@ sudo -E env 'PATH=$PATH' keploy templatize -t="test-set-1"
 > **Note**
 >
 > Even though you can use templatize multiple times, even on testsets that have already been templatized, but it is not reversible. So make sure you create a copy of your keploy folder before trying it out.
+
+## Related
+
+- [Adding a custom Mock](/docs/running-keploy/custom-mocks/) — pair templates with custom mocks.
+- [Configuration File](/docs/running-keploy/configuration-file/) — set defaults for record and test.
+- [Recording Filters](/docs/running-keploy/recording-filters/) — narrow what gets recorded.
diff --git a/versioned_docs/version-4.0.0/running-keploy/recording-filters.md b/versioned_docs/version-4.0.0/running-keploy/recording-filters.md
index e33f679d07..01f6982c2f 100644
--- a/versioned_docs/version-4.0.0/running-keploy/recording-filters.md
+++ b/versioned_docs/version-4.0.0/running-keploy/recording-filters.md
@@ -16,7 +16,6 @@ import ProductTier from '@site/src/components/ProductTier';
 
 <ProductTier tiers="Enterprise" offerings="Self-Hosted, Dedicated" />
 
-
 Keploy lets you configure **filters when starting a recording on any deployment**. Filters give you precise control over which requests get captured. You can limit recording to specific paths, methods, hosts, or headers, or explicitly exclude traffic you do not need.
 
 Filters are **optional**. If none are configured, Keploy records **all traffic** on the selected pods.
@@ -26,9 +25,8 @@ Filters are **optional**. If none are configured, Keploy records **all traffic**
 Filters are configured in **Step 2 (Record config)** of the **Start Recording** flow.
 
 <!-- where to configure image goes here -->
-![Where to configure filters](https://keploy-devrel.s3.us-west-2.amazonaws.com/landing/where-to-configure.png)
-
 
+![Where to configure filters](https://keploy-devrel.s3.us-west-2.amazonaws.com/landing/where-to-configure.png)
 
 To get there:
 
@@ -41,8 +39,8 @@ To get there:
 
 Each filter runs in one of two modes:
 
-* Exclude: Requests that match this filter **will be dropped and not recorded**.
-* Include: Only requests that match this filter **will be recorded**. Everything else is ignored.
+- Exclude: Requests that match this filter **will be dropped and not recorded**.
+- Include: Only requests that match this filter **will be recorded**. Everything else is ignored.
 
 > **Note:**
 > Use **Exclude** when you want to record most traffic but remove noise like health checks, probes, or irrelevant endpoints.
@@ -52,25 +50,25 @@ Each filter runs in one of two modes:
 
 Each filter supports the following fields. You can fill **one or more**. Only the fields you populate are evaluated.
 
-* **Path (Regex)**
-Matches the request path using a regular expression.
-Example: `/api/v1/.*` This captures all paths under `/api/v1/`.
+- **Path (Regex)**
+  Matches the request path using a regular expression.
+  Example: `/api/v1/.*` This captures all paths under `/api/v1/`.
 
-* **Host**
-Matches the target host.
-Example: `api.internal`
+- **Host**
+  Matches the target host.
+  Example: `api.internal`
 
-* **Port**
-Matches the port number.
-Example: `8080`
+- **Port**
+  Matches the port number.
+  Example: `8080`
 
-* **Methods**
-Comma-separated list of HTTP methods.
-Example: `GET`, `POST`
+- **Methods**
+  Comma-separated list of HTTP methods.
+  Example: `GET`, `POST`
 
-* **Headers**
-Matches a specific request header. Enter the header key and a regex as the value.
-Example: key = `x-record`, value = `true`.
+- **Headers**
+  Matches a specific request header. Enter the header key and a regex as the value.
+  Example: key = `x-record`, value = `true`.
 
 You can add multiple header conditions using **+ Add Header**.
 
@@ -88,18 +86,16 @@ For example, if you set Path to `/api/v1/.*` and Methods to `GET`, `POST`, only
 This filter captures only requests where a specific header value matches a regular expression pattern.
 The filter is set to Include mode, meaning all other traffic is ignored.
 
-
-
 <!-- start recording image goes here -->
+
 ![Include filter with regex header](https://keploy-devrel.s3.us-west-2.amazonaws.com/landing/start-recording.png)
 
 ## Example: Include Filter with Exact Header
 
 This example shows an `Include` filter matching on a header key with the exact value `true`. This is the simplest form of header-based filtering. Only requests carrying that header with that value will be recorded.
 
-
-
 <!-- start-recording-1 image goes here -->
+
 ![Include filter with exact header](https://keploy-devrel.s3.us-west-2.amazonaws.com/landing/start-recording-1.png)
 
 ## Client TLS Private Key
@@ -111,3 +107,9 @@ If your services do not use mTLS, leave this section empty and proceed.
 ## After Filters Are Applied
 
 Once you click Next, Keploy proceeds to Step 3 (Auto replay config) to complete the recording setup. After a recording starts, there is no in-UI view of which specific requests are being captured. Keploy applies your filters in the background and records all matching traffic into test cases automatically.
+
+## Related
+
+- [Adding a custom Mock](/docs/running-keploy/custom-mocks/) — supply mocks for filtered dependencies.
+- [Keploy Passthrough](/docs/running-keploy/keploy-passthrough/) — let selected calls hit the real service.
+- [Configuration File](/docs/running-keploy/configuration-file/) — persist filter settings.
diff --git a/versioned_docs/version-4.0.0/running-keploy/rename-testcases.md b/versioned_docs/version-4.0.0/running-keploy/rename-testcases.md
index 61aeb47526..af5711709e 100644
--- a/versioned_docs/version-4.0.0/running-keploy/rename-testcases.md
+++ b/versioned_docs/version-4.0.0/running-keploy/rename-testcases.md
@@ -55,3 +55,9 @@ curl --request POST \
 ## Rename Test-Sets
 
 To rename your test set, you can manually override the default name from `test-set-0` to a `kTest-0` in the `keploy` folder.
+
+## Related
+
+- [Keploy CLI Commands](/docs/running-keploy/cli-commands/) — commands that operate on test cases.
+- [Configuration File](/docs/running-keploy/configuration-file/) — configure test-set behaviour.
+- [Adding a custom Mock](/docs/running-keploy/custom-mocks/) — manage the files alongside test cases.
diff --git a/versioned_docs/version-4.0.0/running-keploy/review-and-improve-ai-generated-tests.md b/versioned_docs/version-4.0.0/running-keploy/review-and-improve-ai-generated-tests.md
index cfbc4f59f7..2174b67a9a 100644
--- a/versioned_docs/version-4.0.0/running-keploy/review-and-improve-ai-generated-tests.md
+++ b/versioned_docs/version-4.0.0/running-keploy/review-and-improve-ai-generated-tests.md
@@ -90,3 +90,9 @@ In the Test Suites list, hover over any row to reveal the ︙ (more-options) men
 
 All changes are saved instantly and logged.
 ⚠️ Deletion is irreversible. Use Git history or backups to restore.
+
+## Related
+
+- [Run AI-Generated API Tests](/docs/running-keploy/run-ai-generated-api-tests/) — execute the generated suites.
+- [Self-Healing API Tests](/docs/running-keploy/self-healing-ai-api-tests/) — auto-repair tests as APIs change.
+- [Generate API Tests using AI](/docs/running-keploy/generate-api-tests-using-ai/) — how the tests are produced.
diff --git a/versioned_docs/version-4.0.0/running-keploy/risk-profile-analysis.md b/versioned_docs/version-4.0.0/running-keploy/risk-profile-analysis.md
index c5d9cab616..f608ea3c41 100644
--- a/versioned_docs/version-4.0.0/running-keploy/risk-profile-analysis.md
+++ b/versioned_docs/version-4.0.0/running-keploy/risk-profile-analysis.md
@@ -87,3 +87,9 @@ tests:
       category:
         - SCHEMA_ADDED
 ```
+
+## Related
+
+- [Review & Improve AI-Generated API Tests](/docs/running-keploy/review-and-improve-ai-generated-tests/) — act on risk findings.
+- [Run AI-Generated API Tests](/docs/running-keploy/run-ai-generated-api-tests/) — run suites the analysis scores.
+- [Generate API Tests using AI](/docs/running-keploy/generate-api-tests-using-ai/) — the generation step upstream.
diff --git a/versioned_docs/version-4.0.0/running-keploy/run-ai-generated-api-tests.md b/versioned_docs/version-4.0.0/running-keploy/run-ai-generated-api-tests.md
index fd531bb0b2..cbb256b625 100644
--- a/versioned_docs/version-4.0.0/running-keploy/run-ai-generated-api-tests.md
+++ b/versioned_docs/version-4.0.0/running-keploy/run-ai-generated-api-tests.md
@@ -52,3 +52,9 @@ Iterate quickly:
 3. Compare the new report with the previous one right in the dashboard to verify the fix.
 
 You now have a pipeline—from triggering the run to an all-green build—that safeguards your API contract in every environment.
+
+## Related
+
+- [Generate API Tests using AI](/docs/running-keploy/generate-api-tests-using-ai/) — create the tests first.
+- [Review & Improve AI-Generated API Tests](/docs/running-keploy/review-and-improve-ai-generated-tests/) — refine the results.
+- [Self-Healing API Tests](/docs/running-keploy/self-healing-ai-api-tests/) — keep tests passing as APIs evolve.
diff --git a/versioned_docs/version-4.0.0/running-keploy/self-healing-ai-api-tests.md b/versioned_docs/version-4.0.0/running-keploy/self-healing-ai-api-tests.md
index 8bc872c965..488ce09713 100644
--- a/versioned_docs/version-4.0.0/running-keploy/self-healing-ai-api-tests.md
+++ b/versioned_docs/version-4.0.0/running-keploy/self-healing-ai-api-tests.md
@@ -37,7 +37,7 @@ Keploy can automatically fix failing test cases using its built-in AI engine. Th
 
 3. **Click "Fix with AI"**
 
-   - Keploy AI analyzes the diff between the expected and actual response. It then proposes updated assertions, allowing you to review and accept the 'healed' version as 
+   - Keploy AI analyzes the diff between the expected and actual response. It then proposes updated assertions, allowing you to review and accept the 'healed' version as
      the new source of truth.
 
 4. _(Optional)_ **Add Context**
@@ -62,3 +62,9 @@ Keploy can automatically fix failing test cases using its built-in AI engine. Th
 - Combine healing with test deduplication to keep your suite clean.
 
 [//]: # "You can read more on [Test Reports](/docs/running-keploy/review-and-improve-ai-generated-tests) or [Running Tests](/docs/running-keploy/run-ai-generated-api-tests)."
+
+## Related
+
+- [Run AI-Generated API Tests](/docs/running-keploy/run-ai-generated-api-tests/) — where self-healing applies.
+- [Review & Improve AI-Generated API Tests](/docs/running-keploy/review-and-improve-ai-generated-tests/) — manual refinement.
+- [Generate API Tests using AI](/docs/running-keploy/generate-api-tests-using-ai/) — the generation pipeline.
diff --git a/versioned_docs/version-4.0.0/running-keploy/share-tests.md b/versioned_docs/version-4.0.0/running-keploy/share-tests.md
index 5a62e2f6a1..5ef45e87ae 100644
--- a/versioned_docs/version-4.0.0/running-keploy/share-tests.md
+++ b/versioned_docs/version-4.0.0/running-keploy/share-tests.md
@@ -2,7 +2,7 @@
 id: share-tests
 title: Share Test Suite With Your Team
 sidebar_label: Share Test Suite
-description: Learn how to use Keploy’s API Test Generator to generate high-quality API test suites using AI from OpenAPI, curl, Postman, or traffic.
+description: Learn how to share Keploy API test suites and run reports with teammates via links, so collaborators can review results without any local setup.
 ---
 
 import ProductTier from '@site/src/components/ProductTier';
@@ -30,3 +30,9 @@ Click **Share**. Keploy sends:
   with a direct link to the suite.
 
 New users must **accept the invite** to gain access.
+
+## Related
+
+- [Sharing Reports](/docs/running-keploy/api-testing-sharing-reports/) — share run results, not just suites.
+- [Test Run Reports](/docs/running-keploy/api-testing-run-report/) — read the reports you share.
+- [Keploy Test Run Reports](/docs/running-keploy/test-run-reports/) — report internals and history.
diff --git a/versioned_docs/version-4.0.0/running-keploy/test-generate.md b/versioned_docs/version-4.0.0/running-keploy/test-generate.md
index 78cbdb5a0d..1f4b981b03 100644
--- a/versioned_docs/version-4.0.0/running-keploy/test-generate.md
+++ b/versioned_docs/version-4.0.0/running-keploy/test-generate.md
@@ -74,3 +74,9 @@ Enhance test accuracy by uploading documentation such as:
 - 🗂 **Feature briefs or requirement docs**
 
 These help Keploy better understand the intended logic and behavior of each endpoint.
+
+## Related
+
+- [Generate API Tests using AI](/docs/running-keploy/generate-api-tests-using-ai/) — the end-to-end generation guide.
+- [Agent-Based API Test Generation](/docs/running-keploy/agent-test-generation/) — generate from a local agent.
+- [Run AI-Generated API Tests](/docs/running-keploy/run-ai-generated-api-tests/) — run what you generate.
diff --git a/versioned_docs/version-4.0.0/running-keploy/test-run-reports.md b/versioned_docs/version-4.0.0/running-keploy/test-run-reports.md
index 61a134802f..ba9bb1ee94 100644
--- a/versioned_docs/version-4.0.0/running-keploy/test-run-reports.md
+++ b/versioned_docs/version-4.0.0/running-keploy/test-run-reports.md
@@ -116,3 +116,9 @@ Update the request configuration for each test case:
 
 - ✅ **Save Changes** — Apply edits to the test step and update the suite.
 - ❌ **Cancel** — Discard any unsaved modifications and revert to the last saved state.
+
+## Related
+
+- [Test Run Reports](/docs/running-keploy/api-testing-run-report/) — the per-run report view.
+- [Sharing Reports](/docs/running-keploy/api-testing-sharing-reports/) — share reports with your team.
+- [Share Test Suite With Your Team](/docs/running-keploy/share-tests/) — share the suites themselves.
diff --git a/versioned_docs/version-4.0.0/running-keploy/unit-test-architecture.md b/versioned_docs/version-4.0.0/running-keploy/unit-test-architecture.md
index 2e0d95b5f6..7386e7c64f 100644
--- a/versioned_docs/version-4.0.0/running-keploy/unit-test-architecture.md
+++ b/versioned_docs/version-4.0.0/running-keploy/unit-test-architecture.md
@@ -36,3 +36,9 @@ Here’s how Keploy leverages AI (LLM) to automate and streamline the unit testi
 ## In Short
 
 Keploy’s AI-driven architecture turns CI feedback and your codebase into a robust, scalable set of unit tests—saving you hours and catching regressions before they hit production.
+
+## Related
+
+- [Keploy Unit Test Generator](/docs/running-keploy/unit-test-generator/) — the generator built on this architecture.
+- [What is Unit Testing?](/docs/running-keploy/about-unit-testing/) — unit testing fundamentals.
+- [API Test Architecture](/docs/running-keploy/api-test-architecture/) — the API-side counterpart.
diff --git a/versioned_docs/version-4.0.0/running-keploy/unit-test-generator.md b/versioned_docs/version-4.0.0/running-keploy/unit-test-generator.md
index 7c30cae012..97558d591f 100644
--- a/versioned_docs/version-4.0.0/running-keploy/unit-test-generator.md
+++ b/versioned_docs/version-4.0.0/running-keploy/unit-test-generator.md
@@ -34,3 +34,9 @@ Keploy's UTG aims to:
 1. **PR Agent**: Install a GitHub App on your repo to automatically generate tests when you create a pull request.
 
 2. **VS Code Extension**: Generate test files with a single click directly from your IDE.
+
+## Related
+
+- [Unit Test Architecture](/docs/running-keploy/unit-test-architecture/) — how the generator is structured.
+- [Keploy's PR Agent](/docs/running-keploy/utg-pr-agent/) — generate unit tests on pull requests.
+- [Keploy's VS Code Extension](/docs/running-keploy/utg-vscode-extension/) — generate unit tests in your editor.
diff --git a/versioned_docs/version-4.0.0/running-keploy/utg-pr-agent.md b/versioned_docs/version-4.0.0/running-keploy/utg-pr-agent.md
index 0bde9477e6..906c2740c9 100644
--- a/versioned_docs/version-4.0.0/running-keploy/utg-pr-agent.md
+++ b/versioned_docs/version-4.0.0/running-keploy/utg-pr-agent.md
@@ -33,7 +33,7 @@ Follow the steps below to get started with the Keploy PR Agent on your GitHub re
 
 - Visit [Github Marketplace](https://github.com/marketplace/keploy)
 
-<img src="https://res.cloudinary.com/dfhtr1rwo/image/upload/v1748777663/keploy-marketplace_lwiaoz.png" width="100%" />
+<img src="https://res.cloudinary.com/dfhtr1rwo/image/upload/v1748777663/keploy-marketplace_lwiaoz.png" width="100%" alt="Keploy GitHub App listing on the GitHub Marketplace" />
 
 Click on **Add**.
 
@@ -43,7 +43,7 @@ Choose:
 - **All repositories** if you want the functionality across your GitHub organization.
 - Authorize the app to complete the installation.
   <!-- one small screenshot for the configuration in repositories goes here -->
-  <img src="https://res.cloudinary.com/dqwbkjfuh/image/upload/v1747914670/Screenshot_2025-05-22_at_2.50.17_PM_okdxc8.png" width="100%" />
+  <img src="https://res.cloudinary.com/dqwbkjfuh/image/upload/v1747914670/Screenshot_2025-05-22_at_2.50.17_PM_okdxc8.png" width="100%" alt="Choosing repositories while installing the Keploy GitHub App" />
 
 ### Step 2. Make a Code Change and Open a Pull Request
 
@@ -53,7 +53,7 @@ Once the app is installed:
 - Push your changes and **create a pull request (PR)** as usual.
 - The **Keploy PR Agent** will automatically detect the changes and leave a comment on the PR.
   <!-- one image of the koploy pr agent making a comment on the code will be added here  -->
-  <img src="https://res.cloudinary.com/dqwbkjfuh/image/upload/v1747914669/Screenshot_2025-05-22_at_3.21.05_PM_uzeewc.png" width="100%" />
+  <img src="https://res.cloudinary.com/dqwbkjfuh/image/upload/v1747914669/Screenshot_2025-05-22_at_3.21.05_PM_uzeewc.png" width="100%" alt="Keploy PR Agent leaving an automated comment on a pull request" />
 
 ### Step 3. Trigger Unit Test Generation
 
@@ -63,7 +63,7 @@ In the PR comment left by Keploy:
 - You will be redirected to the Keploy service, where the unit test generation process begins.
 - The PR Agent uses code semantics and the power of LLMs to understand your code changes and generate meaningful unit tests.
   <!-- one screenshot of the api server generating test cases will go here -->
-  <img src="https://res.cloudinary.com/dqwbkjfuh/image/upload/v1747914670/Screenshot_2025-05-22_at_3.23.40_PM_emluya.png" width="100%" />
+  <img src="https://res.cloudinary.com/dqwbkjfuh/image/upload/v1747914670/Screenshot_2025-05-22_at_3.23.40_PM_emluya.png" width="100%" alt="Keploy service generating unit tests from the pull request changes" />
 
 ### Step 4. View the Generated Tests and Summary
 
@@ -74,7 +74,7 @@ Once the process is complete:
   - All the **unit test files** generated for your recent changes.
   - A **test summary** presented in a **clean tabular format** showing: - File names - Number of test cases - Coverage details - Edge cases handled (if any)
     <!-- one image with the tabular format comment with the test summary will be added here -->
-    <img src="https://res.cloudinary.com/dqwbkjfuh/image/upload/v1747914671/Screenshot_2025-05-22_at_3.30.35_PM_mubqr5.png" width="100%" />
+    <img src="https://res.cloudinary.com/dqwbkjfuh/image/upload/v1747914671/Screenshot_2025-05-22_at_3.30.35_PM_mubqr5.png" width="100%" alt="Pull request comment showing generated unit test files and a test summary table" />
     You can review, modify, or directly merge the PR with complete confidence that your changes are well-tested.
     With Keploy PR Agent, testing is no longer a bottleneck - it’s built right into your workflow.
 
@@ -89,3 +89,9 @@ Ready to transform your pull request workflow from a potential quality bottlenec
 3. **Experience the difference** in your next code review cycle
 
 _Elevate your development workflow. Make every pull request a quality checkpoint._
+
+## Related
+
+- [Keploy Unit Test Generator](/docs/running-keploy/unit-test-generator/) — the engine behind the PR agent.
+- [Keploy's VS Code Extension](/docs/running-keploy/utg-vscode-extension/) — the same generator in your IDE.
+- [Unit Test Architecture](/docs/running-keploy/unit-test-architecture/) — how generated unit tests are built.
diff --git a/versioned_docs/version-4.0.0/running-keploy/utg-vsc-extension.md b/versioned_docs/version-4.0.0/running-keploy/utg-vsc-extension.md
index deffc6f112..d388e70207 100644
--- a/versioned_docs/version-4.0.0/running-keploy/utg-vsc-extension.md
+++ b/versioned_docs/version-4.0.0/running-keploy/utg-vsc-extension.md
@@ -125,3 +125,9 @@ Don't let testing slow down your development velocity. With Keploy's AI-powered
 4. **Watch your test coverage soar** while maintaining development speed
 
 \_Transform your IDE. Elevate your code quality. Join 500k+ developers building better software with Keploy.
+
+## Related
+
+- [Keploy's PR Agent](/docs/running-keploy/utg-pr-agent/) — the same generator on pull requests.
+- [Keploy Unit Test Generator](/docs/running-keploy/unit-test-generator/) — the generator internals.
+- [Unit Test Architecture](/docs/running-keploy/unit-test-architecture/) — how generated unit tests are built.
diff --git a/versioned_docs/version-4.0.0/server/installation.md b/versioned_docs/version-4.0.0/server/installation.md
index bc9729dc4e..3f4612046d 100644
--- a/versioned_docs/version-4.0.0/server/installation.md
+++ b/versioned_docs/version-4.0.0/server/installation.md
@@ -86,3 +86,9 @@ keploy test -c "CMD_TO_RUN_APP" --delay 10
 ```
 
 Explore the [Test Coverage Generation Guide](https://keploy.io/docs/server/sdk-installation/go/) for seeing test-coverage with your unit testing library and [Keploy Running Guide](https://keploy.io/docs/running-keploy/configuration-file/) for additional options and tips on customizing your Keploy setup to perfection.
+
+## Related
+
+- [Installing Keploy](/docs/server/installation/) — the full install guide with OS tabs.
+- [Keploy Go SDK — Install & Merge Test Coverage](/docs/server/sdk-installation/go/) — set up a language SDK.
+- [Keploy CLI Commands](/docs/running-keploy/cli-commands/) — commands to run after installing.
diff --git a/versioned_docs/version-4.0.0/server/installation_tabs.md b/versioned_docs/version-4.0.0/server/installation_tabs.md
index 76b0c5ac39..4164519df2 100644
--- a/versioned_docs/version-4.0.0/server/installation_tabs.md
+++ b/versioned_docs/version-4.0.0/server/installation_tabs.md
@@ -968,3 +968,9 @@ You’ve successfully set up **Keploy on Windows** using **Docker**.
 
 </TabItem>
 </Tabs>
+
+## Related
+
+- [Keploy Local Installation](/docs/server/install/) — the quick local install.
+- [Keploy Go SDK — Install & Merge Test Coverage](/docs/server/sdk-installation/go/) — set up a language SDK.
+- [Keploy CLI Commands](/docs/running-keploy/cli-commands/) — commands to run after installing.
diff --git a/versioned_docs/version-4.0.0/server/linux/installation.md b/versioned_docs/version-4.0.0/server/linux/installation.md
index 13ff68f7e6..1c20a6b1a6 100644
--- a/versioned_docs/version-4.0.0/server/linux/installation.md
+++ b/versioned_docs/version-4.0.0/server/linux/installation.md
@@ -22,6 +22,21 @@ keywords:
   - server-setup
 ---
 
+import HowTo from '@site/src/components/HowTo';
+
+<HowTo
+name="Install Keploy on Linux"
+description="Install the Keploy CLI on Linux, either via the one-click script or by downloading the binary."
+totalTime="PT5M"
+tools={["Linux", "curl", "Keploy CLI"]}
+steps={[
+{name: "One-click install", text: "Run: curl --silent -O -L https://keploy.io/install.sh && source install.sh"},
+{name: "Or install manually", text: "Download the Keploy binary from the latest release and move it to /usr/local/bin."},
+{name: "Verify", text: "Run keploy to confirm the CLI is installed and on your PATH."},
+]}
+visible={false}
+/>
+
 Keploy can be installed in two ways:
 
 1. [One-Click Install](#one-click-install-keploy).
diff --git a/versioned_docs/version-4.0.0/server/sdk-installation/go.md b/versioned_docs/version-4.0.0/server/sdk-installation/go.md
index 54879409b8..f28a56b005 100644
--- a/versioned_docs/version-4.0.0/server/sdk-installation/go.md
+++ b/versioned_docs/version-4.0.0/server/sdk-installation/go.md
@@ -19,6 +19,21 @@ keywords:
   - Go Test
 ---
 
+import HowTo from '@site/src/components/HowTo';
+
+<HowTo
+name="Merge Keploy test coverage in a Go application"
+description="Add graceful shutdown and run Keploy so Go test coverage from recorded API tests is captured and merged."
+totalTime="PT10M"
+tools={["Go", "Keploy CLI"]}
+steps={[
+{name: "Add graceful shutdown", text: "Add a GracefulShutdown handler that listens for SIGTERM/SIGKILL so coverage data is flushed when Keploy stops the app."},
+{name: "Run with coverage", text: "Run keploy test with Go coverage enabled to record which lines the replayed tests exercise."},
+{name: "Merge the reports", text: "Merge the Keploy coverage with your go test coverage into a single combined report."},
+]}
+visible={false}
+/>
+
 import ProductTier from '@site/src/components/ProductTier';
 
 <ProductTier tiers="Open Source, Enterprise" offerings="Self-Hosted, Dedicated" />
@@ -109,3 +124,9 @@ To get the coverage related information for merged coverage data :
 ```go
 go tool cover -func combined-coverage.txt
 ```
+
+## Related
+
+- [Java Agent for Dynamic Deduplication](/docs/server/sdk-installation/java/) — the Java SDK.
+- [Keploy JavaScript SDK — Install & Merge Test Coverage](/docs/server/sdk-installation/javascript/) — the JS SDK.
+- [Keploy Python SDK — Install & Merge Test Coverage](/docs/server/sdk-installation/python/) — the Python SDK.
diff --git a/versioned_docs/version-4.0.0/server/sdk-installation/java.md b/versioned_docs/version-4.0.0/server/sdk-installation/java.md
index d7da4884f2..2fdc251afe 100644
--- a/versioned_docs/version-4.0.0/server/sdk-installation/java.md
+++ b/versioned_docs/version-4.0.0/server/sdk-installation/java.md
@@ -16,6 +16,21 @@ keywords:
   - dynamic deduplication
 ---
 
+import HowTo from '@site/src/components/HowTo';
+
+<HowTo
+name="Set up the Keploy Java agent for dedup and coverage"
+description="Attach the Keploy and JaCoCo Java agents, then replay with dynamic deduplication enabled."
+totalTime="PT10M"
+tools={["Java", "Maven", "Keploy CLI"]}
+steps={[
+{name: "Copy the agents", text: "Use the maven-dependency-plugin to copy the Keploy Java agent and the JaCoCo agent into your build."},
+{name: "Run with both agents", text: "Start the application with the Keploy and JaCoCo javaagents attached so coverage is recorded."},
+{name: "Replay with dedup", text: "Run keploy test with dedup enabled to drop duplicate tests while replaying."},
+]}
+visible={false}
+/>
+
 import ProductTier from '@site/src/components/ProductTier';
 
 <ProductTier tiers="Enterprise" offerings="Self-Hosted, Dedicated" />
@@ -128,3 +143,9 @@ ENV KEPLOY_JAVA_CLASS_DIRS=/app/classes
 ## CI Guidance
 
 CI should run replay/test mode against checked-in Keploy test fixtures. Do not record Java dedup fixtures in the pipeline unless you intentionally want to refresh them.
+
+## Related
+
+- [Keploy Go SDK — Install & Merge Test Coverage](/docs/server/sdk-installation/go/) — the Go SDK.
+- [Keploy JavaScript SDK — Install & Merge Test Coverage](/docs/server/sdk-installation/javascript/) — the JS SDK.
+- [Keploy Python SDK — Install & Merge Test Coverage](/docs/server/sdk-installation/python/) — the Python SDK.
diff --git a/versioned_docs/version-4.0.0/server/sdk-installation/javascript.md b/versioned_docs/version-4.0.0/server/sdk-installation/javascript.md
index 4e07aefba5..8149b7f27d 100644
--- a/versioned_docs/version-4.0.0/server/sdk-installation/javascript.md
+++ b/versioned_docs/version-4.0.0/server/sdk-installation/javascript.md
@@ -22,6 +22,21 @@ keywords:
   - Typescript
 ---
 
+import HowTo from '@site/src/components/HowTo';
+
+<HowTo
+name="Merge Keploy test coverage in a JavaScript application"
+description="Install nyc and wire coverage scripts so Keploy and Jest coverage merge into one report."
+totalTime="PT10M"
+tools={["Node.js", "nyc", "Keploy CLI"]}
+steps={[
+{name: "Install nyc", text: "Install nyc, which Keploy uses to collect and merge JavaScript coverage."},
+{name: "Update package.json scripts", text: "Add coverage and coverage:merge scripts that run your tests with coverage and merge the output."},
+{name: "Run and merge", text: "Run keploy test, then merge the nyc and Keploy coverage into a single lcov report."},
+]}
+visible={false}
+/>
+
 import ProductTier from '@site/src/components/ProductTier';
 
 <ProductTier tiers="Open Source, Enterprise" offerings="Self-Hosted, Dedicated" />
@@ -96,3 +111,9 @@ To get coverage related information for merged coverage data, Run:
 ```bash
 npm run coverage:report
 ```
+
+## Related
+
+- [Keploy Go SDK — Install & Merge Test Coverage](/docs/server/sdk-installation/go/) — the Go SDK.
+- [Java Agent for Dynamic Deduplication](/docs/server/sdk-installation/java/) — the Java SDK.
+- [Keploy Python SDK — Install & Merge Test Coverage](/docs/server/sdk-installation/python/) — the Python SDK.
diff --git a/versioned_docs/version-4.0.0/server/sdk-installation/python.md b/versioned_docs/version-4.0.0/server/sdk-installation/python.md
index 16b75c0f92..21e16de857 100644
--- a/versioned_docs/version-4.0.0/server/sdk-installation/python.md
+++ b/versioned_docs/version-4.0.0/server/sdk-installation/python.md
@@ -17,6 +17,21 @@ keywords:
   - Pytest
 ---
 
+import HowTo from '@site/src/components/HowTo';
+
+<HowTo
+name="Merge Keploy test coverage in a Python application"
+description="Install coverage.py and run Keploy so recorded API tests produce a combined coverage report."
+totalTime="PT10M"
+tools={["Python", "coverage.py", "Keploy CLI"]}
+steps={[
+{name: "Install coverage", text: "Run pip install coverage so Keploy can record Python coverage."},
+{name: "Run the tests", text: "Run keploy test -c \"<command to run your app>\" to replay tests and generate coverage data."},
+{name: "Combine the report", text: "Combine the coverage data into a single report to view total covered lines."},
+]}
+visible={false}
+/>
+
 import ProductTier from '@site/src/components/ProductTier';
 
 <ProductTier tiers="Open Source, Enterprise" offerings="Self-Hosted, Dedicated" />
@@ -89,3 +104,9 @@ and if you want the coverage in an html file, you can run:
 ```bash
 coverage html
 ```
+
+## Related
+
+- [Keploy Go SDK — Install & Merge Test Coverage](/docs/server/sdk-installation/go/) — the Go SDK.
+- [Java Agent for Dynamic Deduplication](/docs/server/sdk-installation/java/) — the Java SDK.
+- [Keploy JavaScript SDK — Install & Merge Test Coverage](/docs/server/sdk-installation/javascript/) — the JS SDK.
diff --git a/versioned_docs/version-4.0.0/server/windows/installation.md b/versioned_docs/version-4.0.0/server/windows/installation.md
index 32db955b3e..0e6e23878b 100644
--- a/versioned_docs/version-4.0.0/server/windows/installation.md
+++ b/versioned_docs/version-4.0.0/server/windows/installation.md
@@ -21,6 +21,21 @@ keywords:
   - docker
 ---
 
+import HowTo from '@site/src/components/HowTo';
+
+<HowTo
+name="Install Keploy on Windows using WSL"
+description="Install Keploy on Windows by running it inside WSL, via the one-click script or Docker."
+totalTime="PT10M"
+tools={["Windows", "WSL", "Keploy CLI"]}
+steps={[
+{name: "Enable WSL", text: "Install WSL and an Ubuntu distribution (recommended Ubuntu-22.04) from an elevated terminal."},
+{name: "One-click install", text: "Inside the WSL shell run: curl --silent -O https://keploy.io/install.sh && source install.sh"},
+{name: "Or use Docker", text: "Alternatively run Keploy via Docker Desktop with the WSL 2 backend enabled."},
+]}
+visible={false}
+/>
+
 Keploy can be installed in two ways:
 
 1. [One-Click Install](#one-click-install-keploy).