diff --git a/.github/workflows/framework-candidate.yml b/.github/workflows/framework-candidate.yml
new file mode 100644
index 0000000..d41b00c
--- /dev/null
+++ b/.github/workflows/framework-candidate.yml
@@ -0,0 +1,68 @@
+name: Framework candidate validation
+
+on:
+  pull_request:
+    branches: ['main']
+  push:
+    branches: ['main']
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: framework-candidate-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  validate:
+    name: Validate framework candidate
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Set up Node
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Lint
+        run: npm run lint
+
+      - name: Test theme bootstrap
+        run: npm run test:theme-bootstrap
+
+      - name: Test SEO
+        run: npm run test:seo
+
+      - name: Test content route data
+        run: npm run test:content-route-data
+
+      - name: Build current SPA
+        run: npm run build
+
+      - name: Build framework candidate
+        shell: bash
+        run: |
+          started_at=$SECONDS
+          npm run build:framework
+          duration=$((SECONDS - started_at))
+          echo "Framework build duration: ${duration}s"
+          echo "Framework build duration: ${duration}s" >> "$GITHUB_STEP_SUMMARY"
+          if (( duration > 60 )); then
+            echo "::error::Framework build exceeded the 60-second budget (${duration}s)."
+            exit 1
+          fi
+
+      - name: Finalize framework candidate
+        run: npm run finalize:framework
+
+      - name: Validate framework candidate
+        run: npm run validate:framework
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index d909feb..29d4b01 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -1,8 +1,6 @@
 name: Deploy static content to Pages
 
 on:
-  push:
-    branches: ['main']
   workflow_dispatch:
 
 permissions:
@@ -16,6 +14,9 @@ concurrency:
 
 jobs:
   deploy:
+    name: Validate and deploy current SPA
+    if: github.ref == 'refs/heads/main'
+    timeout-minutes: 15
     environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}
@@ -28,15 +29,46 @@ jobs:
       - name: Set up Node
         uses: actions/setup-node@v6
         with:
-          node-version: lts/*
+          node-version: 22
           cache: 'npm'
 
       - name: Install dependencies
         run: npm ci
 
-      - name: Build
+      - name: Lint
+        run: npm run lint
+
+      - name: Test theme bootstrap
+        run: npm run test:theme-bootstrap
+
+      - name: Test SEO
+        run: npm run test:seo
+
+      - name: Test content route data
+        run: npm run test:content-route-data
+
+      - name: Build current SPA
         run: npm run build
 
+      - name: Build framework candidate
+        shell: bash
+        run: |
+          started_at=$SECONDS
+          npm run build:framework
+          duration=$((SECONDS - started_at))
+          echo "Framework build duration: ${duration}s"
+          echo "Framework build duration: ${duration}s" >> "$GITHUB_STEP_SUMMARY"
+          if (( duration > 60 )); then
+            echo "::error::Framework build exceeded the 60-second budget (${duration}s)."
+            exit 1
+          fi
+
+      - name: Finalize framework candidate
+        run: npm run finalize:framework
+
+      - name: Validate framework candidate
+        run: npm run validate:framework
+
       - name: Create SPA fallback
         run: cp dist/index.html dist/404.html
 
diff --git a/.gitignore b/.gitignore
index ea4b6a9..fd4092d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,6 +10,9 @@ lerna-debug.log*
 node_modules
 dist
 dist-ssr
+/.react-router/
+/spikes/react-router-7-ssg/build/
+/build-framework/
 *.local
 /.playwright-cli/
 
diff --git a/AGENTS.md b/AGENTS.md
index 09b310a..17bad1b 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -67,8 +67,36 @@ npm run lint
 npm run preview
 ```
 
+Framework migration candidate commands:
+
+```bash
+npm run build:framework
+npm run finalize:framework
+npm run validate:framework
+npm run preview:framework
+```
+
 Important: `npm run dev` and `npm run build` both generate the curriculum manifest first through the configured pre-scripts. If curriculum content or question markers are changed, make sure the generated manifest still works.
 
+The project currently uses a dual-build cutover. `npm run build` writes the
+deployable SPA to `dist/`. `npm run build:framework` writes the React Router
+static/pre-render candidate to `build-framework/client/`.
+`npm run finalize:framework` writes the candidate sitemap, candidate
+`robots.txt`, and dedicated `404.html` into that client output. Do not switch
+the GitHub Pages deployment artifact until the framework route matrix, fallback
+handling, and production URLs pass their dedicated cutover validation.
+
+GitHub Actions intentionally separates validation from deployment:
+
+* `.github/workflows/framework-candidate.yml` runs the dual-build validation
+  gate for pull requests and pushes to `main`, but has read-only permissions and
+  does not upload or deploy a Pages artifact. It is advisory until repository
+  branch protection is explicitly updated.
+* `.github/workflows/main.yml` is manual-only, runs the same validation gate,
+  and continues to deploy the existing `dist/` SPA from `main`.
+* Do not make the candidate workflow a required branch check or change the
+  deployed directory to `build-framework/client/` without explicit approval.
+
 ## Important Project Areas
 
 ### Main Routes
@@ -94,6 +122,8 @@ The application includes these important routes:
 
 Do not break existing route behavior unless explicitly requested.
 
+Canonical public SEO URLs should use trailing slashes, for example `/content/`, `/content/:topicId/`, `/roadmap/`, `/about-us/`, `/privacy/`, and `/terms/`. Non-trailing variants may continue to work for user convenience, but they should not be used in sitemap URLs, canonical tags, Open Graph URLs, structured data URLs, or internal generated SEO links.
+
 ### Content System
 
 The curriculum is Markdown-driven.
@@ -309,7 +339,7 @@ Important behavior:
   * The progress section should be hidden.
   * The "On This Page" section should not show "Interview Practice".
 * `/content/:topicId` displays the selected curriculum topic.
-* Invalid topic IDs should redirect to the first available topic.
+* Invalid topic IDs should render a clear Not Found state with `noindex`, not redirect to the first available topic.
 * The left panel contains the curriculum navigation.
 * The main area renders Markdown content.
 * The right panel contains "On This Page", topic progress, and interview practice navigation when applicable.
@@ -524,6 +554,8 @@ Before changing code:
 7. Avoid unrelated refactors.
 8. Avoid renaming public IDs, slugs, routes, or question markers unless required.
 9. Run validation commands when possible.
+10. Create a local Git commit after each completed implementation step.
+11. Ask the user for permission before pushing or reverting changes.
 
 After changing code, report:
 
@@ -562,6 +594,35 @@ When a task affects routing, check:
 * Navigation links
 * GitHub Pages or production base path compatibility
 
+## SEO and Pre-rendering Rules
+
+Follow the SEO plan in `docs/plans/dev-net-core-seo-improvement-plan.md` when working on metadata, routing, sitemap output, pre-rendering, or production deployment behavior.
+
+Important SEO route rules:
+
+* `/content/:topicId/` is the primary searchable landing page for each curriculum topic.
+* `/practice/:topicId/`, `/simulation/*`, `/bug-report/`, and utility/user-flow routes are `noindex` and excluded from the sitemap by default.
+* `/practice/:topicId/` should stay out of the sitemap unless it is later redesigned as a standalone searchable page with unique visible content.
+* `/simulation/` and `/changelog/` are optional sitemap routes only if they have enough unique visible source HTML content and are intended to rank.
+* Invalid content or practice topic IDs should render Not Found + `noindex`; do not redirect them to another valid topic.
+* Do not block `noindex` pages in `robots.txt`; crawlers must be able to read the `noindex` directive.
+
+Sitemap and static output rules:
+
+* Every sitemap URL must be absolute, canonical, trailing-slash, indexable, direct-loadable, and production validated.
+* A sitemap URL must return `200 OK` on direct production load and must not redirect.
+* A sitemap URL must have route-specific source HTML metadata and visible source HTML content.
+* A sitemap URL must have matching static/pre-rendered output and must not depend on the GitHub Pages `404.html` SPA fallback.
+* Do not include routes in `sitemap.xml` until their production static/pre-rendered output is validated.
+* Submit the sitemap to Google Search Console only after the production validation gate passes.
+* A generated public `404.html` must be a dedicated Not Found + `noindex` document, not a blind copy of the homepage.
+
+Build and metadata ownership rules:
+
+* Markdown frontmatter and the generated curriculum/SEO manifests are the source of truth for content metadata.
+* Shared SEO metadata should drive sitemap generation, pre-rendered HTML, React route metadata, Open Graph tags, Twitter/X tags, and JSON-LD.
+* Framework finalization must preserve React Router/Vite-generated hashed assets. Deploy only the final public client output and never a private server/static build.
+
 ## GitHub Pages and Domain Notes
 
 The production website is:
diff --git a/app/entry.server.tsx b/app/entry.server.tsx
new file mode 100644
index 0000000..95df630
--- /dev/null
+++ b/app/entry.server.tsx
@@ -0,0 +1,36 @@
+import { PassThrough } from "node:stream";
+import { createReadableStreamFromReadable } from "@react-router/node";
+import type { EntryContext } from "react-router";
+import { ServerRouter } from "react-router";
+import { renderToPipeableStream } from "react-dom/server";
+
+export default function handleRequest(
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  routerContext: EntryContext
+) {
+  return new Promise<Response>((resolve, reject) => {
+    const { pipe } = renderToPipeableStream(
+      <ServerRouter context={routerContext} url={request.url} />,
+      {
+        onAllReady() {
+          const body = new PassThrough();
+          const stream = createReadableStreamFromReadable(body);
+
+          responseHeaders.set("Content-Type", "text/html");
+          pipe(body);
+          resolve(
+            new Response(stream, {
+              headers: responseHeaders,
+              status: responseStatusCode,
+            })
+          );
+        },
+        onShellError(error) {
+          reject(error);
+        },
+      }
+    );
+  });
+}
diff --git a/app/lib/contentRouteData.server.ts b/app/lib/contentRouteData.server.ts
new file mode 100644
index 0000000..bab3032
--- /dev/null
+++ b/app/lib/contentRouteData.server.ts
@@ -0,0 +1 @@
+export { loadContentRouteData } from "../../shared/content/loadContentRouteData.mjs";
diff --git a/app/root.tsx b/app/root.tsx
new file mode 100644
index 0000000..815793e
--- /dev/null
+++ b/app/root.tsx
@@ -0,0 +1,87 @@
+import type { ReactNode } from "react";
+import {
+  Links,
+  Meta,
+  Navigate,
+  Outlet,
+  Scripts,
+  ScrollRestoration,
+  useLocation,
+} from "react-router";
+import "../src/App.css";
+import "../src/index.css";
+import { AppProviders } from "../src/AppProviders";
+import { getCanonicalPathname } from "../src/routing/canonicalPath";
+
+export function Layout({ children }: { children: ReactNode }) {
+  return (
+    <html lang="en">
+      <head>
+        <meta charSet="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <link rel="icon" type="image/png" href="/icon.png" />
+        <script src="/theme-bootstrap.js" />
+        <Meta />
+        <Links />
+      </head>
+      <body>
+        {children}
+        <ScrollRestoration />
+        <Scripts />
+      </body>
+    </html>
+  );
+}
+
+export default function Root() {
+  return (
+    <AppProviders hydrateBrowserPersistence>
+      <CanonicalOutlet />
+    </AppProviders>
+  );
+}
+
+export function HydrateFallback() {
+  return (
+    <main className="theme-page flex min-h-screen items-center justify-center px-6">
+      <section className="theme-content-card max-w-xl rounded-lg p-8 text-center">
+        <p className="gleeple-heading theme-accent text-sm font-semibold uppercase">
+          Error 404
+        </p>
+        <h1 className="gleeple-heading theme-text mt-3 text-3xl font-semibold">
+          404 - Page Not Found
+        </h1>
+        <p className="theme-muted mt-4">
+          The requested DEV_NET_CORE page could not be found.
+        </p>
+        <a
+          className="gleeple-heading theme-accent mt-6 inline-block font-semibold"
+          href="/"
+        >
+          Return home
+        </a>
+      </section>
+    </main>
+  );
+}
+
+function CanonicalOutlet() {
+  const location = useLocation();
+  const canonicalPathname = getCanonicalPathname(location.pathname);
+
+  if (canonicalPathname) {
+    return (
+      <Navigate
+        replace
+        state={location.state}
+        to={{
+          hash: location.hash,
+          pathname: canonicalPathname,
+          search: location.search,
+        }}
+      />
+    );
+  }
+
+  return <Outlet />;
+}
diff --git a/app/routes.ts b/app/routes.ts
new file mode 100644
index 0000000..e73f277
--- /dev/null
+++ b/app/routes.ts
@@ -0,0 +1,34 @@
+import {
+  index,
+  layout,
+  route,
+  type RouteConfig,
+} from "@react-router/dev/routes";
+
+const pageModule = "./routes/page.tsx";
+const contentModule = "./routes/content.tsx";
+
+export default [
+  layout("./routes/main-layout.tsx", [
+    index(pageModule, { id: "home" }),
+    route("content/", contentModule, { id: "content-index" }),
+    route("content/:topicId/", contentModule, { id: "content-topic" }),
+    route("about-us/", pageModule, { id: "about-us" }),
+    route("bug-report/", pageModule, { id: "bug-report" }),
+    route("changelog/", pageModule, { id: "changelog" }),
+    route("privacy/", pageModule, { id: "privacy" }),
+    route("roadmap/", pageModule, { id: "roadmap" }),
+    route("terms/", pageModule, { id: "terms" }),
+    route("practice/", pageModule, { id: "practice-index" }),
+    route("practice/:topicId/", pageModule, { id: "practice-topic" }),
+    route("simulation/", pageModule, { id: "simulation-index" }),
+    route("simulation/setup/", pageModule, { id: "simulation-setup" }),
+    route("simulation/session/:sessionId", pageModule, {
+      id: "simulation-session",
+    }),
+    route("simulation/result/:sessionId", pageModule, {
+      id: "simulation-result",
+    }),
+    route("*", pageModule, { id: "not-found" }),
+  ]),
+] satisfies RouteConfig;
diff --git a/app/routes/content.tsx b/app/routes/content.tsx
new file mode 100644
index 0000000..91d0963
--- /dev/null
+++ b/app/routes/content.tsx
@@ -0,0 +1,79 @@
+import type {
+  ClientLoaderFunctionArgs,
+  LoaderFunctionArgs,
+  MetaFunction,
+} from "react-router";
+import { useLoaderData } from "react-router";
+import {
+  buildSeoMetadata,
+  type SeoContentEntry,
+} from "../../shared/seo/buildSeoMetadata.mjs";
+import { loadClientContentRouteData } from "../../src/components/content/loadClientContentRouteData";
+import type { ContentRouteData } from "../../src/components/content/contentRouteData";
+import Content from "../../src/pages/Content";
+import { loadContentRouteData } from "../lib/contentRouteData.server";
+import {
+  createMetaDescriptors,
+  StructuredData,
+} from "../seo/routeMetadata";
+
+export function loader({ params }: LoaderFunctionArgs) {
+  return loadContentRouteData(params.topicId);
+}
+
+export async function clientLoader({
+  params,
+  serverLoader,
+}: ClientLoaderFunctionArgs) {
+  try {
+    return (await serverLoader()) as ContentRouteData;
+  } catch {
+    return loadClientContentRouteData(params.topicId);
+  }
+}
+
+export const meta: MetaFunction = ({ data, location }) => {
+  const routeData = data as ContentRouteData | undefined;
+  const contentEntry =
+    routeData?.kind === "topic"
+      ? (routeData.topic as SeoContentEntry)
+      : undefined;
+
+  return createMetaDescriptors(
+    buildSeoMetadata({
+      contentEntry,
+      pathname: location.pathname,
+    })
+  );
+};
+
+export function HydrateFallback() {
+  return (
+    <div className="theme-page min-h-screen pt-24 text-center">
+      Loading content...
+    </div>
+  );
+}
+
+export default function ContentRoute() {
+  const routeData = useLoaderData<typeof loader>();
+  const metadata = buildSeoMetadata({
+    contentEntry:
+      routeData.kind === "topic"
+        ? (routeData.topic as SeoContentEntry)
+        : undefined,
+    pathname:
+      routeData.kind === "topic"
+        ? routeData.topic.canonicalPath
+        : routeData.kind === "welcome"
+          ? "/content/"
+          : `/content/${routeData.topicId}/`,
+  });
+
+  return (
+    <>
+      <StructuredData value={metadata.structuredData} />
+      <Content initialRouteData={routeData} />
+    </>
+  );
+}
diff --git a/app/routes/main-layout.tsx b/app/routes/main-layout.tsx
new file mode 100644
index 0000000..b7f45c3
--- /dev/null
+++ b/app/routes/main-layout.tsx
@@ -0,0 +1 @@
+export { MainLayout as default } from "../../src/layouts/MainLayout";
diff --git a/app/routes/page.tsx b/app/routes/page.tsx
new file mode 100644
index 0000000..395654c
--- /dev/null
+++ b/app/routes/page.tsx
@@ -0,0 +1,90 @@
+import type { MetaFunction } from "react-router";
+import { useLocation } from "react-router";
+import { buildSeoMetadata } from "../../shared/seo/buildSeoMetadata.mjs";
+import AboutUs from "../../src/pages/AboutUs";
+import BugReport from "../../src/pages/BugReport";
+import Changelog from "../../src/pages/Changelog";
+import Home from "../../src/pages/Home";
+import NotFound from "../../src/pages/NotFound";
+import Practice from "../../src/pages/Practice";
+import Privacy from "../../src/pages/Privacy";
+import Roadmap from "../../src/pages/Roadmap";
+import Simulation from "../../src/pages/Simulation";
+import SimulationResult from "../../src/pages/SimulationResult";
+import SimulationSession from "../../src/pages/SimulationSession";
+import Terms from "../../src/pages/Terms";
+import { curriculumManifest } from "../../src/contents/curriculumManifest.generated";
+import {
+  createMetaDescriptors,
+  StructuredData,
+} from "../seo/routeMetadata";
+
+const curriculumEntriesById = new Map(
+  curriculumManifest.map((entry) => [entry.id, entry])
+);
+
+export const meta: MetaFunction = ({ location }) =>
+  createMetaDescriptors(getPageMetadata(location.pathname));
+
+export default function PageRoute() {
+  const { pathname } = useLocation();
+  const metadata = getPageMetadata(pathname);
+
+  return (
+    <>
+      <StructuredData value={metadata.structuredData} />
+      {renderPage(pathname)}
+    </>
+  );
+}
+
+function renderPage(pathname: string) {
+  switch (pathname) {
+    case "/":
+      return <Home />;
+    case "/about-us/":
+      return <AboutUs />;
+    case "/bug-report/":
+      return <BugReport />;
+    case "/changelog/":
+      return <Changelog />;
+    case "/practice/":
+      return <Practice />;
+    case "/privacy/":
+      return <Privacy />;
+    case "/roadmap/":
+      return <Roadmap />;
+    case "/simulation/":
+    case "/simulation/setup/":
+      return <Simulation />;
+    case "/terms/":
+      return <Terms />;
+  }
+
+  if (/^\/practice\/[^/]+\/$/.test(pathname)) {
+    return <Practice />;
+  }
+
+  if (/^\/simulation\/session\/[^/]+\/?$/.test(pathname)) {
+    return <SimulationSession />;
+  }
+
+  if (/^\/simulation\/result\/[^/]+\/?$/.test(pathname)) {
+    return <SimulationResult />;
+  }
+
+  return <NotFound />;
+}
+
+function getPageMetadata(pathname: string) {
+  const topicId = pathname.match(
+    /^\/practice\/([a-z0-9][a-z0-9-]*)\/$/
+  )?.[1];
+
+  return buildSeoMetadata({
+    contentEntry: topicId
+      ? curriculumEntriesById.get(topicId)
+      : undefined,
+    pathname,
+  });
+}
diff --git a/app/seo/routeMetadata.tsx b/app/seo/routeMetadata.tsx
new file mode 100644
index 0000000..cc8b4ce
--- /dev/null
+++ b/app/seo/routeMetadata.tsx
@@ -0,0 +1,76 @@
+import type { MetaDescriptor } from "react-router";
+import type {
+  SeoMetadata,
+  SeoStructuredData,
+} from "../../shared/seo/buildSeoMetadata.mjs";
+
+export function createMetaDescriptors(
+  metadata: SeoMetadata
+): MetaDescriptor[] {
+  const descriptors: MetaDescriptor[] = [
+    { title: metadata.title },
+    { name: "description", content: metadata.description },
+    { name: "robots", content: metadata.robots },
+    { property: "og:title", content: metadata.openGraph.title },
+    {
+      property: "og:description",
+      content: metadata.openGraph.description,
+    },
+    { property: "og:type", content: metadata.openGraph.type },
+    { property: "og:image", content: metadata.openGraph.image },
+    {
+      property: "og:image:width",
+      content: String(metadata.openGraph.imageWidth),
+    },
+    {
+      property: "og:image:height",
+      content: String(metadata.openGraph.imageHeight),
+    },
+    {
+      property: "og:image:alt",
+      content: metadata.openGraph.imageAlt,
+    },
+    { name: "twitter:card", content: metadata.twitter.card },
+    { name: "twitter:title", content: metadata.twitter.title },
+    {
+      name: "twitter:description",
+      content: metadata.twitter.description,
+    },
+    { name: "twitter:image", content: metadata.twitter.image },
+  ];
+
+  if (metadata.canonicalUrl) {
+    descriptors.push({
+      tagName: "link",
+      rel: "canonical",
+      href: metadata.canonicalUrl,
+    });
+  }
+
+  if (metadata.openGraph.url) {
+    descriptors.push({
+      property: "og:url",
+      content: metadata.openGraph.url,
+    });
+  }
+
+  return descriptors;
+}
+
+export function StructuredData({
+  value,
+}: {
+  value: SeoStructuredData | null;
+}) {
+  if (!value) {
+    return null;
+  }
+
+  return (
+    <script
+      data-dev-net-core-seo="structured-data"
+      dangerouslySetInnerHTML={{ __html: JSON.stringify(value) }}
+      type="application/ld+json"
+    />
+  );
+}
diff --git a/build/vite/rawMarkdownHashPathPlugin.ts b/build/vite/rawMarkdownHashPathPlugin.ts
new file mode 100644
index 0000000..3a8395f
--- /dev/null
+++ b/build/vite/rawMarkdownHashPathPlugin.ts
@@ -0,0 +1,36 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const rawMarkdownHashPathPrefix = "\0raw-markdown-hash-path:";
+
+export function rawMarkdownHashPathPlugin() {
+  return {
+    name: "raw-markdown-hash-path",
+    enforce: "pre" as const,
+    resolveId(source: string, importer?: string) {
+      if (!importer || !source.includes("#") || !source.includes(".md?raw")) {
+        return null;
+      }
+
+      const [filePath] = source.split("?");
+      const importerPath = importer.split("?")[0];
+      const resolvedPath = path.resolve(path.dirname(importerPath), filePath);
+
+      if (!fs.existsSync(resolvedPath)) {
+        return null;
+      }
+
+      return `${rawMarkdownHashPathPrefix}${resolvedPath}`;
+    },
+    load(id: string) {
+      if (!id.startsWith(rawMarkdownHashPathPrefix)) {
+        return null;
+      }
+
+      const filePath = id.slice(rawMarkdownHashPathPrefix.length);
+      const markdown = fs.readFileSync(filePath, "utf8");
+
+      return `export default ${JSON.stringify(markdown)};`;
+    },
+  };
+}
diff --git a/docs/architecture/framework-routing-dual-build.md b/docs/architecture/framework-routing-dual-build.md
new file mode 100644
index 0000000..c264d02
--- /dev/null
+++ b/docs/architecture/framework-routing-dual-build.md
@@ -0,0 +1,84 @@
+# Framework Routing Dual-Build Cutover
+
+Task 11A2 introduces a production-shaped React Router framework build without
+changing the current GitHub Pages deployment artifact.
+
+## Build Ownership
+
+- `npm run build` remains the deployable Vite SPA build and writes `dist/`.
+- `npm run build:framework` builds the migration candidate and writes
+  `build-framework/client/`.
+- React Router uses `ssr: false`; no request-time Node server is required.
+- The temporary framework server bundle is removed after pre-rendering.
+- The manual deployment workflow continues to publish `dist/` until a separate
+  cutover task is approved.
+
+## GitHub Actions Ownership
+
+- `.github/workflows/framework-candidate.yml` runs on pull requests and pushes
+  to `main`, plus manual dispatch. It has read-only repository permissions,
+  builds both outputs, finalizes and validates the framework output, and never
+  uploads or deploys a Pages artifact.
+- The candidate check is initially advisory. After several stable GitHub runs
+  confirm timing and reliability, it can be made required through repository
+  branch protection settings.
+- `.github/workflows/main.yml` is manual-only and restricted to `main`. It runs
+  the complete validation gate before publishing the existing `dist/` SPA.
+- Candidate and deployment workflows use separate concurrency groups, so
+  validation cannot cancel or replace a deployment.
+
+## Framework Output
+
+The framework build pre-renders:
+
+- `/`
+- `/content/`
+- Every valid `/content/:topicId/` route from the curriculum SEO manifest
+- `/roadmap/`
+- `/about-us/`
+- `/privacy/`
+- `/terms/`
+
+App-only and noindex routes use `__spa-fallback.html` and are not treated as
+valid sitemap artifacts.
+
+## Validation
+
+Run:
+
+```bash
+npm run build:framework
+npm run finalize:framework
+npm run validate:framework
+npm run preview:framework
+```
+
+`finalize:framework` writes `sitemap.xml`, candidate `robots.txt`, and the
+dedicated Not Found + `noindex` `404.html` into `build-framework/client/`.
+
+`validate:framework` checks that every expected static route has visible source
+HTML, self-canonical metadata, Open Graph metadata, and the required route
+artifact. It parses the sitemap, validates the dedicated fallback, enforces
+output budgets, confirms that app-only routes were not emitted as static
+sitemap pages, and confirms that the existing `dist/index.html` SPA artifact
+still exists.
+
+The final hosting cutover still needs explicit GitHub Pages fallback/output
+handling and production URL validation. `__spa-fallback.html` must not be
+counted as static output for any sitemap URL.
+
+## Candidate Output Budgets
+
+The first sitemap release uses these guardrails:
+
+- Maximum public client output: 80 MiB
+- Maximum route HTML: 512 KiB
+- Maximum route-data file: 100 KiB
+- Maximum pre-rendered routes: 250
+- Maximum framework build duration in CI: 60 seconds
+
+`validate:framework` enforces the size and route-count budgets. Both GitHub
+workflows record framework build duration in the run summary and fail when the
+build exceeds 60 seconds. The current duplicated Markdown in route HTML and
+route data is accepted for the first cutover while these limits pass; optimize
+it later if growth approaches a budget.
diff --git a/docs/dev-net-core-seo-plan-handoff.md b/docs/dev-net-core-seo-plan-handoff.md
new file mode 100644
index 0000000..b8c0e85
--- /dev/null
+++ b/docs/dev-net-core-seo-plan-handoff.md
@@ -0,0 +1,625 @@
+# DEV_NET_CORE SEO Plan Handoff
+
+Last updated: 2026-06-28
+
+This document summarizes the SEO planning and implementation conversation so a
+new AI agent can continue without access to the original chat.
+
+## Start Here
+
+Read these files before making changes:
+
+1. `AGENTS.md`
+2. `docs/plans/dev-net-core-seo-improvement-plan.md`
+3. `docs/spikes/react-router-7-ssg-spike.md`
+4. `docs/architecture/framework-routing-dual-build.md`
+5. `docs/plans/structured-data-rules.md`
+
+The detailed SEO plan is currently untracked in Git:
+
+```txt
+docs/plans/dev-net-core-seo-improvement-plan.md
+```
+
+Do not delete, overwrite, stage, or commit that file unless the user explicitly
+asks. It contains the refined plan and remains the main planning reference.
+
+## Project and Hosting Context
+
+- Product: DEV_NET_CORE, a technical interview preparation website.
+- Production URL: `https://www.dev-net-core.com/`
+- Repository: `https://github.com/CircleQMinh/dev-net-core`
+- Stack: React 19, TypeScript, Vite, React Router 7.18, Redux Toolkit, MUI,
+  Tailwind CSS, and Markdown curriculum content.
+- Current host: GitHub Pages.
+- Domain/DNS: custom domain managed through Cloudflare.
+- Cloudflare is not the application host unless a later migration explicitly
+  moves the site to Cloudflare Pages.
+- The apex/root domain has already been deployed and validated.
+- Runtime SSR is not required or planned while GitHub Pages remains the host.
+- Vite `base: "/"` is correct for the current custom root domain.
+
+## Final Decisions
+
+These decisions supersede earlier alternatives discussed in the conversation.
+
+### Canonical URLs
+
+- Canonical public URLs use trailing slashes.
+- Examples:
+  - `/content/`
+  - `/content/async-and-await-semantics-in-csharp/`
+  - `/roadmap/`
+  - `/about-us/`
+- Non-trailing variants may work for user convenience, but must not be used in:
+  - sitemap URLs
+  - canonical tags
+  - Open Graph URLs
+  - structured data URLs
+  - generated internal SEO links
+- Non-trailing client redirects do not prove that GitHub Pages returns the
+  correct production status. Hosting behavior must be validated separately.
+
+### Sitemap Eligibility
+
+Every sitemap URL must be:
+
+- absolute
+- canonical
+- trailing-slash
+- indexable
+- direct-loadable
+- backed by a static/pre-rendered artifact
+- returning `200 OK`
+- not redirected
+- not blocked by `robots.txt`
+- not marked `noindex`
+- unique in the sitemap
+- populated with route-specific source HTML metadata and visible source content
+
+`Sitemap = Yes` means:
+
+```txt
+indexable + canonical + static/pre-rendered + production validated
+```
+
+A route must not be included merely because the React SPA can catch it through
+`404.html`.
+
+### Indexability
+
+Primary SEO assets:
+
+- `/`
+- `/content/`
+- `/content/:topicId/`
+- `/roadmap/`
+- `/about-us/`
+- `/privacy/`
+- `/terms/`
+
+Noindex and excluded from the sitemap by default:
+
+- `/practice/`
+- `/practice/:topicId/`
+- `/simulation/setup/`
+- `/simulation/session/:sessionId`
+- `/simulation/result/:sessionId`
+- `/bug-report/`
+- invalid routes
+
+Optional only if intentionally improved and made search-worthy:
+
+- `/simulation/`
+- `/changelog/`
+
+The main searchable page for a topic is `/content/:topicId/`. Practice pages
+remain useful application routes but should stay noindex unless they gain
+substantial, unique search-oriented content.
+
+### Invalid Routes
+
+- Invalid content and practice topic IDs render a clear Not Found state.
+- They must include `noindex`.
+- They must not redirect to the first valid topic.
+- A real HTTP `404` is preferred where hosting allows it.
+- If GitHub Pages serves a `200` SPA fallback, the rendered page must still show
+  Not Found and `noindex`.
+- The final `404.html` must be a dedicated Not Found + `noindex` document, not a
+  blind copy of the homepage.
+
+### Robots and Noindex
+
+- Do not block noindex pages in `robots.txt`.
+- Crawlers must be able to fetch a page to see its `noindex` directive.
+- Use `robots.txt` for crawl control and `noindex` for search-result exclusion.
+- Current `public/robots.txt` only contains:
+
+```txt
+User-agent: *
+Allow: /
+```
+
+- It does not yet advertise a sitemap because the final production sitemap has
+  not been generated or deployed.
+
+### Metadata Source of Truth
+
+The intended pipeline is:
+
+```txt
+Markdown frontmatter
+  -> generated curriculum/SEO manifests
+  -> shared metadata builder
+  -> React route metadata
+  -> pre-rendered source HTML
+  -> sitemap
+```
+
+Supported content SEO fields:
+
+```yaml
+seoTitle: Async and Await in C# Interview Questions
+seoDescription: Learn async and await in C# for technical interviews...
+canonicalPath: /content/async-await/
+```
+
+Rules:
+
+- Custom frontmatter metadata is preferred.
+- Generated fallbacks are allowed during transition.
+- Do not manually maintain `lastmod`.
+- Omit `<lastmod>` unless an automated source can keep it accurate.
+- Do not use `<priority>` or `<changefreq>`.
+- The current build reports 220 fallback titles and 220 fallback descriptions
+  across 221 curriculum entries. Metadata rollout remains pending/optional.
+
+The implementation does not use `react-helmet-async`. The SPA uses a custom
+`Seo` component, while the framework candidate uses React Router route `meta`
+exports. Both consume the same plain `.mjs` metadata builder.
+
+### Social Metadata
+
+- Default image:
+  `public/og/default-og-image.png`
+- Public URL:
+  `https://www.dev-net-core.com/og/default-og-image.png`
+- Dimensions: `1200x630`
+- Format: PNG
+- Every page should use the default image unless a custom image is later added.
+- Open Graph and Twitter/X image URLs must be absolute and available without
+  JavaScript.
+
+### Structured Data
+
+- Structured data must match visible content.
+- Do not invent author, publisher, rating, review, FAQ, or date facts.
+- Homepage uses `WebSite` JSON-LD.
+- Valid content pages use `Article` JSON-LD.
+- Noindex and invalid pages do not receive structured data.
+- The shared metadata builder owns canonical, Open Graph, Twitter/X, and
+  JSON-LD data to prevent drift.
+
+### Content Quality
+
+If `/practice/:topicId/` is noindex, the matching `/content/:topicId/` page must
+fully satisfy search intent. Indexable content pages should contain:
+
+- a clear H1
+- a strong opening explanation
+- core concepts
+- practical examples
+- trade-offs
+- common mistakes
+- best practices
+- interview questions and expected answers
+- related internal links
+
+A subtopic is currently considered ready when its Markdown file exists. No
+separate per-topic readiness flag is required.
+
+## Chosen Rendering Architecture
+
+React Router framework-mode static generation was chosen after a spike.
+
+Configuration:
+
+- React Router packages pinned to `7.18.0`
+- `ssr: false`
+- `routeDiscovery: { mode: "initial" }`
+- `future.v8_trailingSlashAwareDataRequests: true`
+- pre-render paths come from:
+  - `shared/seo/seoRoutes.mjs`
+  - `shared/content/curriculumSeoManifest.generated.json`
+
+This remains static build-time rendering. There is no production Node server.
+
+### Dual-Build Cutover
+
+The repository intentionally has two build paths:
+
+```txt
+npm run build
+  -> dist/
+  -> current deployable Vite SPA
+
+npm run build:framework
+  -> build-framework/client/
+  -> React Router framework migration candidate
+```
+
+The GitHub Pages workflow still publishes `dist/`. Do not switch it to
+`build-framework/client/` until fallback handling, sitemap output, production
+validation, and the full cutover gate are complete.
+
+React Router creates `__spa-fallback.html` for app-only routes. GitHub Pages
+expects `404.html`, so `finalize:framework` adds Not Found metadata and writes
+the dedicated fallback document. The fallback is never valid static output for
+a sitemap URL.
+
+## Current Route Output
+
+The framework candidate pre-renders:
+
+- `/`
+- `/content/`
+- all 221 valid `/content/:topicId/` routes
+- `/roadmap/`
+- `/about-us/`
+- `/privacy/`
+- `/terms/`
+
+Current generated candidate measurements:
+
+```txt
+Static route HTML artifacts: 227
+HTML files including __spa-fallback.html: 228
+Content route data files: 222
+Total finalized client output: about 67.59 MiB
+Largest HTML file: about 444.78 KiB
+Largest route data file: about 89.68 KiB
+Observed full framework command time: about 19-24 seconds locally
+```
+
+Markdown is present in source HTML and route data, so duplicated content size is
+accepted for the first cutover while the formal output budgets pass.
+
+## Implemented Work
+
+| Work | Commit |
+|---|---|
+| Fix `/content` On This Page scroll tracking | `b965497` |
+| Update `AGENTS.md` with SEO context | `680d8b7` |
+| Basic robots/default metadata/social image foundation | `6d21ec2` |
+| Extend curriculum manifest with SEO fields and Node-readable JSON | `cadab8d` |
+| Add machine-readable SEO route config | `282f0a6` |
+| Add shared dependency-free metadata builder and tests | `62b9d90` |
+| Add route-aware SPA SEO component | `5597626` |
+| Fix invalid topic Not Found behavior | `3df4213` |
+| Add structured data rules note | `7e1d21d` |
+| Add `WebSite` and `Article` JSON-LD | `ff6fc9b` |
+| Convert important internal navigation to crawlable links | `4c677fa` |
+| Add explicit trailing-slash route normalization | `6e7eb9c` |
+| Complete React Router SSG spike | `7a5047a` |
+| Make providers, Redux, theme, and content render-safe | `6b24b34` |
+| Add production-shaped dual-build framework routing candidate | `55221be` |
+
+## Important Implementation Files
+
+### Existing SPA
+
+- `src/main.tsx`
+- `src/App.tsx`
+- `src/components/seo/Seo.tsx`
+- `src/pages/Content.tsx`
+- `vite.config.ts`
+
+This path remains production-deployable.
+
+### Framework Candidate
+
+- `app/root.tsx`
+- `app/routes.ts`
+- `app/routes/main-layout.tsx`
+- `app/routes/page.tsx`
+- `app/routes/content.tsx`
+- `app/entry.server.tsx`
+- `app/seo/routeMetadata.tsx`
+- `react-router.config.ts`
+- `vite.framework.config.ts`
+- `tsconfig.framework.json`
+
+### Shared SEO and Route Data
+
+- `shared/seo/seoRoutes.mjs`
+- `shared/seo/buildSeoMetadata.mjs`
+- `shared/content/curriculumSeoManifest.generated.json`
+- `shared/content/loadContentRouteData.mjs`
+- `src/components/content/loadClientContentRouteData.ts`
+- `src/components/content/contentRouteData.ts`
+- `src/routing/canonicalPath.ts`
+
+The Node content loader:
+
+- reads the JSON SEO manifest
+- reads Markdown with Node `fs`
+- does not use `import.meta.glob`
+- validates that content paths stay under `src/contents/v1`
+- returns serializable welcome/topic/not-found route data
+
+The browser loader remains available for SPA fallback and client navigation.
+
+### Redux and Hydration
+
+- `src/lib/redux/createAppStore.ts` creates isolated stores.
+- `src/lib/redux/store.ts` owns the current browser singleton.
+- `src/lib/redux/persistence.ts` isolates localStorage loading/subscriptions.
+- `src/AppProviders.tsx` can create a fresh store and restore browser persistence
+  after hydration.
+- Pre-rendered content receives the same initial Markdown/metadata used during
+  hydration.
+- URL route data wins over stale persisted selected-topic state.
+
+### Validation and Preview
+
+- `scripts/finalize-framework-output.mjs`
+- `scripts/validate-framework-build.mjs`
+- `scripts/preview-framework.mjs`
+- `docs/architecture/framework-routing-dual-build.md`
+
+`validate:framework` checks:
+
+- all expected static route artifacts exist
+- every content route has matching `.data`
+- source HTML contains visible H1 content
+- source HTML does not contain `Loading content...`
+- title, description, canonical, robots, Open Graph URL, and image exist
+- structured data exists where expected
+- finalized sitemap URLs exactly match the 227 validated static routes
+- sitemap URLs are unique, absolute, canonical, and trailing-slash
+- candidate `robots.txt` advertises the finalized sitemap
+- dedicated `404.html` and `__spa-fallback.html` contain visible Not Found
+  content, `noindex`, no canonical, and no structured data
+- app-only routes were not emitted as static sitemap pages
+- framework output budgets pass
+- the temporary server build was removed
+- the old `dist/index.html` SPA artifact still exists
+
+On a clean checkout, run `npm run build` before `npm run validate:framework`,
+because the validator intentionally checks that the rollback SPA artifact still
+exists.
+
+## Current Commands
+
+```bash
+npm run generate:curriculum
+npm run lint
+npm run test:seo
+npm run test:content-route-data
+npm run test:theme-bootstrap
+npm run build
+npm run build:framework
+npm run finalize:framework
+npm run validate:framework
+npm run preview
+npm run preview:framework
+```
+
+Recommended complete local gate:
+
+```bash
+npm run lint
+npm run test:seo
+npm run test:content-route-data
+npm run test:theme-bootstrap
+npm run build
+npm run build:framework
+npm run finalize:framework
+npm run validate:framework
+```
+
+## Validation Already Completed
+
+The latest implementation passed:
+
+- ESLint
+- TypeScript/Vite SPA build
+- React Router framework build
+- 9 shared SEO tests
+- 4 content route-data tests
+- validation of 227 static framework route artifacts
+- direct pre-rendered content loads
+- client navigation between generated content routes
+- direct SPA fallback load for `/practice/`
+- direct SPA fallback load for `/simulation/setup/`
+- invalid topic Not Found behavior
+- generic invalid route Not Found behavior
+- `noindex` and no canonical on invalid routes
+- trailing-slash client normalization
+- post-hydration Redux progress restoration
+- zero React hydration warnings
+- zero MUI/Emotion hydration warnings
+- zero browser console errors in the final Playwright pass
+
+Existing non-blocking warnings:
+
+- 220 fallback SEO titles/descriptions remain.
+- The SPA main bundle remains larger than Vite's 500 KiB warning threshold.
+- Candidate output size is substantial because Markdown is duplicated between
+  HTML and route data.
+
+## Current Working-Tree Progress
+
+The current uncommitted implementation completes the next two readiness steps:
+
+- A synchronous theme bootstrap now preserves dark mode as the default and
+  restores an explicit saved dark/light choice before the app paints.
+- The SPA and framework output both include the same bootstrap.
+- React reconciles the saved mode before paint without changing the initial
+  server-rendered dark markup.
+- Browser validation passed for the default dark path and a saved light reload
+  with zero React, MUI, Emotion, or console warnings.
+- Framework output budgets are documented and enforced by
+  `validate:framework`:
+  - 80 MiB total client output
+  - 512 KiB maximum route HTML
+  - 100 KiB maximum route data
+  - 250 pre-rendered routes
+  - 60 seconds maximum full framework build duration in CI
+- `finalize:framework` now generates an idempotent 227-URL sitemap from the
+  shared static route config and curriculum canonical paths.
+- The finalizer writes candidate-only sitemap discovery to
+  `build-framework/client/robots.txt`; `public/robots.txt` remains unchanged.
+- The React Router SPA fallback now renders honest Not Found source content.
+- Finalization adds `noindex` metadata and writes the same hydrated fallback as
+  a dedicated `build-framework/client/404.html`.
+- Valid `/practice/` and `/simulation/setup/` routes hydrate from the fallback.
+- Invalid content and generic routes remain Not Found with `noindex`, no
+  canonical, and no structured data.
+- The Pages workflow is now manual-only, runs the complete dual-build gate, and
+  still deploys the existing `dist/` SPA from `main`.
+- A read-only framework candidate workflow validates pull requests and pushes
+  to `main` without uploading or deploying a Pages artifact.
+- The candidate check is advisory initially. Make it required in repository
+  settings only after several stable GitHub runs confirm timing and
+  reliability.
+
+## Work Not Yet Completed
+
+Do not assume the SEO rollout is production-complete.
+
+### 1. Reconcile the Plan with Framework Output
+
+The plan still contains older custom postbuild wording involving `dist`,
+`dist-server`, and a custom `renderRoute` API. The chosen implementation now
+uses React Router framework SSG.
+
+Preserve the underlying ownership rules, but adapt later tasks to:
+
+- treat `build-framework/client/` as the candidate public output
+- let React Router own route rendering and `.data` generation
+- keep custom finalization responsible only for sitemap, dedicated `404.html`,
+  validation, and GitHub Pages output preparation
+- avoid reintroducing a parallel custom SSR renderer
+
+The handoff and implementation now adapt the older plan to framework output.
+Do not reintroduce a custom SSR renderer.
+
+### 2. GitHub Actions Dual-Build/Cutover
+
+The workflow split is now in place:
+
+- `.github/workflows/framework-candidate.yml` validates pull requests and
+  pushes to `main` with read-only permissions and no deployment steps.
+- `.github/workflows/main.yml` runs only by manual dispatch from `main`, runs
+  the full gate, and still deploys `dist/`.
+- Both workflows record and enforce the 60-second framework build budget.
+
+Before switching the deployed artifact:
+
+1. Build the existing SPA rollback artifact.
+2. Build the framework candidate.
+3. Run framework/static SEO validation.
+4. Generate sitemap and dedicated fallback output.
+5. Confirm only public client output is uploaded.
+6. Keep the old deployment path easy to restore.
+7. Change the published directory only after the complete route matrix passes.
+
+Do not deploy `build-framework/server`; React Router removes it under
+`ssr:false` anyway.
+
+### 3. Production Validation
+
+After cutover, test the Cloudflare-managed custom domain on GitHub Pages.
+
+For every sitemap URL, verify:
+
+- direct request returns `200 OK`
+- no redirect
+- canonical trailing slash
+- no `noindex`
+- not blocked by robots
+- source HTML contains unique metadata and visible content
+- Open Graph URL matches the page
+- URL appears exactly once in the sitemap
+
+Use both header and source checks, for example:
+
+```bash
+curl -I https://www.dev-net-core.com/content/classes-structs-records/
+curl -L https://www.dev-net-core.com/content/classes-structs-records/
+```
+
+### 4. Search Console and Bing
+
+Do not submit the sitemap until:
+
+1. Technical foundation is complete.
+2. Pre-render/static output is deployed.
+3. Production URL validation passes.
+
+Then:
+
+- submit to Google Search Console
+- inspect representative URLs
+- submit to Bing Webmaster Tools
+- monitor indexing and search performance
+
+### Optional Follow-Ups
+
+- Gradually replace fallback metadata with custom frontmatter.
+- Add scheduled Codex production SEO validation after manual validation proves
+  the checks.
+- Improve content quality and related-topic linking based on search data.
+- Consider custom per-topic Open Graph images later.
+
+## Recommended Next Implementation Order
+
+1. Observe several advisory candidate runs on GitHub for timing and reliability.
+2. Make the candidate check required through repository settings once stable.
+3. Run the complete local route matrix again before cutover.
+4. Perform the explicit GitHub Pages cutover only after user approval and in a
+   separate commit.
+5. Validate production with headers, source HTML, and browser hydration.
+6. Add custom metadata to the highest-value topics while temporary fallbacks
+   remain accepted for the rest.
+7. Submit the sitemap only after the production gate passes.
+
+## Safety Rules for the Next Agent
+
+- Read the current files before editing.
+- Preserve the existing SPA build until the cutover is explicitly approved.
+- Do not change the deployment workflow casually.
+- Do not add runtime SSR or a Node production server.
+- Do not add `react-helmet-async`; it is not part of the chosen architecture.
+- Do not include practice, simulation flow, utility, session, or invalid routes
+  in the sitemap.
+- Do not block noindex pages in robots.
+- Do not use non-trailing canonical URLs.
+- Do not manually add `lastmod`.
+- Do not let a generic `404.html` fallback satisfy a sitemap artifact check.
+- Preserve generated Vite/React Router asset references.
+- Preserve Markdown question markers and curriculum extraction behavior.
+- Preserve Redux/localStorage progress and simulation persistence.
+- Treat source HTML metadata and hydrated metadata drift as a bug.
+- Run both SPA and framework build gates after routing/provider changes.
+
+## Git State at Handoff
+
+Latest implementation commit:
+
+```txt
+ea36f27 docs: add SEO implementation handoff
+```
+
+Current working tree:
+
+```txt
+Theme bootstrap, framework output budgets, finalization, and validation changes
+are uncommitted.
+?? docs/plans/dev-net-core-seo-improvement-plan.md
+```
+
+Verify `git status` before committing and keep the untracked SEO plan outside
+the commit unless explicitly requested. Do not push or deploy the current work
+without user approval.
diff --git a/docs/plans/dev-net-core-seo-improvement-plan.md b/docs/plans/dev-net-core-seo-improvement-plan.md
new file mode 100644
index 0000000..349d099
--- /dev/null
+++ b/docs/plans/dev-net-core-seo-improvement-plan.md
@@ -0,0 +1,3405 @@
+# DEV_NET_CORE SEO Improvement Plan
+
+## Purpose
+
+This plan documents the steps needed to improve SEO for DEV_NET_CORE so the website and its Markdown-based content can be discovered, crawled, indexed, and ranked by Google and other search engines.
+
+Website:
+
+```txt
+https://www.dev-net-core.com/
+```
+
+Repository:
+
+```txt
+https://github.com/CircleQMinh/dev-net-core
+```
+
+Recommended repo location for this file:
+
+```txt
+docs/plans/seo-improvement-plan.md
+```
+
+## Current Context
+
+DEV_NET_CORE is a React + TypeScript + Vite single-page application.
+
+The website has valuable technical interview preparation content, especially under content routes such as:
+
+```txt
+/content/
+/content/:topicId/
+/practice/
+/simulation/
+/roadmap/
+/about-us/
+```
+
+The project uses Markdown content and a generated curriculum manifest. This is good for SEO because each Markdown topic can become a searchable landing page if it has:
+
+- A stable URL
+- Real crawlable links
+- Unique metadata
+- A sitemap entry
+- Search-friendly page content
+- Ideally pre-rendered HTML
+
+The most important SEO goal is to make each curriculum topic searchable as its own page.
+
+Example search targets:
+
+```txt
+C# async await interview questions
+Entity Framework change tracker interview questions
+React useEffect interview questions
+SQL isolation levels interview questions
+ASP.NET Core middleware interview questions
+Azure Functions interview questions
+Clean Architecture .NET interview questions
+```
+
+## Goals
+
+The SEO work should achieve these goals:
+
+- Make the website discoverable by Google and other search engines.
+- Make every important content page available as an indexable URL.
+- Generate a sitemap from the curriculum content.
+- Add `robots.txt`.
+- Add unique metadata for important routes.
+- Add canonical URLs.
+- Add Open Graph metadata for sharing.
+- Add structured data where useful.
+- Improve Markdown content so each page has strong search intent.
+- Add pre-rendered/static HTML for every sitemap-included route before submitting sitemap URLs.
+- Set up Google Search Console and Bing Webmaster Tools after production validation passes.
+
+## Non-Goals
+
+This plan does not include:
+
+- Adding paid SEO tools.
+- Rebuilding the entire site in Next.js or Astro immediately.
+- Adding a backend.
+- Adding ads.
+- Adding analytics beyond what is needed for SEO validation.
+- Rewriting all curriculum content at once.
+
+## High-Level Recommendation
+
+Implement SEO in this order:
+
+```txt
+1. Add robots.txt
+2. Extend the curriculum manifest for SEO fields and generate sitemap.xml from it
+3. Add safe site-wide default metadata and a default social preview asset
+4. Add dynamic SPA metadata with react-helmet-async as an interim improvement
+5. Add crawlable internal links, canonical URLs, and explicit trailing-slash route support
+6. Add a shared SEO route config and complete the pre-rendering architecture decision gate
+7. Run the React Router 7 SSG spike before choosing the final pre-rendering approach
+8. Complete the SSR/SSG readiness refactor
+9. Add content route data loading and hydration seeding
+10. Add pre-render/static generation for all sitemap-eligible routes
+11. Validate production sitemap URLs and source HTML metadata
+12. Submit the sitemap to Google Search Console and Bing Webmaster Tools
+13. Monitor indexing and optionally add scheduled production validation
+```
+
+The highest-impact items are:
+
+```txt
+manifest-driven sitemap + real links + default metadata + shared route config + pre-rendering architecture gate + SSG-ready app structure + route data hydration + pre-rendered sitemap-eligible routes + production validation + Search Console
+```
+
+## Phase 1: Basic Crawlability
+
+### 1. Add `robots.txt`
+
+Create:
+
+```txt
+public/robots.txt
+```
+
+Content:
+
+```txt
+User-agent: *
+Allow: /
+
+Sitemap: https://www.dev-net-core.com/sitemap.xml
+```
+
+### Purpose
+
+This tells crawlers that the site can be crawled and where to find the sitemap.
+
+Important timing caveat: if `robots.txt` is deployed before the full production sitemap is ready, do not expose unvalidated URLs through the `Sitemap:` line yet. Either omit the `Sitemap:` line temporarily or expose only a limited sitemap containing URLs that already pass the production validation gate.
+
+Because DEV_NET_CORE is already in production, treat sitemap exposure as a production change. A public `sitemap.xml` or `robots.txt` `Sitemap:` line can be discovered before Search Console submission, so expose only validated URLs until the full SEO postbuild output is ready.
+
+### Acceptance Criteria
+
+- `https://www.dev-net-core.com/robots.txt` is accessible.
+- The file points to `https://www.dev-net-core.com/sitemap.xml` only when the sitemap URLs are ready for production discovery.
+- No important assets, pages, or routes are blocked.
+
+### Decision: `noindex` vs `robots.txt`
+
+Do not block `noindex` pages in `robots.txt`.
+
+Crawlers must be able to access the page in order to see the `noindex` meta tag or `X-Robots-Tag` header.
+
+Use `robots.txt` only to control crawling of areas that should not be crawled. Use `noindex` to prevent specific pages from appearing in search results.
+
+## Phase 2: Sitemap Generation
+
+### 2. Generate `sitemap.xml`
+
+Create a sitemap that includes important static routes and curriculum routes only after those routes have production-ready static/pre-rendered output.
+
+Required sitemap-eligible routes for the first submission:
+
+```txt
+/
+/content/
+/content/:topicId/
+/roadmap/
+/about-us/
+/privacy/
+/terms/
+```
+
+Optional sitemap-eligible routes:
+
+```txt
+/changelog/
+/simulation/
+```
+
+Do not include optional routes unless they have enough unique visible content, are intended to rank, and pass the same static/pre-rendered production validation as required routes.
+
+The sitemap should be generated from the existing curriculum manifest so new Markdown topics are automatically included.
+
+### Recommended Implementation
+
+Add a script such as:
+
+```txt
+scripts/seo-postbuild.mjs
+```
+
+The script should:
+
+1. Run after Vite has produced `dist`.
+2. Load the Node-readable SEO manifest generated by the curriculum generation step.
+3. Build a list of sitemap-eligible static routes.
+4. Build content routes from each entry's `canonicalPath`, falling back to `/content/[id]/` during transition.
+5. Generate static/pre-rendered HTML artifacts for every sitemap URL.
+6. Inject metadata from the shared metadata builder.
+7. Write the final production sitemap to `dist/sitemap.xml`.
+8. Validate that every sitemap URL has a matching static artifact.
+9. Do not include `/practice/:topicId/` routes in the first SEO sitemap pass.
+10. Do not include `<lastmod>` unless a reliable automated source can provide an accurate value.
+11. Do not output `<priority>` or `<changefreq>`.
+
+### Decision: SEO Postbuild Output Ownership
+
+Use a custom SEO `postbuild` script as the owner of pre-rendered HTML and sitemap output.
+
+The script is responsible for:
+
+- Building the list of sitemap-eligible routes.
+- Generating static HTML artifacts for those routes.
+- Injecting metadata from the shared metadata builder.
+- Injecting safe serialized route data for hydrated pages.
+- Writing `dist/sitemap.xml`.
+- Validating that every sitemap URL has a matching static artifact.
+- Ensuring no sitemap route depends on `404.html`.
+
+Postbuild failure policy in strict mode:
+
+- Fail the build if any sitemap URL is missing a static/pre-rendered artifact.
+- Fail the build if any sitemap URL is missing route-specific title, description, canonical URL, Open Graph URL, or `og:image`.
+- Fail the build if any sitemap URL has no visible source HTML content.
+- Fail the build if any sitemap URL contains `noindex`.
+- Fail the build if any sitemap URL can only be served through `dist/404.html`.
+- Treat SEO postbuild errors as release-blocking, not warnings.
+
+Staged postbuild activation:
+
+- Use `SEO_POSTBUILD_MODE=off` only during early scaffolding when the script or route list does not exist yet.
+- Use `SEO_POSTBUILD_MODE=warn` while manifest SEO fields, metadata, route config, and pre-rendering support are being built.
+- Use `SEO_POSTBUILD_MODE=strict` after the pre-render proof of concept passes and before exposing a full production sitemap.
+- Do not make strict SEO postbuild validation block unrelated early PRs before the SSG/pre-render proof of concept proves the route output and hydration path.
+- Once the production sitemap includes sitemap-eligible routes, strict mode should be required in CI/deployment.
+
+The deployment workflow may still create `dist/404.html` for SPA fallback, but that fallback is not considered valid static output for any sitemap URL.
+
+During early local work, sitemap generation may be tested locally, but do not deploy a full production sitemap or a `robots.txt` `Sitemap:` line until every sitemap URL has validated static/pre-rendered output.
+
+### Decision: Build Boundary for Vite, Curriculum Generation, and SEO Postbuild
+
+Keep the build responsibilities separated:
+
+```txt
+Vite -> JavaScript/CSS bundling and hashed assets
+Curriculum generation -> TypeScript app manifest + Node-readable SEO manifest
+SEO postbuild -> static route HTML, metadata injection, route data injection, sitemap, and SEO validation
+React -> hydration after the static page loads
+```
+
+Rules:
+
+- Vite owns JavaScript and CSS bundling, hashed asset filenames, and the production `dist/index.html` app template.
+- The curriculum generation step must output a Node-readable SEO manifest, such as JSON, in addition to the React/TypeScript curriculum manifest.
+- The SEO manifest must include enough data to generate static route HTML, sitemap URLs, route metadata, and content route data.
+- The SEO postbuild script must use `dist/index.html` as the base HTML template after Vite has built the app.
+- The SEO postbuild script must preserve Vite-generated script, CSS, preload, modulepreload, and asset references.
+- The SEO postbuild script owns static route HTML generation, metadata injection, route data injection, sitemap generation, and SEO validation.
+- The SEO postbuild script must not depend on Vite-only imports, TypeScript runtime execution, `import.meta.glob`, or React app internals.
+- The SEO postbuild script may import only the built server/static render entry as the React rendering boundary.
+- The SEO postbuild script must not rely on the SPA `404.html` fallback as valid output for sitemap routes.
+- The server/static render bundle should be a build artifact outside the public `dist` deploy output, such as `dist-server/entry-server.js`.
+
+### Decision: HTML Template and Asset Preservation
+
+The SEO postbuild script should read `dist/index.html` and use it as the base template for every generated static route.
+
+Rules:
+
+- Preserve Vite-generated hashed script and stylesheet references.
+- Preserve modulepreload/preload links and public asset references.
+- Replace or inject only the route-specific head tags, root app markup, and safe route data script.
+- Do not manually guess hashed JS or CSS filenames.
+- Validate generated nested routes load the same JS and CSS assets as the root app shell.
+- Prefer explicit managed template slots over broad string replacement.
+- If template slots are used, define stable markers for the SEO head block, root app markup, and serialized route data.
+- If an HTML parser is used instead of markers, restrict mutation to the same three areas.
+- Fail or warn according to `SEO_POSTBUILD_MODE` if the expected template markers or nodes are missing.
+- Do not rewrite unrelated `head`, script, style, preload, modulepreload, favicon, manifest, or public asset tags.
+
+Suggested managed slots:
+
+```html
+<!-- seo:head:start -->
+<!-- seo:head:end -->
+
+<div id="root"><!-- app:html --></div>
+
+<!-- route-data:start -->
+<!-- route-data:end -->
+```
+
+### Decision: Initial Head Metadata Ownership
+
+Initial source HTML metadata should come from the shared metadata builder and be injected by `scripts/seo-postbuild.mjs`.
+
+`react-helmet-async` may still mirror or update the same metadata after hydration, but it should not be the source of truth for pre-rendered HTML.
+
+Rules:
+
+- Initial HTML metadata is owned by SEO postbuild.
+- Hydrated route metadata should match the same shared metadata builder output.
+- Mismatches between source HTML metadata and hydrated React metadata are bugs.
+
+### Decision: Server/Static Render Entry API
+
+The server/static render entry should expose a small, explicit API for the SEO postbuild script.
+
+Suggested API:
+
+```ts
+export async function renderRoute(input: {
+  url: string;
+  routeData?: unknown;
+  preloadedState?: unknown;
+}): Promise<{
+  appHtml: string;
+  statusCode?: number;
+  diagnostics?: string[];
+}>;
+```
+
+Rules:
+
+- `src/entry-server.tsx` should be the React rendering boundary consumed by SEO postbuild.
+- The built server/static render entry should render app markup only; it should not write files, generate sitemap URLs, or mutate `dist`.
+- The SEO postbuild script should own file output, metadata injection, route-data injection, sitemap generation, and validation.
+- The server/static render entry should receive the canonical URL path and any route data before rendering.
+- The server/static render entry should create an isolated app instance per route render.
+- Do not import the browser singleton Redux store into the server/static render entry.
+- Do not depend on browser globals or process-wide mutable render state.
+- Metadata may be calculated for React route components, but initial source HTML metadata is still injected by SEO postbuild from the shared metadata builder.
+
+### Decision: Per-Render Store and Client-Only Persistence
+
+Static rendering must not reuse the browser singleton Redux store across route renders.
+
+Rules:
+
+- Extract a store factory such as `createAppStore(preloadedState?)` from `src/lib/redux/store.ts`.
+- The server/static render entry must create a fresh Redux store for every `renderRoute` call.
+- The client entry may create the browser store once, but it should also support preloaded route data or preloaded state when present.
+- Browser persistence subscriptions for Redux/localStorage should be attached only in the client entry or behind explicit browser guards.
+- Do not run localStorage, sessionStorage, or storage-subscription side effects at module load in code imported by `entry-server`.
+- Server/static rendering must never read from or write to localStorage.
+- Route-derived data must win over persisted selected-topic state during hydration.
+
+### Decision: Client Hydration Bootstrap
+
+The client entry should choose hydration or fresh mounting based on the generated HTML it receives.
+
+Rules:
+
+- Read serialized route data before the first React render.
+- If the root element already contains pre-rendered app markup, use `hydrateRoot`.
+- If the root element is empty or contains only a generic non-pre-rendered shell, use `createRoot`.
+- Pass initial route data or preloaded state into shared app providers before rendering.
+- Ignore or clear serialized route data if it does not match the current URL.
+- After hydration, normal client navigation can use existing route loading behavior.
+- Hydration mismatches between generated source HTML and the first client render should be treated as bugs.
+
+### Decision: Sitemap URL Discipline
+
+Every sitemap URL must be:
+
+- Absolute
+- Canonical
+- Indexable
+- Direct-loadable
+- Intended to appear in search results
+- Returning `200 OK`
+- Not redirected
+- Not duplicated with another slash/non-slash format
+- Not blocked by `robots.txt`
+- Not marked `noindex`
+
+Use only canonical URLs in the sitemap.
+
+Example:
+
+```xml
+<loc>https://www.dev-net-core.com/content/async-await/</loc>
+```
+
+Do not use:
+
+```xml
+<loc>/content/async-await/</loc>
+```
+
+Do not include invalid routes, duplicate routes, utility-only routes, or pages that should not rank.
+
+Submitting a sitemap helps discovery, but it does not guarantee that Google will crawl or index every URL.
+
+### Decision: Static Output Rule for Sitemap URLs
+
+Every route marked `Sitemap = Yes` must have a matching production static output or pre-rendered artifact.
+
+A route must not be included in `sitemap.xml` if it only works because the React SPA catches the route after loading a generic app shell.
+
+For every sitemap URL, production must provide:
+
+- A direct-loadable URL
+- `200 OK` status
+- No redirect
+- Canonical trailing-slash URL
+- Route-specific source HTML metadata
+- Route-specific or fallback Open Graph metadata in source HTML
+- Visible page content in source HTML
+- No `noindex`
+- No `robots.txt` block
+
+This rule applies to all sitemap routes, not only `/content/:topicId/`.
+
+Examples of routes that need static/pre-rendered output if included in the sitemap:
+
+- `/`
+- `/content/`
+- `/content/:topicId/`
+- `/roadmap/`
+- `/about-us/`
+- `/privacy/`
+- `/terms/`
+
+Do not include a route in the sitemap until its production static output is validated.
+
+| Route type | Sitemap? | Static/pre-render required? |
+|---|---:|---:|
+| `/` | Yes | Yes |
+| `/content/` | Yes | Yes |
+| `/content/:topicId/` | Yes | Yes |
+| `/roadmap/` | Yes | Yes |
+| `/about-us/` | Yes | Yes |
+| `/privacy/` | Yes | Yes |
+| `/terms/` | Yes | Yes |
+| `/practice/` | No by default | No, unless later indexed |
+| `/practice/:topicId/` | No by default | No, unless later indexed |
+| `/simulation/setup/` | No | No |
+| `/simulation/session/:sessionId/` | No | No |
+| `/simulation/result/:sessionId/` | No | No |
+| `/bug-report/` | No | No |
+| Invalid routes | No | Prefer real 404 or noindex |
+
+### Example Sitemap Shape
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url>
+    <loc>https://www.dev-net-core.com/</loc>
+  </url>
+  <url>
+    <loc>https://www.dev-net-core.com/content/</loc>
+  </url>
+  <url>
+    <loc>https://www.dev-net-core.com/roadmap/</loc>
+  </url>
+  <url>
+    <loc>https://www.dev-net-core.com/about-us/</loc>
+  </url>
+  <url>
+    <loc>https://www.dev-net-core.com/privacy/</loc>
+  </url>
+  <url>
+    <loc>https://www.dev-net-core.com/terms/</loc>
+  </url>
+  <url>
+    <loc>https://www.dev-net-core.com/content/classes-structs-records/</loc>
+  </url>
+</urlset>
+```
+
+### Package Script Update
+
+Consider updating `package.json`:
+
+```json
+{
+  "scripts": {
+    "generate:curriculum": "node scripts/generate-curriculum-manifest.mjs",
+    "generate:seo-manifest": "node scripts/generate-seo-manifest.mjs",
+    "predev": "npm run generate:curriculum",
+    "build:client": "tsc -b && vite build",
+    "build:ssg": "vite build --ssr src/entry-server.tsx --outDir dist-server",
+    "seo:postbuild": "node scripts/seo-postbuild.mjs",
+    "fallback:404": "node scripts/seo-404.mjs",
+    "seo:validate": "node scripts/validate-seo-build.mjs",
+    "build": "npm run generate:curriculum && npm run generate:seo-manifest && npm run build:client && npm run build:ssg && npm run seo:postbuild && npm run fallback:404 && npm run seo:validate"
+  }
+}
+```
+
+Only change the scripts after checking the current `package.json`.
+
+Do not make `predev` generate the production sitemap. Local development can rely on app routes; production sitemap output belongs to the SEO postbuild step.
+
+If the main `build` script explicitly runs `generate:curriculum`, remove or adjust the existing `prebuild` script so curriculum generation does not run twice.
+
+The exact `generate:seo-manifest` implementation can be folded into `generate:curriculum` as long as the generated ownership is clear, the build script does not duplicate work unnecessarily, and the SEO manifest is produced before sitemap/pre-render work begins.
+
+If `fallback:404` remains separate from `seo:postbuild`, final SEO validation should run after `fallback:404` so the dedicated Not Found + `noindex` file is included in validation.
+
+The exact script names may be adjusted during implementation, but the required production build order is:
+
+1. Generate the curriculum manifest.
+2. Generate the Node-readable SEO manifest, either as part of curriculum generation or as an explicit step.
+3. Build the client assets.
+4. Build the server/static render entry or framework-mode pre-render output.
+5. Run the SEO postbuild script that writes route HTML artifacts and `dist/sitemap.xml`.
+6. Generate or validate the dedicated `dist/404.html` Not Found + `noindex` fallback.
+7. Run local SEO build validation when available.
+
+Only `dist` should be deployed to GitHub Pages. Do not upload `dist-server` or other private server/static build outputs.
+
+## Pre-rendering Architecture Decisions Before Implementation
+
+Before implementing SEO pre-rendering, decide these items explicitly.
+
+### Decision: Canonical URL Shape for Static Hosting
+
+DEV_NET_CORE should keep trailing-slash URLs as the canonical static-output format.
+
+Reason:
+
+```txt
+dist/content/topic/index.html -> https://www.dev-net-core.com/content/topic/
+```
+
+Rules:
+
+- Sitemap URLs must use trailing-slash canonical URLs.
+- Canonical tags, Open Graph URLs, Twitter/X URLs, structured data URLs, and internal generated links must use trailing-slash canonical URLs.
+- Non-trailing URLs may continue to work for user convenience, but they are not the canonical SEO target.
+- On GitHub Pages, do not assume non-trailing URLs can return true `301` redirects unless Cloudflare redirect rules are explicitly enabled and validated.
+- If a non-trailing URL is kept as an accepted direct-load URL, production must prove that it returns `200 OK` directly without relying on a generic SPA fallback.
+- Non-trailing URLs must not appear in `sitemap.xml`.
+
+### Decision: Rendering Strategy Spike Before Implementation
+
+Do not assume the custom SEO postbuild approach is the only possible path.
+
+Run a spike to compare:
+
+- React Router framework-mode SSG/pre-rendering.
+- Custom Vite SSR/SSG build plus SEO postbuild generation.
+
+React Router framework docs support static pre-rendering through `react-router.config.ts`, including `ssr: false` for static-file deployments and a `prerender()` list/function for generated paths. They also support build-time loaders during pre-rendering.
+
+However, DEV_NET_CORE is currently a Vite SPA using `BrowserRouter`, `Routes`, and `createRoot`, so React Router framework-mode SSG may require a larger routing/build migration.
+
+The spike must answer:
+
+- Can DEV_NET_CORE migrate safely to React Router framework mode?
+- Can it generate `/content/:topicId/` paths from the curriculum manifest?
+- Can route loaders receive Markdown content and curriculum metadata at build time?
+- Can the generated output deploy cleanly to GitHub Pages with the Cloudflare-managed custom domain?
+- How much current routing, layout, provider, and navigation code must change?
+- Does framework-mode SSG reduce or increase complexity compared with the custom SEO postbuild approach?
+
+Proceed with framework-mode SSG only if the migration cost is acceptable. Otherwise, continue with the custom SEO postbuild approach already described in this plan.
+
+References:
+
+- `https://reactrouter.com/start/framework/rendering`
+- `https://reactrouter.com/how-to/pre-rendering`
+
+### Decision: JSON-LD Ownership
+
+Structured data should be owned by the same metadata pipeline as title, description, canonical URL, Open Graph, and Twitter/X metadata.
+
+Rule:
+
+```txt
+Markdown frontmatter -> generated manifest -> shared metadata builder -> sitemap + pre-render HTML + React route metadata
+```
+
+The shared metadata builder should produce:
+
+- Canonical metadata
+- Open Graph metadata
+- Twitter/X metadata
+- JSON-LD structured data
+
+SEO postbuild should inject JSON-LD into source HTML for sitemap URLs. React may mirror the same JSON-LD after hydration, but React runtime output should not be the source of truth for structured data.
+
+### Decision: Static Theme Bootstrap
+
+Pre-rendered HTML should not flash the wrong theme before React hydrates.
+
+Rules:
+
+- Add a small before-paint theme bootstrap if needed.
+- The bootstrap may read a safe theme preference from localStorage and/or system preference.
+- It should set the root `data-theme`, `dark`/`light` class, and any critical theme variables needed before paint.
+- Keep the script tiny and dependency-free.
+- Do not let the bootstrap create markup that conflicts with React hydration.
+- If localStorage is unavailable, default to the production default theme.
+
+Example placement:
+
+```html
+<script>
+  // Tiny before-paint theme bootstrap.
+</script>
+```
+
+### Decision: Build Script Ownership
+
+Keep production build steps explicit while the SEO pipeline is being stabilized.
+
+Preferred conceptual steps:
+
+```txt
+generate:curriculum
+generate:seo-manifest
+build:client
+build:ssg or framework prerender
+seo:postbuild
+fallback:404
+seo:validate
+```
+
+Rules:
+
+- Avoid hiding too much behind `prebuild` and `postbuild` until the flow is stable.
+- If the main `build` script explicitly runs `generate:curriculum`, remove or adjust the existing `prebuild` script so generation does not run twice.
+- `generate:seo-manifest` may be a separate command or part of `generate:curriculum`, but ownership must be clear.
+- `fallback:404` must generate a dedicated Not Found + `noindex` document, not blindly copy `dist/index.html`.
+- If `fallback:404` is separate from `seo:postbuild`, run final SEO validation after the fallback file exists.
+- CI/GitHub Actions should use the same ordered build steps as local production validation.
+
+### Decision: Pre-render Output Budgets
+
+Define output and build-time budgets before scaling from the POC to every sitemap-eligible route.
+
+Initial budgets to choose during the POC:
+
+- Maximum total `dist` size.
+- Maximum HTML file size per route.
+- Maximum serialized route-data JSON size per route.
+- Maximum number of pre-rendered routes in the first sitemap release.
+- Maximum production build time.
+
+Important risk:
+
+If each content route includes full rendered HTML and also serializes full Markdown as route data, output size can grow quickly. Prefer the smallest route data needed for hydration, and measure the POC before generating every topic page.
+
+### Acceptance Criteria
+
+- `https://www.dev-net-core.com/sitemap.xml` is accessible.
+- The sitemap includes all required sitemap-eligible routes that have validated static/pre-rendered production output.
+- Every curriculum topic has a `/content/:topicId/` entry.
+- `/practice/:topicId/` routes are intentionally excluded from the first SEO sitemap pass.
+- Sitemap URLs are absolute canonical URLs, not relative paths.
+- Sitemap URLs use the trailing-slash format.
+- Sitemap URLs are indexable, direct-loadable, not redirected, not blocked by `robots.txt`, and not marked `noindex`.
+- Every sitemap URL has route-specific source HTML metadata and visible page content in source HTML.
+- Every sitemap-included content URL receives Markdown and curriculum metadata before pre-rendering.
+- Every sitemap-included content URL hydrates with the same initial route data used during pre-rendering.
+- No sitemap-included content URL renders `Loading content...` as its primary source HTML content.
+- Sitemap generation uses manifest `canonicalPath` values for content pages.
+- Sitemap and pre-render generation use the Node-readable SEO manifest, not the TypeScript app manifest.
+- Generated route HTML is based on `dist/index.html` and preserves Vite-generated hashed asset references.
+- Generated route HTML includes safe serialized route data only when needed for hydration.
+- The private server/static render build output is not deployed to GitHub Pages.
+- Sitemap generation omits `<lastmod>` unless a reliable automated source can provide an accurate value.
+- Sitemap generation does not include `<priority>` or `<changefreq>`.
+- SEO postbuild output does not break `npm run build`.
+- Local development does not require production sitemap generation.
+
+### Decision: Practice Topic Indexing
+
+For the first SEO pass, do not pre-render or index `/practice/:topicId/` pages.
+
+Use `/content/:topicId/` as the primary SEO landing page and source of truth for each curriculum topic. Treat `/practice/:topicId/` as an interactive app workflow route for users who want to practice after reading the topic content.
+
+Initial indexing strategy:
+
+```txt
+Index and include in sitemap after static/pre-render validation:
+/
+/content/
+/content/:topicId/
+/roadmap/
+/about-us/
+/privacy/
+/terms/
+
+Optional index and sitemap only if intentionally designed to rank:
+/changelog/
+/simulation/
+
+Do not include in sitemap initially:
+/practice/
+/practice/:topicId/
+/simulation/*
+/bug-report/
+
+Add noindex initially:
+/practice/:topicId/
+/simulation/*
+/bug-report/
+```
+
+Rules:
+
+- `/content/:topicId/` pages should be the canonical searchable landing pages.
+- `/practice/:topicId/` pages should be linked from their corresponding content pages for user flow.
+- `/practice/:topicId/` pages should not be included in the sitemap until they are intentionally designed as standalone searchable Q&A landing pages.
+- `/practice/:topicId/` pages should use `noindex` initially to avoid thin-content or duplicate-intent indexing risk.
+- `/practice/` itself should not be included in the first sitemap pass unless it has enough visible source HTML content and is intended to rank as a practice landing page.
+- `/simulation/` itself may remain indexable only if it has enough visible source HTML content and is intended to rank as a stable public tool landing route.
+- `/simulation/*` session, result, or user-flow routes should use `noindex` and should not be included in the sitemap.
+
+Only consider indexing `/practice/:topicId/` later if those pages become strong standalone pages with:
+
+- Unique title and description
+- Enough meaningful initial HTML content
+- Clear question/answer content visible without relying only on interaction
+- Distinct purpose from the corresponding content page
+- Self-canonical URL
+- Structured data only if it accurately matches the visible content and Google guidelines
+
+## Phase 3: Crawlable Internal Links
+
+### 3. Ensure Topic Links Use Real Anchors
+
+Search engines discover links through real HTML anchor tags.
+
+Ensure navigation to topic pages renders links with valid `href` values.
+
+Good:
+
+```tsx
+<Link to="/content/classes-structs-records/">
+  Classes, Structs, and Records
+</Link>
+```
+
+Also good:
+
+```tsx
+<a href="/content/classes-structs-records/">
+  Classes, Structs, and Records
+</a>
+```
+
+Avoid:
+
+```tsx
+<button onClick={() => navigate("/content/classes-structs-records/")}>
+  Classes, Structs, and Records
+</button>
+```
+
+Buttons are fine for app interactions, but important SEO navigation should also be available through real links.
+
+### Decision: Curriculum Link Semantics
+
+Follow the crawlable-link plan with a targeted navigation semantics change, not a redesign.
+
+Keep curriculum folder rows as `<button>` elements because expanding and collapsing categories such as `.NET`, `React`, `SQL`, and `Azure` is UI state.
+
+Change only curriculum subtopic leaf rows from `<button>` to real React Router links.
+
+Recommended shape:
+
+```tsx
+<RouterLink
+  to={`/content/${node.id}/`}
+  onClick={() => onSelectTopic(node)}
+>
+  ...
+</RouterLink>
+```
+
+Use trailing-slash URLs to match the canonical URL decision:
+
+```tsx
+to={`/content/${node.id}/`}
+```
+
+Do not use:
+
+```tsx
+to={`/content/${node.id}`}
+```
+
+Preserve:
+
+- Existing visual styling
+- Active row styling
+- Icons
+- Progress display
+- Indentation
+- Expanded folder state
+- Redux/internal selected topic behavior
+
+This still works with the React SPA model and improves internal link semantics, accessibility, browser behavior, and consistency with sitemap/canonical URLs. However, crawlers will only see these generated links after JavaScript renders the app until pre-rendering/static generation is added later.
+
+### Files to Inspect
+
+Likely files:
+
+```txt
+src/components/content/CurriculumTreeView.tsx
+src/components/content/LeftContentPanel.tsx
+src/components/content/RightContentPanel.tsx
+src/pages/Practice.tsx
+src/pages/Content.tsx
+```
+
+### Acceptance Criteria
+
+- Important content and practice pages are reachable through real links.
+- Navigation still works normally in the React app.
+- Existing UI behavior is preserved.
+- Folder expand/collapse controls remain buttons.
+- Curriculum subtopic rows render real links with trailing-slash `href` values.
+- Existing non-trailing route support may remain temporarily for compatibility.
+
+## Phase 4: Dynamic Metadata
+
+### 4. Add SEO Metadata Support
+
+Each important route should have a unique:
+
+- `<title>`
+- `<meta name="description">`
+- `<link rel="canonical">`
+- Open Graph title
+- Open Graph description
+- Open Graph URL
+- Open Graph type
+- Open Graph image
+- Open Graph image width, height, and alt text
+- X/Twitter Card metadata
+
+Recommended package:
+
+```bash
+npm install react-helmet-async
+```
+
+Create a reusable component, for example:
+
+```txt
+src/components/seo/Seo.tsx
+```
+
+Example:
+
+```tsx
+import { Helmet } from "react-helmet-async";
+
+const DEFAULT_OG_IMAGE_URL =
+  "https://www.dev-net-core.com/og/default-og-image.png";
+const DEFAULT_OG_IMAGE_ALT = "DEV_NET_CORE developer interview preparation";
+
+type SeoProps = {
+  title: string;
+  description: string;
+  canonicalPath: string;
+  noindex?: boolean;
+  ogImageAlt?: string;
+  ogImageUrl?: string;
+};
+
+export function Seo({
+  title,
+  description,
+  canonicalPath,
+  noindex = false,
+  ogImageAlt = DEFAULT_OG_IMAGE_ALT,
+  ogImageUrl = DEFAULT_OG_IMAGE_URL,
+}: SeoProps) {
+  const canonicalUrl = `https://www.dev-net-core.com${canonicalPath}`;
+
+  return (
+    <Helmet>
+      <title>{title}</title>
+      <meta name="description" content={description} />
+      <link rel="canonical" href={canonicalUrl} />
+
+      {noindex ? <meta name="robots" content="noindex" /> : null}
+
+      <meta property="og:title" content={title} />
+      <meta property="og:description" content={description} />
+      <meta property="og:url" content={canonicalUrl} />
+      <meta property="og:type" content="website" />
+      <meta property="og:image" content={ogImageUrl} />
+      <meta property="og:image:width" content="1200" />
+      <meta property="og:image:height" content="630" />
+      <meta property="og:image:alt" content={ogImageAlt} />
+
+      <meta name="twitter:card" content="summary_large_image" />
+      <meta name="twitter:title" content={title} />
+      <meta name="twitter:description" content={description} />
+      <meta name="twitter:image" content={ogImageUrl} />
+    </Helmet>
+  );
+}
+```
+
+Wrap the app with `HelmetProvider`.
+
+## Important Note About Dynamic Metadata
+
+Using `react-helmet-async` improves metadata after the React app runs, and it can help Google because Google is able to render JavaScript in many cases.
+
+However, this does not guarantee that metadata exists in the initial HTML response.
+
+This matters because many social preview crawlers, link unfurlers, and non-Google bots do not reliably execute JavaScript before reading Open Graph or X/Twitter Card tags.
+
+Therefore:
+
+- `react-helmet-async` is useful as an interim SPA metadata solution.
+- It should not be considered a complete solution for social previews.
+- Reliable per-page Open Graph previews require metadata to exist in the initial HTML.
+- For DEV_NET_CORE, true per-topic SEO/social metadata should eventually be generated through pre-rendering, static HTML generation, SSR, or another build-time HTML generation strategy.
+
+Recommended priority:
+
+1. Add safe site-wide default metadata in `index.html`.
+2. Use `react-helmet-async` for in-app route metadata as a short-term improvement.
+3. Generate initial HTML metadata for `/content/:topicId/` pages through pre-rendering/static generation.
+
+### Decision: Metadata-Only Static HTML Shell
+
+A metadata-only static HTML shell is allowed as an interim improvement for default head tags and social previews.
+
+This means the initial HTML may include route-specific or site-wide:
+
+- `<title>`
+- Meta description
+- Canonical URL
+- Open Graph tags
+- X/Twitter Card tags
+
+However, a metadata-only shell is not sufficient for sitemap inclusion.
+
+Rules:
+
+- A metadata-only shell may improve social preview reliability and basic head metadata before JavaScript runs.
+- It should not be treated as validated static output for a sitemap URL.
+- A sitemap URL must include visible route content in source HTML, not only metadata plus a generic React app shell.
+- `/content/:topicId/` URLs should not be submitted in the production sitemap based only on metadata-only HTML.
+- Metadata-only output can be used as a stepping stone while full SSG/pre-rendered content output is being implemented.
+
+### Decision: Default Social Preview Asset
+
+Create one default social preview image for DEV_NET_CORE.
+
+Recommended file:
+
+```txt
+public/og/default-og-image.png
+```
+
+Recommended URL:
+
+```txt
+https://www.dev-net-core.com/og/default-og-image.png
+```
+
+Recommended dimensions:
+
+```txt
+1200x630
+```
+
+Recommended format:
+
+```txt
+PNG
+```
+
+Fallback behavior:
+
+- Every page should have an `og:image`.
+- If a page does not define a custom image, use the default image.
+- Content pages may later define custom `ogImage` in frontmatter.
+- The image URL must be absolute.
+- The image must be publicly accessible.
+- The image should not require JavaScript to load.
+- The same image can be used for Twitter/X card metadata.
+
+Required Open Graph fields should include:
+
+```html
+<meta property="og:title" content="..." />
+<meta property="og:type" content="website" />
+<meta property="og:url" content="..." />
+<meta property="og:image" content="https://www.dev-net-core.com/og/default-og-image.png" />
+<meta property="og:image:width" content="1200" />
+<meta property="og:image:height" content="630" />
+<meta property="og:image:alt" content="DEV_NET_CORE developer interview preparation" />
+```
+
+Optional Twitter/X fields:
+
+```html
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="..." />
+<meta name="twitter:description" content="..." />
+<meta name="twitter:image" content="https://www.dev-net-core.com/og/default-og-image.png" />
+```
+
+Open Graph's required basic metadata includes `og:title`, `og:type`, `og:image`, and `og:url`. It also supports image width, height, type, and alt metadata.
+
+Important caveat: for reliable social previews, the default `og:image` and site-wide fallback Open Graph tags should exist in the initial HTML. Route-specific React metadata is useful, but social preview crawlers may not execute JavaScript before reading tags.
+
+### Decision: Metadata Source of Truth
+
+SEO metadata should come from Markdown frontmatter where possible.
+
+Required for indexable content pages after transition:
+
+- `seoTitle`
+- `seoDescription`
+
+Generated or optional:
+
+- `canonicalPath`
+
+Fallbacks are allowed, but they should be treated as temporary.
+
+Fallback example:
+
+- `seoTitle`: `[subtopic] Interview Questions | DEV_NET_CORE`
+- `seoDescription`: `Learn [subtopic] for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.`
+- `canonicalPath`: `/content/[id]/`
+- `lastmod`: omitted
+
+Generated descriptions such as `Learn [topic] for interviews...` are acceptable as a fallback, but every content page should not use the same repeated pattern when custom metadata is available.
+
+Do not generate repetitive descriptions for all pages if custom metadata is available.
+
+Example frontmatter:
+
+```md
+---
+id: async-await
+topic: C# Language Foundations
+subtopic: Async/Await
+category: .NET
+seoTitle: Async and Await in C# Interview Questions
+seoDescription: Learn async and await in C# for technical interviews, including Task, I/O-bound work, cancellation, exception handling, and common deadlock risks.
+canonicalPath: /content/async-await/
+---
+```
+
+Notes:
+
+- `canonicalPath` should use the trailing-slash format defined in the canonical URL decision.
+- `canonicalPath` can be derived from `id` by default and should only be overridden when needed.
+- `lastmod` should not be maintained manually in Markdown frontmatter.
+
+### Decision: Manifest SEO Field Support
+
+The current curriculum manifest only supports the fields needed for curriculum navigation and question extraction.
+
+Before generating high-quality sitemap and metadata output, extend the Markdown frontmatter parser and generated manifests to support SEO fields.
+
+Required for indexable content pages after transition:
+
+```yaml
+seoTitle: Async and Await in C# Interview Questions
+seoDescription: Learn async and await in C# for technical interviews, including Task, cancellation, exception handling, and common deadlock risks.
+```
+
+Generated or optional:
+
+```yaml
+canonicalPath: /content/async-await/
+```
+
+Implementation tasks:
+
+1. Update Markdown frontmatter parsing.
+2. Extend the React/TypeScript manifest entry type.
+3. Generate a Node-readable SEO manifest such as `shared/content/curriculumSeoManifest.generated.json`.
+4. Include `seoTitle`, `seoDescription`, generated-or-overridden `canonicalPath`, and content path data needed by the SEO postbuild script.
+5. Add validation for:
+   - Missing `seoTitle` after the transition period
+   - Missing `seoDescription` after the transition period
+   - Duplicate `canonicalPath`
+   - `canonicalPath` not starting with `/content/`
+   - `canonicalPath` not ending with `/`
+   - `canonicalPath` not matching the selected trailing-slash canonical format
+6. Update sitemap generation to use `canonicalPath`.
+7. Omit `<lastmod>` unless a reliable automated source can generate it accurately.
+8. Use fallback metadata only during transition.
+
+Fallbacks:
+
+- `seoTitle`: `[subtopic] Interview Questions | DEV_NET_CORE`
+- `seoDescription`: `Learn [subtopic] for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.`
+- `canonicalPath`: `/content/[id]/`
+- `lastmod`: omit
+
+Do not generate `<priority>` or `<changefreq>` in the sitemap. Google ignores those fields. Do not manually maintain `<lastmod>` values; only include `<lastmod>` later if the build has a consistently accurate automated source.
+
+### Decision: Node-Readable SEO Manifest
+
+The curriculum generation step must output a Node-readable SEO manifest.
+
+Suggested file:
+
+```txt
+shared/content/curriculumSeoManifest.generated.json
+```
+
+Purpose:
+
+- Let `scripts/seo-postbuild.mjs` generate route HTML, metadata, and sitemap output without importing TypeScript files at runtime.
+- Avoid dependence on Vite-only imports, `import.meta.glob`, React app internals, or TypeScript runtime execution.
+- Keep content and SEO data stable across Node scripts and React hydration.
+
+The SEO manifest should include enough data for:
+
+- Static content route generation
+- Sitemap URL generation
+- Metadata generation
+- Markdown file loading
+- Route data generation
+- Validation
+
+Example shape:
+
+```json
+{
+  "topics": [
+    {
+      "id": "async-await",
+      "category": ".NET",
+      "topic": "C# Language Foundations",
+      "subtopic": "Async/Await",
+      "contentPath": "/src/contents/v1/NET/async-await.md",
+      "canonicalPath": "/content/async-await/",
+      "seoTitle": "Async and Await in C# Interview Questions",
+      "seoDescription": "Learn async and await in C# for technical interviews, including Task, cancellation, exception handling, and common deadlock risks."
+    }
+  ]
+}
+```
+
+Rules:
+
+- The JSON manifest is for Node SEO tooling.
+- The TypeScript manifest is for the React application.
+- Both outputs should be generated by the same curriculum generation step.
+- The SEO postbuild script should consume the JSON manifest, not the TypeScript manifest.
+- The JSON manifest should not include full Markdown content unless there is a specific reason; prefer storing content paths and reading Markdown during route-data generation.
+
+### Decision: Content Path Mapping for Node SEO Tools
+
+Manifest `contentPath` values are Vite/browser paths, such as:
+
+```txt
+/src/contents/v1/NET/async-await.md
+```
+
+Node SEO tooling must resolve these paths to filesystem paths safely.
+
+Rules:
+
+- Resolve manifest `contentPath` values relative to the project root.
+- Only allow paths under `src/contents/v1`.
+- Reject paths containing traversal attempts such as `..`.
+- Reject paths outside the expected content root.
+- Read Markdown with Node `fs`.
+- Do not use `import.meta.glob` in SEO postbuild or route-data loading.
+
+### Decision: Metadata Source-of-Truth Pipeline
+
+Use one metadata pipeline for sitemap generation, pre-rendered HTML, and React route metadata:
+
+```txt
+Markdown frontmatter -> generated manifest -> sitemap -> pre-render HTML -> React route metadata
+```
+
+Rules:
+
+- Markdown frontmatter is the authoring source for `seoTitle`, `seoDescription`, and optional `canonicalPath` overrides.
+- The generated manifest is the application source of truth consumed by SEO scripts and React routes.
+- Sitemap generation, pre-rendered source HTML, and `react-helmet-async` route metadata should use the same manifest-backed metadata builder.
+- Use `shared/seo/buildSeoMetadata.mjs` as the shared metadata builder.
+- Keep the shared metadata builder boring, pure, and dependency-free.
+- Do not use React, Vite-only features, browser-only APIs, or TypeScript runtime loading in the shared metadata builder.
+- Add a small type bridge such as `shared/seo/buildSeoMetadata.d.ts` if TypeScript imports from React code need explicit types.
+- Validate that the React TypeScript build can import the shared `.mjs` module without weakening type checking.
+- Do not duplicate route titles, descriptions, canonical URLs, or Open Graph URLs in separate hardcoded maps.
+- If source HTML metadata and hydrated React metadata disagree, treat it as a bug.
+
+### Decision: Content Route Data for Pre-rendering and Hydration
+
+Pre-rendered content pages must receive Markdown and curriculum metadata as route data before rendering.
+
+The client must hydrate with the same initial route data used during pre-rendering.
+
+Purpose:
+
+- Prevent `/content/:topicId/` pre-rendered HTML from containing only `Loading content...`.
+- Ensure source HTML contains visible Markdown-derived article content before JavaScript runs.
+- Keep pre-rendered markup and the first client render aligned to avoid hydration mismatch.
+- Keep the URL route parameter as the source of truth for content pages.
+
+Rules:
+
+- The pre-render script must load the selected topic's Markdown and curriculum metadata before rendering the route.
+- Content route data should include at least the topic, raw or body Markdown, SEO metadata, and canonical path.
+- The server/static render entry should receive this route data before rendering `/content/:topicId/`.
+- The server/static render entry should receive route data through the explicit `renderRoute` API.
+- The generated HTML should safely serialize the same route data for the client.
+- The client entry should read the serialized route data before hydration.
+- The serialized route data should be written only through the managed route-data template slot.
+- Serialized route data should include the minimum data needed for hydration.
+- Strip frontmatter before serializing Markdown unless the client explicitly needs it.
+- Escape serialized JSON so Markdown cannot break out of the script tag.
+- Validate that serialized route data handles `<`, `>`, `&`, `</script>`, and Unicode line separator characters safely.
+- `Content.tsx` should use preloaded route data when it matches the current URL topic ID.
+- If preloaded route data is missing or does not match the current URL, the client can fall back to the existing client-side load path.
+- Persisted Redux selected-topic state must not override the URL topic during hydration.
+- Invalid topic IDs should render Not Found + `noindex`, not redirect to the first available topic.
+- Sitemap-eligible content pages must never rely on effect-only Markdown loading for their source HTML.
+
+Example route data shape:
+
+```js
+{
+  topic: {
+    id: "async-await",
+    topic: "C# Language Foundations",
+    subtopic: "Async/Await",
+    category: ".NET"
+  },
+  markdown: "...",
+  metadata: {
+    title: "Async and Await in C# Interview Questions",
+    description: "...",
+    canonicalUrl: "https://www.dev-net-core.com/content/async-await/",
+    ogUrl: "https://www.dev-net-core.com/content/async-await/"
+  },
+  canonicalPath: "/content/async-await/"
+}
+```
+
+### Decision: Machine-Readable SEO Route Config
+
+Create one machine-readable SEO route config used by sitemap generation, metadata generation, pre-rendering, and validation.
+
+Suggested file:
+
+```txt
+shared/seo/seoRoutes.mjs
+```
+
+Purpose:
+
+- Keep route indexability decisions in code, not only in the Markdown route matrix.
+- Prevent sitemap, metadata, pre-render, and validation logic from drifting into separate hardcoded route lists.
+- Give `scripts/seo-postbuild.mjs` one source for static sitemap-eligible routes.
+- Give React route metadata one source for public route canonical/index/noindex behavior.
+
+Example shape:
+
+```js
+export const staticSeoRoutes = [
+  { path: "/", sitemap: true, index: true, prerender: true },
+  { path: "/content/", sitemap: true, index: true, prerender: true },
+  { path: "/roadmap/", sitemap: true, index: true, prerender: true },
+  { path: "/about-us/", sitemap: true, index: true, prerender: true },
+  { path: "/privacy/", sitemap: true, index: true, prerender: true },
+  { path: "/terms/", sitemap: true, index: true, prerender: true },
+  { path: "/bug-report/", sitemap: false, index: false, prerender: false },
+];
+```
+
+Rules:
+
+- The route config must match the route indexability matrix.
+- Sitemap generation, pre-rendering, and local SEO validation should consume this config.
+- Content topic routes should be generated from the curriculum manifest and then merged with this static route config.
+- A route marked `sitemap: true` must also be canonical, indexable, pre-rendered/static, and production validated.
+- App-only routes should remain out of the sitemap by default.
+
+### Decision: Content Readiness
+
+Do not add a separate `seoReady` or content-readiness flag for the first SEO pass.
+
+For DEV_NET_CORE, a curriculum subtopic is considered ready for sitemap generation when it has a valid Markdown file in the curriculum source and passes manifest/frontmatter validation.
+
+Rules:
+
+- If a subtopic has a valid `.md` file, it is eligible for `/content/:topicId/`.
+- The page still must pass metadata, sitemap, pre-render, and production validation before it is exposed in the production sitemap.
+- Do not introduce a separate per-topic readiness flag unless content publishing needs become more complex later.
+
+### Metadata Rules
+
+Use these patterns:
+
+Homepage:
+
+```txt
+Title: DEV_NET_CORE | Developer Interview Preparation
+Description: Structured interview preparation for .NET, React, SQL, Azure, architecture, and modern software engineering topics.
+Canonical: https://www.dev-net-core.com/
+```
+
+Content page:
+
+```txt
+Title: [Subtopic Name] Interview Questions | DEV_NET_CORE
+Description: Learn [Subtopic Name] for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.
+Canonical: https://www.dev-net-core.com/content/[topicId]/
+```
+
+Practice page:
+
+```txt
+Title: Practice [Subtopic Name] Interview Questions | DEV_NET_CORE
+Description: Practice [Subtopic Name] interview questions with expected answers, key points, and topic progress tracking.
+Canonical: https://www.dev-net-core.com/practice/[topicId]/
+```
+
+Simulation page:
+
+```txt
+Title: Mock Interview Simulation | DEV_NET_CORE
+Description: Practice a realistic technical interview session by selecting focus topics, difficulty level, and question count.
+Canonical: https://www.dev-net-core.com/simulation/
+```
+
+### Acceptance Criteria
+
+- Important pages have unique browser titles.
+- Important pages have unique meta descriptions.
+- Content pages use Markdown frontmatter metadata where available.
+- The generated curriculum manifest exposes `seoTitle`, `seoDescription`, and `canonicalPath` for content pages.
+- Manifest validation catches duplicate or malformed canonical paths.
+- Generated metadata fallbacks are available but not treated as the final long-term content strategy.
+- Invalid routes use `noindex`.
+- Metadata does not break routing or rendering.
+
+## Phase 5: Canonical URLs and Invalid Route Handling
+
+### 5. Add Canonical URLs
+
+Every indexable route should have one canonical URL.
+
+Use:
+
+```txt
+https://www.dev-net-core.com
+```
+
+as the production domain.
+
+Avoid duplicate canonical versions such as:
+
+```txt
+https://dev-net-core.com
+https://www.dev-net-core.com
+https://www.dev-net-core.com/content/topic
+https://www.dev-net-core.com/content/topic/
+```
+
+Pick one consistent URL format.
+
+Recommended:
+
+```txt
+Trailing slash for canonical URLs
+```
+
+Example:
+
+```txt
+https://www.dev-net-core.com/content/classes-structs-records/
+```
+
+### Decision: Trailing-Slash Canonical URLs
+
+DEV_NET_CORE should use trailing-slash URLs as the canonical format for public indexable routes.
+
+Reason:
+
+- Static pre-rendering commonly outputs `/route/index.html`.
+- That naturally maps to `/route/`.
+- The app already accepts trailing-slash route variants for important topic routes.
+- This avoids fighting the hosting platform later.
+
+Examples:
+
+```txt
+https://www.dev-net-core.com/content/async-and-await-semantics-in-csharp/
+https://www.dev-net-core.com/practice/async-and-await-semantics-in-csharp/
+https://www.dev-net-core.com/roadmap/
+https://www.dev-net-core.com/
+```
+
+Use the same trailing-slash format for:
+
+- Canonical URLs
+- Sitemap entries
+- Open Graph URLs
+- X/Twitter Card URLs
+- Structured data URLs
+- Internal generated links
+
+Non-trailing versions may continue to work for user convenience, but they should not be used in sitemap URLs, canonical tags, Open Graph URLs, X/Twitter Card URLs, structured data URLs, or internal generated links.
+
+Practical caveat: static public routes such as `/roadmap/`, `/about-us/`, and `/simulation/` should be explicitly supported in React Router and verified in production so canonical trailing-slash URLs work correctly.
+
+### 6. Handle Invalid Routes
+
+Invalid content or practice routes should not be indexed.
+
+For invalid routes:
+
+- Show a real Not Found page in the app.
+- Add:
+
+```html
+<meta name="robots" content="noindex">
+```
+
+This avoids soft-404 indexing issues.
+
+### Decision: Invalid Topic Routes
+
+Invalid topic routes should show a Not Found experience with `noindex`, not redirect to the first available topic.
+
+Recommended behavior:
+
+```txt
+/content/                  Valid index/welcome page
+/content/valid-topic-id/   Valid topic page
+/content/bad-topic-id/     Not Found + noindex
+/practice/                 Valid practice index page
+/practice/valid-topic-id/  Valid practice topic page
+/practice/bad-topic-id/    Not Found + noindex
+```
+
+Rules:
+
+- `/content/` with no topic remains a valid index/welcome route.
+- `/practice/` with no topic remains a valid practice index route.
+- Valid `/content/:topicId/` and `/practice/:topicId/` routes render the requested topic.
+- Valid topic pages use canonical trailing-slash URLs.
+- Invalid `/content/:topicId/` and `/practice/:topicId/` routes render the app's `NotFound` page or a clear topic-specific Not Found state.
+- Invalid routes include `<meta name="robots" content="noindex">`.
+- Invalid routes should not redirect to the first topic, because that can make bad URLs look like real curriculum pages and may create soft-404 or duplicate-content signals.
+- Unknown global routes should continue to use the app's Not Found behavior and should also include `noindex`.
+
+If pre-rendering/static generation is added later, generate only valid topic pages. Invalid generated/static paths should return real 404 behavior where the hosting setup allows it.
+
+### Decision: Production Hosting and Redirect Authority
+
+Production hosting is GitHub Pages with a Cloudflare-managed custom domain.
+
+Cloudflare is used for domain/DNS management. It should not be treated as the application host unless the site is explicitly migrated to Cloudflare Pages or Cloudflare proxy/rules are configured.
+
+Redirect and rewrite behavior should be assumed to come from GitHub Pages unless Cloudflare proxy/rules are explicitly enabled and documented.
+
+Rules:
+
+- Valid sitemap URLs must resolve to real GitHub Pages-served static files or another verified `200 OK` production response.
+- Valid sitemap URLs must not depend on the generic `404.html` SPA fallback.
+- Do not assume Cloudflare enforces trailing-slash redirects unless Cloudflare proxy/rules are configured.
+- If Cloudflare rules are used later, document the exact rules and validate them in production.
+- If Cloudflare Pages replaces GitHub Pages later, update this plan before relying on Cloudflare Pages routing behavior.
+
+Current deployment note: the GitHub Actions workflow creates an SPA fallback by copying `dist/index.html` to `dist/404.html`. That fallback may make browser navigation appear to work, but it must not be the only mechanism supporting URLs included in `sitemap.xml`.
+
+### Decision: SSG-Only Hosting Model for GitHub Pages
+
+DEV_NET_CORE should use SSR-style rendering only at build time while the site remains hosted on GitHub Pages.
+
+GitHub Pages can serve static HTML, CSS, JavaScript, images, and generated route files, but it cannot run a React SSR server per request.
+
+Rules:
+
+- Keep GitHub Pages as the production host for the current SEO plan.
+- Use the SSR/SSG readiness refactor to generate static HTML during the build.
+- Do not introduce request-time SSR unless the project intentionally migrates hosting.
+- Generated sitemap URLs must map to static files in `dist`, such as `dist/content/async-await/index.html`.
+- The build may use React SSR APIs internally, but the deployed output must remain static.
+- If runtime SSR becomes a future requirement, create a separate hosting migration plan before changing the deployment target.
+
+Expected static deployment flow:
+
+```txt
+npm run build
+-> Vite client build
+-> SEO/SSG postbuild renders static HTML route files
+-> dist contains route index.html files, sitemap.xml, assets, and optional 404.html fallback
+-> GitHub Pages deploys dist
+```
+
+### Decision: Deployment and Status-Code Handling
+
+Every URL included in `sitemap.xml` must return `200 OK` on direct load without depending on a generic GitHub Pages-style `404.html` fallback as the only route handling mechanism.
+
+Invalid routes should return a real `404` where the hosting platform allows it. If true 404 status handling is not practical because of SPA routing, invalid/error routes must render a clear Not Found page and include:
+
+- `<meta name="robots" content="noindex">`
+- A clear page title such as `Page Not Found | DEV_NET_CORE`
+- No sitemap entry
+- No internal links pointing to the invalid URL
+- No redirect to the first topic or another valid content page
+
+Invalid routes should not use canonical tags that point to valid topic pages, because that can make bad URLs look like alternate versions of real content.
+
+Follow the `noindex` vs `robots.txt` decision from Phase 1 for invalid SPA routes.
+
+### Decision: Dedicated Static 404 Output
+
+If `dist/404.html` is needed for GitHub Pages SPA fallback behavior, generate it as a dedicated Not Found document instead of blindly copying `dist/index.html`.
+
+Rules:
+
+- `dist/404.html` should render a clear Not Found page in source HTML.
+- `dist/404.html` should include `noindex`.
+- `dist/404.html` should not include a canonical tag pointing to a valid content route.
+- `dist/404.html` should not be listed in `sitemap.xml`.
+- The SEO postbuild script should generate or validate the dedicated `404.html` output.
+- A workflow fallback copy step must not overwrite a dedicated `404.html` generated by SEO postbuild.
+- If the dedicated `404.html` hydrates into the React app, it must still keep Not Found + `noindex` behavior for invalid routes.
+- No sitemap URL may be considered valid merely because it can be reached through `404.html`.
+
+### Decision: Route Indexability Matrix
+
+Use this matrix to decide which routes belong in the sitemap, which routes are indexable, and how non-canonical variants should behave.
+
+Rules:
+
+- Only rows with `Sitemap = Yes` should appear in `sitemap.xml`.
+- `Sitemap = Yes` means indexable + canonical + static/pre-rendered + production validated.
+- Sitemap URLs must be the final canonical trailing-slash URLs.
+- Non-trailing variants should preferably redirect with `301` to the trailing-slash canonical URL.
+- If the host cannot do real redirects, non-trailing variants may return `200`, but they must use canonical tags pointing to the trailing-slash URL and must not appear in the sitemap.
+- Invalid routes should not have canonical tags that point to real content pages.
+- Routes not currently supported with trailing slashes must be explicitly supported before they are used as canonical URLs.
+
+| Route | Sitemap | Index | Canonical | Redirect | Expected status |
+|---|---:|---:|---|---|---|
+| `/` | Yes | Yes | `/` | No | 200 |
+| `/home` | No | Canonical target only | `/` | Prefer redirect to `/` | 301 preferred, 200 acceptable |
+| `/home/` | No | Canonical target only | `/` | Prefer redirect to `/` | 301 preferred, 200 acceptable |
+| `/content` | No | Canonical target only | `/content/` | Prefer redirect to `/content/` | 301 preferred, 200 acceptable |
+| `/content/` | Yes | Yes | `/content/` | No | 200 |
+| `/content/:topicId` | No | Canonical target only | `/content/:topicId/` | Prefer redirect to trailing slash | 301 preferred, 200 acceptable |
+| `/content/:topicId/` | Yes | Yes | `/content/:topicId/` | No | 200 |
+| `/practice` | No | Canonical target only | `/practice/` | Prefer redirect to `/practice/` | 301 preferred, 200 acceptable |
+| `/practice/` | No by default | Optional landing index | `/practice/` | No | 200 |
+| `/practice/:topicId` | No | Noindex or canonical target only | `/practice/:topicId/` | Prefer redirect to trailing slash | 301 preferred, 200 acceptable |
+| `/practice/:topicId/` | No unless intentionally indexable | Noindex first | `/practice/:topicId/` | No | 200 |
+| `/simulation` | No | Canonical target only | `/simulation/` | Prefer redirect to `/simulation/` | 301 preferred, 200 acceptable |
+| `/simulation/` | Optional landing only | Optional landing index | `/simulation/` | No | 200 |
+| `/simulation/setup` | No | Noindex | `/simulation/setup/` | Prefer redirect to trailing slash | 301 preferred, 200 acceptable |
+| `/simulation/setup/` | No | Noindex | `/simulation/setup/` | No | 200 |
+| `/simulation/session/:sessionId` | No | Noindex | None or self | No | 200 |
+| `/simulation/result/:sessionId` | No | Noindex | None or self | No | 200 |
+| `/roadmap` | No | Canonical target only | `/roadmap/` | Prefer redirect to `/roadmap/` | 301 preferred, 200 acceptable |
+| `/roadmap/` | Yes | Yes | `/roadmap/` | No | 200 |
+| `/about-us` | No | Canonical target only | `/about-us/` | Prefer redirect to `/about-us/` | 301 preferred, 200 acceptable |
+| `/about-us/` | Yes | Yes | `/about-us/` | No | 200 |
+| `/changelog` | No | Canonical target only | `/changelog/` | Prefer redirect to `/changelog/` | 301 preferred, 200 acceptable |
+| `/changelog/` | Optional | Optional | `/changelog/` | No | 200 |
+| `/bug-report` | No | Noindex | `/bug-report/` | Prefer redirect to `/bug-report/` | 301 preferred, 200 acceptable |
+| `/bug-report/` | No | Noindex | `/bug-report/` | No | 200 |
+| `/privacy` | No | Canonical target only | `/privacy/` | Prefer redirect to `/privacy/` | 301 preferred, 200 acceptable |
+| `/privacy/` | Yes | Yes | `/privacy/` | No | 200 |
+| `/terms` | No | Canonical target only | `/terms/` | Prefer redirect to `/terms/` | 301 preferred, 200 acceptable |
+| `/terms/` | Yes | Yes | `/terms/` | No | 200 |
+| Invalid routes | No | Noindex | None | Prefer real 404 route | 404 where possible, otherwise 200 + noindex |
+
+`/content/:topicId/` is the main SEO asset for each curriculum topic. `/practice/:topicId/` is useful for users, but should stay `noindex` at first unless those pages are intentionally written with unique visible content.
+
+Google warns that SPA error pages can cause soft 404s. For client-side routing, prefer redirecting to a URL that returns a real `404` where practical, or add `noindex` to error pages when true 404 status handling is not practical.
+
+### Decision: Deep-Link UX Matrix
+
+Use this matrix to separate SEO sitemap requirements from app-only deep-link behavior.
+
+Routes included in the sitemap must never depend on the generic SPA `404.html` fallback. App-only routes may use the fallback when needed, but they must stay out of the sitemap and use `noindex` when crawlable.
+
+| Route | SEO sitemap? | Direct-load status required? | Static artifact? | Accept 404 fallback? | Notes |
+|---|---:|---:|---:|---:|---|
+| `/` | Yes | `200` | Yes | No | Main homepage. Must be fully production-ready. |
+| `/home/` | No | Optional | Optional | No | Prefer redirect/canonical to `/`, or remove from sitemap. |
+| `/content/` | Yes | `200` | Yes | No | Curriculum landing page. |
+| `/content/:topicId/` | Yes | `200` | Yes | No | Main SEO target pages. Must have static/pre-rendered HTML. |
+| `/practice/` | No by default | `200` if public | Optional | Yes if noindex/app-only | Useful app page, but not primary SEO page. |
+| `/practice/:topicId/` | No by default | `200` if public | Optional | Yes if noindex/app-only | Prefer noindex unless it has unique searchable content. |
+| `/simulation/` | Optional | `200` if indexed | Required only if sitemap yes | No if sitemap yes | Include only if landing page has real content. |
+| `/simulation/setup/` | No | `200` if public app flow | No | Yes | App flow page, not search target. Add noindex if crawled. |
+| `/simulation/session/:sessionId/` | No | `200` or app fallback | No | Yes | Session-specific route. Must not be in sitemap. Noindex. |
+| `/simulation/result/:sessionId/` | No | `200` or app fallback | No | Yes | Session-specific route. Must not be in sitemap. Noindex. |
+| `/roadmap/` | Yes | `200` | Yes | No | Index only if it has meaningful visible content. |
+| `/about-us/` | Yes | `200` | Yes | No | Brand/about page. |
+| `/changelog/` | Optional | `200` if indexed | Required only if sitemap yes | No if sitemap yes | Include only if you want it indexed. |
+| `/bug-report/` | No | `200` if public | No | Yes | Utility page. Noindex. |
+| `/privacy/` | Yes | `200` | Yes | No | Legal page. |
+| `/terms/` | Yes | `200` | Yes | No | Legal page. |
+| Non-trailing variants | No | Prefer redirect to trailing slash | No | No | Example: `/content/topic` -> `/content/topic/`. |
+| Invalid routes | No | Prefer real `404` | No | Yes | If SPA fallback makes this `200`, render clear Not Found + `noindex`. |
+
+### Acceptance Criteria
+
+- Valid pages have canonical URLs.
+- Every URL included in `sitemap.xml` returns `200 OK` on direct load.
+- The route indexability matrix is implemented or explicitly verified for production behavior.
+- The deep-link UX matrix is implemented or explicitly verified for production behavior.
+- Non-canonical route variants redirect to or canonicalize to their trailing-slash canonical URL.
+- Invalid pages are not indexable.
+- Existing user navigation still works.
+- Invalid topic IDs do not redirect to the first topic.
+- `/content/` and `/practice/` index routes remain valid.
+
+## Phase 6: Structured Data
+
+### 7. Add Website Structured Data
+
+On the homepage, add JSON-LD:
+
+```json
+{
+  "@context": "https://schema.org",
+  "@type": "WebSite",
+  "name": "DEV_NET_CORE",
+  "url": "https://www.dev-net-core.com/",
+  "description": "A developer-focused interview preparation website for .NET, React, SQL, Azure, architecture, and software engineering topics."
+}
+```
+
+### 8. Add Article Structured Data for Content Pages
+
+For each content topic, add JSON-LD like:
+
+```json
+{
+  "@context": "https://schema.org",
+  "@type": "Article",
+  "headline": "Async/Await in C# Interview Questions",
+  "description": "Learn async and await in C# for technical interviews.",
+  "url": "https://www.dev-net-core.com/content/async-await/",
+  "author": {
+    "@type": "Person",
+    "name": "Minh Vu"
+  }
+}
+```
+
+### Recommended Implementation
+
+Generate structured data from the shared metadata builder and inject it into source HTML through SEO postbuild.
+
+The React SEO component may mirror the same JSON-LD after hydration, but it should not be the source of truth for sitemap URLs.
+
+Example:
+
+```html
+<script type="application/ld+json">
+  {"@context":"https://schema.org","@type":"Article"}
+</script>
+```
+
+Make sure JSON is valid and does not include undefined values.
+
+Rules:
+
+- Use the same route metadata source as canonical, Open Graph, and Twitter/X tags.
+- Keep JSON-LD aligned with visible page content.
+- Inject JSON-LD into pre-rendered source HTML for every sitemap URL where structured data is used.
+- Validate JSON-LD against Google's structured data rules before deployment.
+- Do not emit structured data for routes where the visible source content does not support it.
+
+### Acceptance Criteria
+
+- Homepage includes valid `WebSite` structured data.
+- Content pages include valid `Article` structured data.
+- Structured data matches visible page content.
+- Structured data exists in source HTML for sitemap URLs after pre-render/static generation.
+- Structured data can be validated using Google Rich Results Test or Schema Markup Validator.
+
+## Phase 7: Markdown Content SEO Improvements
+
+### 9. Improve Topic Titles
+
+Each Markdown topic should have a clear H1 that includes search intent.
+
+Good:
+
+```md
+# Async/Await in C# Interview Questions
+```
+
+Less ideal:
+
+```md
+# Async/Await
+```
+
+### 10. Improve Topic Introductions
+
+The first paragraph should clearly explain the page topic and interview relevance.
+
+Good example:
+
+```md
+Async and await are core C# features used to write asynchronous code for I/O-bound operations such as database calls, HTTP requests, and file access. Interviewers often ask this topic to check whether candidates understand Task, thread usage, exception handling, cancellation, and common deadlock risks.
+```
+
+### 11. Preserve Required Markdown Structure
+
+Do not break the existing app extraction rules.
+
+Each content file should generally keep:
+
+```md
+# Topic Name
+
+## Overview
+
+## Core Concepts
+
+## Common Interview Questions
+```
+
+Question markers must remain stable and balanced.
+
+### Decision: Content Quality for Indexable Topic Pages
+
+Index:
+
+```txt
+/content/:topicId/
+```
+
+Noindex:
+
+```txt
+/practice/:topicId/
+/simulation/*
+```
+
+Reason:
+
+- `/content/:topicId/` is the real educational landing page.
+- `/practice/:topicId/` is an app interaction page.
+- `/simulation/*` is session/user-flow content, not search landing content.
+
+If a related practice route is `noindex`, the matching content route must fully satisfy the search intent.
+
+For example, if `/practice/async-await/` is `noindex`, then `/content/async-await/` must include enough visible content to rank for queries such as:
+
+```txt
+C# async await interview questions
+async await C# interview
+Task vs thread C# interview
+```
+
+Each indexable content page should include:
+
+- Clear H1 with the topic and interview intent
+- Strong opening paragraph
+- Practical explanation
+- Core concepts
+- Code examples where useful
+- Trade-offs
+- Common mistakes
+- Best practices
+- Interview questions and expected answers
+- Internal links to related topics
+
+This aligns with Google's guidance to create substantial, complete, helpful content for people rather than thin pages made primarily for search engines.
+
+### Acceptance Criteria
+
+- Topic titles are descriptive.
+- Introductions explain interview relevance.
+- Indexable content pages are strong enough to satisfy the relevant interview search intent without depending on the matching practice page.
+- `/practice/:topicId/` and `/simulation/*` routes stay `noindex` unless they are later redesigned as standalone searchable pages.
+- Markdown still renders correctly.
+- Practice questions still extract correctly.
+- Simulation question generation still works.
+
+## Phase 8: Pre-Rendering
+
+### 12. Pre-render All Sitemap-Eligible Routes
+
+Static/pre-rendered output is required for every route included in `sitemap.xml` before submitting the sitemap to Google Search Console.
+
+Current Vite React SPA behavior may rely on JavaScript rendering. Google can render JavaScript, but pre-rendered HTML is faster and easier for crawlers.
+
+### Pre-Render Proof of Concept
+
+Before implementing pre-rendering for the full route set, run a small proof of concept for one representative topic route.
+
+Recommended proof-of-concept route:
+
+```txt
+/content/classes-structs-records/
+```
+
+The proof of concept should validate:
+
+- Static output exists at `dist/content/classes-structs-records/index.html`.
+- Production direct load returns `200 OK`.
+- Production direct load does not redirect.
+- Source HTML contains route-specific title, description, canonical URL, Open Graph URL, and `og:image`.
+- Source HTML contains visible page content, not only a generic app shell.
+- React hydration still works after the page loads.
+- The generated URL matches the trailing-slash canonical format.
+
+Use the result to confirm the pre-rendering approach before applying it to every sitemap-eligible route.
+
+Recommended approach:
+
+- Keep the current Vite + React app.
+- Add route pre-rendering for every route that will be included in the sitemap.
+- Generate route-specific initial HTML metadata for indexable pages.
+- Generate visible source HTML content for every sitemap URL.
+- Generate required sitemap-eligible routes:
+  - `/`
+  - `/content/`
+  - `/content/:topicId/`
+  - `/roadmap/`
+  - `/about-us/`
+  - `/privacy/`
+  - `/terms/`
+- Generate optional sitemap-eligible routes only if they are intended to rank:
+  - `/changelog/`
+  - `/simulation/`
+
+Do not include optional routes unless they have enough unique visible content and are intended to rank.
+
+Do not pre-render `/practice/:topicId/` pages in the first SEO pass. Those pages are interactive workflow pages and should stay `noindex` unless they are later redesigned as standalone searchable Q&A landing pages.
+
+### Decision: Submit Sitemap Only After Pre-Rendering
+
+Do not submit the full sitemap containing `Sitemap = Yes` URLs to Google Search Console until every included route has pre-rendered/static HTML and production validation passes.
+
+During earlier local foundation work, sitemap generation can be implemented and tested locally. However, do not expose a full production sitemap through `robots.txt` or Search Console until every sitemap URL is pre-rendered and validated.
+
+Recommended order:
+
+1. Finish the SEO technical foundation locally.
+2. Complete the pre-render proof of concept.
+3. Implement pre-render/static HTML for every sitemap-eligible route.
+4. Validate production URLs and source HTML.
+5. Submit the sitemap to Google Search Console.
+
+Reason:
+
+- `/content/:topicId/` is the main SEO asset, but every sitemap URL must meet the same standard.
+- URLs in `sitemap.xml` must direct-load with `200 OK`.
+- Route-specific title, description, canonical URL, and Open Graph tags should exist in the initial HTML before search engines and social crawlers inspect the full topic set.
+- Submitting sitemap URLs before pre-rendering can create inconsistent crawl, render, soft-404, and social-preview signals.
+
+### Options
+
+Option A: Add Vite pre-rendering to current app.
+
+Best first choice because it avoids a major migration.
+
+Option B: Move content pages to Astro.
+
+Good if content SEO becomes the main product priority.
+
+Option C: Move the app to Next.js.
+
+Good only if the project later needs stronger SSR or backend/API features.
+
+### Recommendation
+
+Do not migrate to Astro or Next.js immediately.
+
+First implement the SEO foundation in the current Vite app:
+
+```txt
+robots.txt + manifest-driven sitemap generation + metadata + canonical URLs + pre-rendered sitemap-eligible routes
+```
+
+Then validate production URLs and submit the sitemap to Search Console.
+
+### Acceptance Criteria
+
+- Every sitemap URL has meaningful HTML before JavaScript fully runs.
+- `/content/:topicId/` pages have route-specific source HTML metadata.
+- Static pages included in the sitemap have route-specific source HTML metadata.
+- Generated pages still hydrate correctly.
+- Routes still work after refresh.
+- Deployment still works on GitHub Pages with the Cloudflare-managed custom domain.
+
+## Production Validation Gate Before Search Console Submission
+
+Do not submit the sitemap to Google Search Console until production URL validation passes.
+
+For every URL in `sitemap.xml`, verify:
+
+- URL is absolute.
+- URL uses the canonical trailing-slash format.
+- URL returns `200 OK` on direct load.
+- URL does not redirect.
+- URL is not blocked by `robots.txt`.
+- URL does not contain `noindex`.
+- URL has a canonical tag matching itself.
+- URL has route-specific source HTML metadata before JavaScript runs.
+- URL has unique title and meta description.
+- URL has correct Open Graph URL.
+- URL has route-specific or fallback Open Graph metadata in source HTML.
+- URL has visible page content in source HTML.
+- URL appears only once in the sitemap.
+
+Suggested check command:
+
+```bash
+curl -I https://www.dev-net-core.com/content/classes-structs-records/
+```
+
+Also inspect HTML:
+
+```bash
+curl -L https://www.dev-net-core.com/content/classes-structs-records/
+```
+
+Do not rely only on local dev behavior. Validate against the production GitHub Pages website on the Cloudflare-managed custom domain.
+
+Important caveat: if metadata is added only by React at runtime, `curl` will not show route-specific metadata. That should be recorded as a limitation until pre-rendering/static HTML generation is added. Google can render JavaScript, but server-side rendering or pre-rendering is still a good idea because it is faster for users and crawlers, and not all bots can run JavaScript.
+
+## Phase 9: Search Console and Bing Webmaster Tools
+
+### 13. Set Up Google Search Console
+
+Do this only after every sitemap-included route has static/pre-rendered production output and the Production Validation Gate passes.
+
+Steps:
+
+1. Go to Google Search Console.
+2. Add the domain property:
+
+```txt
+dev-net-core.com
+```
+
+3. Verify ownership using Cloudflare DNS.
+4. Confirm every sitemap-included route has static/pre-rendered source HTML.
+5. Complete the Production Validation Gate Before Search Console Submission.
+6. Submit:
+
+```txt
+https://www.dev-net-core.com/sitemap.xml
+```
+
+7. Use URL Inspection for sitemap-included routes:
+   - Homepage
+   - `/content/`
+   - A few important topic pages
+   - `/roadmap/`
+   - `/about-us/`
+   - `/privacy/`
+   - `/terms/`
+   - `/changelog/` only if included
+   - `/simulation/` only if included
+
+8. Request indexing for key pages.
+
+### 14. Set Up Bing Webmaster Tools
+
+Steps:
+
+1. Open Bing Webmaster Tools.
+2. Import from Google Search Console if available.
+3. Submit the sitemap.
+4. Check indexing status.
+
+### Acceptance Criteria
+
+- Google Search Console property is verified.
+- Production Validation Gate Before Search Console Submission passes before sitemap submission.
+- Sitemap is submitted.
+- Google can fetch and render important URLs.
+- Bing Webmaster Tools is configured.
+- Indexing issues are documented.
+
+## Phase 10: Favicon and Branding SEO
+
+### 15. Add Website Icon Files
+
+Recommended files:
+
+```txt
+public/favicon.ico
+public/favicon.svg
+public/apple-touch-icon.png
+public/icon-192.png
+public/icon-512.png
+```
+
+Add to `index.html`:
+
+```html
+<link rel="icon" href="/favicon.ico" sizes="any" />
+<link rel="icon" href="/favicon.svg" type="image/svg+xml" />
+<link rel="apple-touch-icon" href="/apple-touch-icon.png" />
+```
+
+### Acceptance Criteria
+
+- Favicon loads in browser tabs.
+- Favicon files are crawlable.
+- Homepage is crawlable.
+- The icon appears correctly on desktop and mobile.
+
+## Phase 11: Monitoring and Iteration
+
+### 16. Monitor Indexing
+
+Check Google Search Console weekly after deployment.
+
+Manual checks are enough for the first SEO pass. Automated production validation can be added later as an optional scheduled Codex check.
+
+Watch:
+
+- Indexed pages
+- Crawled but not indexed pages
+- Discovered but not indexed pages
+- Duplicate without user-selected canonical
+- Soft 404
+- Page with redirect
+- Not found
+- Core Web Vitals
+- Search queries
+- Click-through rate
+
+### 17. Improve Based on Data
+
+If important pages are not indexed:
+
+- Check whether the page has unique content.
+- Check whether the page appears in sitemap.
+- Check whether internal links point to it.
+- Check whether canonical URL is correct.
+- Check whether it is accidentally `noindex`.
+- Check rendered HTML.
+- Check whether pre-rendered source HTML and route-specific metadata are present in production.
+
+If impressions are low:
+
+- Improve H1.
+- Improve title.
+- Improve meta description.
+- Add stronger intro content.
+- Add more specific subheadings.
+- Add internal links from related topics.
+- Add more complete expected answers.
+
+## Suggested Implementation Tasks
+
+### Task 1: Add Basic SEO Files
+
+Files:
+
+```txt
+public/robots.txt
+```
+
+Optional only if it contains already-validated URLs:
+
+```txt
+public/sitemap.xml
+```
+
+Do not deploy a full production sitemap from `public/`. Final sitemap output belongs to the SEO postbuild script and should be written to `dist/sitemap.xml`.
+
+Validation:
+
+```bash
+npm run build
+```
+
+### Task 2: Extend Curriculum Manifest for SEO Fields
+
+Files:
+
+```txt
+scripts/generate-curriculum-manifest.mjs
+src/contents/curriculumManifest.generated.ts
+shared/content/curriculumSeoManifest.generated.json
+src/contents/v1/**/*.md
+```
+
+Implementation:
+
+- Parse `seoTitle`, `seoDescription`, and optional `canonicalPath` from Markdown frontmatter.
+- Generate `canonicalPath` as `/content/[id]/` when it is not explicitly provided.
+- Continue generating the TypeScript manifest for React app navigation and question extraction.
+- Generate a Node-readable SEO manifest JSON for SEO postbuild tooling.
+- Include content path, canonical path, title/subtopic/topic/category, and SEO fields in the SEO manifest.
+- Validate missing SEO fields after the transition period.
+- Validate duplicate `canonicalPath` values.
+- Validate trailing-slash canonical paths.
+- Do not parse or maintain manual `lastmod` values from Markdown frontmatter.
+- Keep fallback metadata available during transition.
+- Ensure the SEO manifest includes enough data for static route HTML, sitemap URLs, metadata, and route data generation.
+
+Validation:
+
+```bash
+npm run generate:curriculum
+npm run build
+```
+
+### Optional Task 2A: Content Metadata Rollout Strategy
+
+This is an optional planning task to make the frontmatter metadata rollout manageable across the Markdown curriculum.
+
+Goal:
+
+- Add custom `seoTitle` and `seoDescription` fields gradually without blocking the technical SEO foundation.
+- Prioritize high-value content pages first.
+- Avoid shipping a large set of repetitive fallback descriptions into the sitemap.
+
+Recommended approach:
+
+1. Create a short metadata rollout checklist for curriculum topics.
+2. Prioritize pages likely to drive search demand, such as C# fundamentals, ASP.NET Core, async/await, Entity Framework, SQL indexing, React hooks, and Azure hosting topics.
+3. Track whether each indexable topic has:
+   - Custom `seoTitle`
+   - Custom `seoDescription`
+   - Generated or verified `canonicalPath`
+   - No manual `lastmod`
+4. Allow fallback metadata during local implementation and early migration.
+5. Before submitting the production sitemap, confirm every `/content/:topicId/` URL included in the sitemap has either custom metadata or an explicitly accepted temporary fallback.
+
+Optional artifact:
+
+```txt
+docs/plans/content-metadata-rollout.md
+```
+
+Validation:
+
+- Metadata rollout list exists if this optional task is used.
+- High-priority topic pages are identified.
+- Sitemap-included topic pages have non-repetitive titles and descriptions before Search Console submission.
+
+### Task 3: Generate Sitemap from Curriculum Manifest
+
+Files:
+
+```txt
+scripts/seo-postbuild.mjs
+package.json
+shared/content/curriculumSeoManifest.generated.json
+```
+
+Implementation:
+
+- Generate sitemap data from the Node-readable SEO manifest and sitemap-eligible static route list.
+- Write final production sitemap output to `dist/sitemap.xml` from the custom SEO postbuild script.
+- Do not rely on `public/sitemap.xml` for the final production sitemap unless it contains only already-validated URLs.
+- Ensure sitemap generation happens after Vite has produced `dist`.
+- Read `dist/index.html` as the base route HTML template.
+- Preserve Vite-generated script, stylesheet, preload, modulepreload, and asset references.
+- Import only the built server/static render entry from the private build output, such as `dist-server/entry-server.js`.
+- Do not import TypeScript files, Vite-only modules, `import.meta.glob`, or React app internals from the postbuild script.
+- Inject route-specific metadata from the shared metadata builder.
+- Inject safe serialized route data for content pages that need hydration data.
+- Validate that no sitemap route depends on `dist/404.html`.
+- Start with warning-mode validation while the SSG/pre-render proof of concept is still incomplete.
+- Switch to strict mode only after the pre-render proof of concept validates static output, source HTML content, and hydration.
+
+Validation:
+
+```bash
+npm run build
+```
+
+### Task 3A: Add Machine-Readable SEO Route Config
+
+Create a shared route config that encodes the route indexability matrix for static non-content routes.
+
+Suggested files:
+
+```txt
+shared/seo/seoRoutes.mjs
+shared/seo/seoRoutes.d.ts
+scripts/seo-postbuild.mjs
+```
+
+Implementation:
+
+- Define static route metadata for routes such as `/`, `/content/`, `/roadmap/`, `/about-us/`, `/privacy/`, `/terms/`, `/bug-report/`, `/practice/`, and `/simulation/`.
+- Include route fields such as `path`, `sitemap`, `index`, `prerender`, and optional `canonicalPath`.
+- Keep canonical paths in trailing-slash format.
+- Exclude app-only, user-flow-only, and utility routes from the sitemap by default.
+- Merge generated content topic routes from the curriculum manifest with this static route config during sitemap and pre-render generation.
+- Use this config from sitemap generation, pre-rendering, route metadata, and local validation scripts.
+- Add `.d.ts` typing if React TypeScript code imports the `.mjs` route config.
+
+Validation:
+
+```bash
+npm run lint
+npm run build
+```
+
+### Task 4: Add Shared SEO Metadata Builder
+
+Create one manifest-backed metadata builder used by sitemap generation, pre-rendered HTML, and React route metadata.
+
+Suggested files:
+
+```txt
+shared/seo/buildSeoMetadata.mjs
+shared/seo/buildSeoMetadata.d.ts
+shared/seo/seoRoutes.mjs
+shared/content/curriculumSeoManifest.generated.json
+scripts/seo-postbuild.mjs
+src/components/seo/Seo.tsx
+src/pages/Content.tsx
+```
+
+Implementation:
+
+- Implement the builder as a plain `.mjs` module with no React dependency.
+- Keep it pure, dependency-free, and boring.
+- Do not use browser-only APIs such as `window`, `document`, `localStorage`, or `navigator`.
+- Do not depend on Vite-only features, Vite-only aliases, TypeScript runtime loading, or unguarded `import.meta.env` values.
+- Ensure the module can be consumed by both Node scripts and React code.
+- Add `shared/seo/buildSeoMetadata.d.ts` or an equivalent type bridge if TypeScript needs explicit declarations for the `.mjs` import.
+- Validate the React TypeScript build without disabling strict type checking for SEO modules.
+- Build route metadata from the generated SEO manifest and static route definitions.
+- Generate title, description, canonical URL, Open Graph URL, and default Open Graph image values from one source.
+- Use Markdown frontmatter fields where available.
+- Use temporary fallbacks only during transition.
+- Keep canonical paths in trailing-slash format.
+- Do not duplicate metadata in separate hardcoded maps for sitemap, pre-rendering, and React routes.
+- Treat mismatches between pre-rendered source HTML metadata and hydrated React metadata as bugs.
+
+Validation:
+
+```bash
+npm run lint
+npm run build
+```
+
+### Task 5: Add SEO Component
+
+Files:
+
+```txt
+public/og/default-og-image.png
+src/components/seo/Seo.tsx
+src/main.tsx
+src/App.tsx
+```
+
+Validation:
+
+```bash
+npm run lint
+npm run build
+```
+
+### Task 6: Add Metadata to Core Pages
+
+Files:
+
+```txt
+public/og/default-og-image.png
+src/pages/Home.tsx
+src/pages/Content.tsx
+src/pages/Practice.tsx
+src/pages/Simulation.tsx
+src/pages/Roadmap.tsx
+src/pages/AboutUs.tsx
+src/pages/NotFound.tsx
+```
+
+Validation:
+
+```bash
+npm run lint
+npm run build
+```
+
+### Task 7: Write Structured Data Rules Note
+
+Before adding structured data, write a short project note summarizing the Google structured data rules DEV_NET_CORE will follow.
+
+Suggested file:
+
+```txt
+docs/plans/structured-data-rules.md
+```
+
+The note should cover:
+
+- Structured data must match visible page content.
+- Do not invent author, publisher, date, rating, review, FAQ, or article facts.
+- Use only schema types that accurately describe the page.
+- Do not add structured data to pages where the visible content does not support it.
+- Validate structured data with Google Rich Results Test or Schema Markup Validator when possible.
+
+Validation:
+
+- The note exists.
+- The structured data implementation plan is checked against the note before code changes.
+- Any structured data fields that cannot be verified against visible content are removed or deferred.
+
+### Task 8: Add Structured Data
+
+Files:
+
+```txt
+src/components/seo/Seo.tsx
+src/pages/Home.tsx
+src/pages/Content.tsx
+```
+
+Validation:
+
+```bash
+npm run lint
+npm run build
+```
+
+### Task 9: Review Internal Links
+
+Files:
+
+```txt
+src/components/content/CurriculumTreeView.tsx
+src/components/content/LeftContentPanel.tsx
+src/components/content/RightContentPanel.tsx
+src/pages/Practice.tsx
+```
+
+Validation:
+
+```bash
+npm run lint
+npm run build
+```
+
+### Task 10: Add Explicit Trailing-Slash Route Support
+
+Files:
+
+```txt
+src/App.tsx
+```
+
+Add explicit route support for canonical trailing-slash URLs.
+
+Examples:
+
+- `/content/`
+- `/practice/`
+- `/simulation/`
+- `/roadmap/`
+- `/about-us/`
+- `/changelog/`
+- `/privacy/`
+- `/terms/`
+- `/bug-report/`
+- `/simulation/setup/`
+
+Non-trailing variants may continue to work for user convenience, but they should redirect to or canonicalize to the trailing-slash URL.
+
+Important caveat: explicit React Router support only fixes client-side route matching. It does not guarantee `200 OK` on direct production loads from GitHub Pages. Sitemap URLs still need real static output, verified production behavior, or another confirmed hosting solution.
+
+Validation:
+
+```bash
+npm run lint
+npm run build
+```
+
+Manual validation:
+
+- Load each canonical trailing-slash route in the app.
+- Confirm non-trailing variants redirect to or canonicalize to the matching trailing-slash URL.
+- Confirm route behavior still matches the route indexability matrix.
+
+### Task 11: Update AGENTS.md SEO Context
+
+Perform this task immediately after the SEO plan is finalized and before implementation work begins.
+
+Update `AGENTS.md` so future Codex work follows the SEO plan's route, invalid-topic, sitemap, and pre-rendering decisions.
+
+Files:
+
+```txt
+AGENTS.md
+docs/plans/dev-net-core-seo-improvement-plan.md
+```
+
+Implementation:
+
+- Record that invalid content/practice topic IDs should render Not Found + `noindex`, not redirect to the first available topic.
+- Record that canonical public SEO URLs use trailing slashes.
+- Record that sitemap URLs require static/pre-rendered production output and must not depend on the GitHub Pages `404.html` SPA fallback.
+- Record that `/practice/:topicId/`, `/simulation/*`, and utility routes are noindex/no-sitemap by default.
+- Keep AGENTS.md concise and aligned with the final SEO plan.
+
+Validation:
+
+- `AGENTS.md` no longer conflicts with the SEO plan.
+- Route behavior guidance in `AGENTS.md` matches the route indexability and deep-link UX matrices.
+
+### Task 11A0: React Router 7 SSG Spike
+
+Before writing the final SEO postbuild implementation, run a spike to determine whether React Router framework-mode SSG is a better fit than the custom Vite SSR/SSG + SEO postbuild approach.
+
+This is an investigation task, not a migration commitment.
+
+Files to inspect:
+
+```txt
+package.json
+vite.config.ts
+src/App.tsx
+src/main.tsx
+src/layouts/MainLayout.tsx
+src/pages/Content.tsx
+scripts/generate-curriculum-manifest.mjs
+src/contents/curriculumManifest.generated.ts
+shared/content/curriculumSeoManifest.generated.json
+```
+
+Questions to answer:
+
+- Can the project migrate safely from `BrowserRouter`/`Routes`/`createRoot` to React Router framework mode?
+- Can `react-router.config.ts` use `ssr: false` for static-file deployment?
+- Can `prerender()` generate static paths for `/`, `/content/`, `/content/:topicId/`, `/roadmap/`, `/about-us/`, `/privacy/`, and `/terms/`?
+- Can dynamic `/content/:topicId/` paths be generated from the Node-readable curriculum SEO manifest?
+- Can loaders receive Markdown content and curriculum metadata at build time?
+- Can generated framework-mode output deploy cleanly to GitHub Pages with the current custom domain?
+- How much route, layout, provider, and navigation code must change?
+- Does framework-mode SSG reduce the amount of custom SEO postbuild code, or does it introduce more migration risk than it removes?
+
+Decision outcomes:
+
+- If the migration cost is acceptable, create a follow-up implementation plan for React Router framework-mode SSG.
+- If the migration cost is too high, continue with the custom SEO postbuild approach in this plan.
+- Do not build the full sitemap pre-rendering implementation until this spike has a documented outcome.
+
+Validation:
+
+- Document a short spike result in this plan or a linked follow-up note.
+- Include an implementation recommendation and rejected alternative.
+- Confirm the chosen route still supports GitHub Pages static deployment.
+
+### Task 11A: SSR/SSG Readiness Refactor
+
+Refactor the current client-only Vite React entry so the app can be rendered at build time for static output while still deploying to GitHub Pages.
+
+This task prepares the app for SSG/pre-rendering. It does not introduce request-time SSR.
+
+Suggested files:
+
+```txt
+src/App.tsx
+src/AppProviders.tsx
+src/entry-client.tsx
+src/entry-server.tsx
+src/main.tsx
+src/lib/redux/createAppStore.ts
+src/lib/redux/store.ts
+src/theme/ThemeModeProvider.tsx
+src/theme/themeMode.ts
+```
+
+Implementation:
+
+- Extract shared app providers into a reusable component.
+- Extract a Redux store factory such as `createAppStore(preloadedState?)`.
+- Keep the browser singleton store as a client concern, not something imported by `entry-server`.
+- Move Redux/localStorage persistence subscriptions into the client entry or guard them behind explicit browser checks.
+- Keep browser bootstrapping in a client entry that uses `BrowserRouter` and `hydrateRoot` or `createRoot` as appropriate.
+- Add a server/static render entry that can render the same app tree with a static router and a fresh Redux store per route render.
+- Give `src/entry-server.tsx` an explicit `renderRoute({ url, routeData, preloadedState })` API for the SEO postbuild script.
+- Keep `entry-server` focused on rendering app markup; do not make it write files, generate sitemap output, or mutate `dist`.
+- Pass initial route data or preloaded state through shared providers so the first client render can match the pre-rendered HTML.
+- Keep routing behavior shared so client and pre-rendered output do not diverge.
+- Add or document the SSR/SSG build command needed to produce the server/static render bundle, such as `vite build --ssr src/entry-server.tsx`.
+- Ensure `scripts/seo-postbuild.mjs` can import the built server/static render entry after the client build and SSR/SSG build have completed.
+- Write the server/static render bundle to a non-public build output such as `dist-server`.
+- Ensure `dist-server` is not uploaded to GitHub Pages.
+- Guard browser-only APIs such as `window`, `document`, `localStorage`, `navigator`, `matchMedia`, and scroll APIs.
+- Ensure Redux/localStorage persistence gracefully falls back during static rendering.
+- Ensure theme setup does not require `document` during static rendering.
+- Ensure static rendering does not read from or write to localStorage/sessionStorage.
+- Ensure route-derived data wins over persisted Redux selected-topic state during hydration.
+- Keep the deployed output static and compatible with GitHub Pages.
+- Do not add a Node server or request-time SSR runtime.
+
+Validation:
+
+```bash
+npm run lint
+npm run build
+```
+
+Manual validation:
+
+- Confirm normal local SPA navigation still works.
+- Confirm direct client-side routes still hydrate correctly.
+- Confirm the refactor does not change visible route behavior.
+- Confirm no new hosting requirement is introduced.
+- Confirm `entry-server` does not import the browser singleton Redux store.
+- Confirm each server/static render call creates an isolated Redux store.
+- Confirm browser persistence subscriptions do not run during static rendering.
+
+### Task 11A1: Static Theme Bootstrap
+
+Add or design a small static theme bootstrap so pre-rendered pages do not flash the wrong theme before React hydrates.
+
+Suggested files:
+
+```txt
+index.html
+src/theme/themeMode.ts
+src/theme/ThemeModeProvider.tsx
+src/entry-client.tsx
+scripts/seo-postbuild.mjs
+```
+
+Implementation:
+
+- Decide whether the bootstrap belongs in `index.html` or generated route HTML.
+- Keep the bootstrap tiny, dependency-free, and safe if localStorage is unavailable.
+- Set the root `data-theme`, `dark`/`light` class, and critical CSS variables before paint if needed.
+- Keep the production default theme stable when no stored preference exists.
+- Ensure React reads or initializes the same theme state during hydration.
+- Avoid markup or state differences that create hydration mismatch.
+
+Validation:
+
+```bash
+npm run lint
+npm run build
+```
+
+Manual validation:
+
+- Load a pre-rendered page with no saved theme preference.
+- Load a pre-rendered page with a saved theme preference.
+- Confirm there is no obvious flash of the wrong theme.
+- Confirm React hydration does not emit mismatch warnings.
+
+### Task 11B: Add Content Route Data Loading and Hydration Seeding
+
+Add a shared route-data path so pre-rendered content pages receive Markdown and curriculum metadata before rendering, and the client hydrates with the same data.
+
+Suggested files:
+
+```txt
+shared/content/loadContentRouteData.mjs
+shared/content/loadContentRouteData.d.ts
+shared/content/curriculumSeoManifest.generated.json
+src/pages/Content.tsx
+src/entry-client.tsx
+src/entry-server.tsx
+scripts/seo-postbuild.mjs
+scripts/generate-curriculum-manifest.mjs
+```
+
+Implementation:
+
+- Create a shared content route-data loader that can run in Node during pre-rendering.
+- Load topic metadata from `shared/content/curriculumSeoManifest.generated.json`.
+- Resolve manifest `contentPath` values to filesystem paths under `src/contents/v1`.
+- Reject traversal attempts or content paths outside the expected content root.
+- Read Markdown with Node `fs`; do not use `import.meta.glob`.
+- Load the selected topic's curriculum metadata and Markdown before rendering `/content/:topicId/`.
+- Return route data containing the topic, Markdown, SEO metadata, and canonical path.
+- Pass route data into the server/static render entry before rendering the route.
+- Pass route data through the explicit `renderRoute` input, not through module-level mutable state.
+- Serialize the same route data into generated HTML using a safe JSON escaping strategy.
+- Inject serialized route data through the managed route-data template slot.
+- Keep serialized route data as small as practical.
+- Strip Markdown frontmatter before serializing if the client does not need it.
+- Escape `<`, `>`, `&`, `</script>`, and Unicode line separator characters.
+- Read the serialized route data before client hydration.
+- Use `hydrateRoot` when generated app markup exists and `createRoot` only for generic or empty app shells.
+- Ignore serialized route data if it does not match the current URL.
+- Refactor `Content.tsx` to use preloaded route data when it matches the URL topic ID.
+- Keep the existing client-side content loading path as a fallback for non-pre-rendered or app-only routes.
+- Ensure the first client render uses the same route data as the pre-rendered HTML.
+- Keep URL params as the source of truth for content pages.
+- Update persisted Redux selected-topic state after hydration if needed, but do not let persisted state override the URL topic.
+- Render Not Found + `noindex` for invalid content or practice topic IDs instead of redirecting to the first topic.
+- Do not include invalid topic URLs in the sitemap or pre-render output.
+
+Validation:
+
+```bash
+npm run lint
+npm run build
+```
+
+Manual validation:
+
+- Pre-render a content route and confirm source HTML contains actual article content, not `Loading content...`.
+- Confirm the client hydrates without changing the visible article content.
+- Confirm a persisted selected topic that differs from the URL does not change the rendered URL topic.
+- Confirm stale serialized route data is ignored if the browser URL does not match it.
+- Confirm hydration uses `hydrateRoot` for pre-rendered routes and does not replace valid source markup on first render.
+- Confirm invalid content/practice topic IDs render Not Found + `noindex`.
+
+### Task 12: Pre-render Compatibility Audit
+
+Before the pre-render proof of concept, audit the app for assumptions that may fail when sitemap-eligible routes render outside a normal browser session.
+
+Files to inspect:
+
+```txt
+vite.config.ts
+package.json
+scripts/
+src/App.tsx
+src/AppProviders.tsx
+src/entry-client.tsx
+src/entry-server.tsx
+src/main.tsx
+src/pages/Home.tsx
+src/pages/Content.tsx
+src/pages/Roadmap.tsx
+src/pages/AboutUs.tsx
+src/pages/Privacy.tsx
+src/pages/Terms.tsx
+src/pages/Changelog.tsx
+src/pages/Simulation.tsx
+src/components/
+src/lib/
+shared/content/loadContentRouteData.mjs
+shared/content/curriculumSeoManifest.generated.json
+shared/seo/buildSeoMetadata.mjs
+shared/seo/seoRoutes.mjs
+dist/index.html
+dist-server/
+```
+
+Audit checklist:
+
+- Check sitemap-eligible routes for render-time use of browser-only globals such as `window`, `document`, `localStorage`, `sessionStorage`, `navigator`, `IntersectionObserver`, and layout measurement APIs.
+- Confirm browser-only behavior is guarded behind effects, environment checks, or client-only boundaries.
+- Confirm Redux/localStorage persistence does not block server/pre-render execution.
+- Confirm Redux/localStorage persistence is client-only and does not run at module load in code imported by `entry-server`.
+- Confirm `entry-server` creates a fresh Redux store for every route render.
+- Confirm `entry-server` does not import the browser singleton Redux store.
+- Confirm the client entry and server/static render entry share the same app providers and route tree.
+- Confirm the server/static render entry uses a static router, not `BrowserRouter`.
+- Confirm the server/static render entry exposes a small `renderRoute` API for SEO postbuild.
+- Confirm content routes can receive Markdown and curriculum metadata as route data before render.
+- Confirm content route data comes from the Node-readable SEO manifest, not the TypeScript app manifest.
+- Confirm Node route-data loading resolves manifest `contentPath` values safely under `src/contents/v1`.
+- Confirm the client can read the same serialized route data before hydration.
+- Confirm `Content.tsx` does not render `Loading content...` in source HTML for sitemap-eligible content routes.
+- Confirm URL params are the source of truth and persisted Redux selected-topic state cannot override a pre-rendered URL topic.
+- Confirm invalid topic IDs render Not Found + `noindex`, not a redirect to the first topic.
+- Confirm Markdown loading and generated manifest imports can run in the pre-render environment.
+- Confirm Vite asset paths work for nested static pages such as `/content/[topicId]/index.html` with `base: "/"`.
+- Confirm `shared/seo/buildSeoMetadata.mjs` can be imported from both Node scripts and React code without Vite-only alias or TypeScript runtime issues.
+- Confirm `scripts/seo-postbuild.mjs` does not import Vite-only modules, TypeScript source files at runtime, `import.meta.glob`, or React app internals except the built server/static render entry.
+- Confirm `scripts/seo-postbuild.mjs` uses `dist/index.html` as the base template and preserves Vite-generated asset references.
+- Confirm `scripts/seo-postbuild.mjs` mutates only managed template slots or explicitly parsed nodes for SEO head tags, app markup, and route data.
+- Confirm the server/static render bundle is produced outside public `dist`.
+- Confirm source HTML metadata is injected from the shared metadata builder by SEO postbuild.
+- Confirm `dist/404.html`, if generated, is a dedicated Not Found + `noindex` document and not a blind copy of the app shell.
+- Confirm MUI/Emotion styling does not create blocking SSR/SSG issues for pre-rendered pages.
+- Confirm pre-rendered HTML can hydrate without markup mismatch for representative sitemap routes.
+- Confirm optional sitemap routes such as `/changelog/` and `/simulation/` are excluded unless their visible source HTML content is strong enough to rank.
+
+Outcome:
+
+- Document any route or component that needs a client-only guard before pre-rendering.
+- Confirm the shared metadata builder lives at `shared/seo/buildSeoMetadata.mjs` and can be imported safely by both Node and React.
+- Do not start the full pre-render rollout until compatibility blockers are resolved or explicitly scoped out.
+
+Validation:
+
+```bash
+npm run lint
+npm run build
+```
+
+### Task 12A: Define Pre-render Output Budgets
+
+Before expanding from the POC route to every sitemap-eligible route, define measurable output and build-time budgets.
+
+Suggested budget fields:
+
+```txt
+Maximum total dist size:
+Maximum HTML file size per route:
+Maximum serialized route-data JSON size per route:
+Maximum number of pre-rendered routes in the first sitemap release:
+Maximum production build time:
+```
+
+Implementation:
+
+- Measure the one-route POC before setting final rollout budgets.
+- Record the number of generated routes.
+- Record total `dist` size after the client build and after pre-rendering.
+- Record the generated HTML file size for the POC route.
+- Record the serialized route-data JSON size for the POC route.
+- Check whether route data duplicates full Markdown that already exists in rendered HTML.
+- Prefer minimal hydration data over serializing large duplicated Markdown payloads when possible.
+
+Validation:
+
+- The POC records size and build-time numbers.
+- The all-routes rollout does not proceed until budgets are defined or explicitly waived.
+- Any budget exception is documented with the reason and mitigation.
+
+### Task 13: Pre-Render Proof of Concept
+
+Before implementing the full sitemap route set, prove the pre-rendering approach on one representative topic page.
+
+Proof-of-concept route:
+
+```txt
+/content/classes-structs-records/
+```
+
+Files to inspect:
+
+```txt
+vite.config.ts
+package.json
+scripts/
+src/App.tsx
+src/AppProviders.tsx
+src/entry-client.tsx
+src/entry-server.tsx
+src/pages/Content.tsx
+src/contents/curriculumManifest.generated.ts
+shared/content/loadContentRouteData.mjs
+shared/content/curriculumSeoManifest.generated.json
+dist/index.html
+dist-server/
+```
+
+Implementation:
+
+- Use a proper React SSR/SSG render entry if feasible so the pre-rendered HTML matches the hydrated React app.
+- Avoid ad hoc HTML injection that creates markup React cannot hydrate cleanly.
+- Use build-time rendering only; do not add request-time SSR or a production Node server.
+- Use the shared app providers and static router from the SSR/SSG readiness refactor.
+- Import the built server/static render entry from the private build output, such as `dist-server`.
+- Call the explicit `renderRoute` API with the canonical URL and route data.
+- Confirm the render entry creates a fresh Redux store for the POC route.
+- Use `dist/index.html` as the base HTML template for the generated route.
+- Inject route head tags, app markup, and serialized route data through managed template slots or explicitly parsed nodes.
+- Preserve Vite-generated scripts, stylesheets, preload/modulepreload links, and asset references.
+- Load `/content/classes-structs-records/` Markdown and curriculum metadata as route data before rendering.
+- Pass the same route data into the server/static render entry and the generated client HTML.
+- Generate static HTML for `/content/classes-structs-records/`.
+- Write output to `dist/content/classes-structs-records/index.html`.
+- Include route-specific title, description, canonical URL, Open Graph URL, and Open Graph image metadata in the initial HTML.
+- Include visible page content in source HTML, not only a generic app shell.
+- Confirm the source HTML does not contain `Loading content...` as the primary content.
+- Measure generated HTML size, serialized route-data size, total `dist` size, and build duration.
+- Check whether full Markdown is duplicated in both rendered HTML and serialized route data.
+- Confirm MUI/Emotion styles render acceptably before hydration.
+- If the POC shows MUI/Emotion style-order, hydration, or flash-of-unstyled-content issues, add Emotion SSR extraction and a shared cache/provider setup before expanding to all sitemap routes.
+- Preserve React hydration and existing client-side routing.
+
+Validation:
+
+```bash
+npm run lint
+npm run build
+```
+
+Manual validation:
+
+- Inspect `dist/content/classes-structs-records/index.html`.
+- Confirm source HTML includes route-specific metadata and visible content before JavaScript runs.
+- Confirm source HTML includes the expected Markdown-derived heading and article text.
+- Confirm serialized route data exists and is safely escaped.
+- Confirm serialized route data is written in the managed route-data slot.
+- Confirm serialized route data is not larger than the defined POC budget unless explicitly accepted.
+- Confirm the generated HTML preserves Vite-generated JS and CSS references from `dist/index.html`.
+- Confirm only the managed SEO head block, root app markup, and route-data block changed from the base template.
+- Confirm the browser loads the generated route's JS and CSS assets successfully.
+- Confirm the server/static render bundle is not present in the public deployed `dist`.
+- Deploy and confirm `curl -I https://www.dev-net-core.com/content/classes-structs-records/` returns `200 OK`.
+- Confirm the production URL does not redirect.
+- Confirm `curl -L https://www.dev-net-core.com/content/classes-structs-records/` shows route-specific source HTML metadata.
+- Confirm `curl -L https://www.dev-net-core.com/content/classes-structs-records/` shows visible route content and not only `Loading content...`.
+- Confirm the page still hydrates correctly in the browser.
+- Confirm browser console does not show hydration mismatch errors.
+- Confirm browser console does not show MUI/Emotion hydration or style insertion warnings.
+- Confirm the page does not show an obvious flash of unstyled content.
+- Record POC output size and build-time measurements before expanding to all sitemap routes.
+
+### Task 14: Pre-render All Sitemap-Eligible Routes
+
+Files to inspect:
+
+```txt
+vite.config.ts
+package.json
+scripts/
+src/App.tsx
+src/AppProviders.tsx
+src/entry-client.tsx
+src/entry-server.tsx
+src/pages/Home.tsx
+src/pages/Content.tsx
+src/pages/Roadmap.tsx
+src/pages/AboutUs.tsx
+src/pages/Privacy.tsx
+src/pages/Terms.tsx
+src/pages/Changelog.tsx
+src/pages/Simulation.tsx
+src/contents/curriculumManifest.generated.ts
+shared/content/loadContentRouteData.mjs
+shared/content/curriculumSeoManifest.generated.json
+dist/index.html
+dist-server/
+```
+
+Implementation:
+
+- Use the rendering method proven in the POC, preferring a proper React SSR/SSG render entry if feasible.
+- Use build-time SSG/pre-rendering only while deploying to GitHub Pages.
+- Generate static HTML/pre-rendered output for every route included in `sitemap.xml`.
+- Use the generated curriculum manifest as the content topic route list.
+- Use the Node-readable SEO manifest for SEO postbuild content route generation.
+- Use the machine-readable SEO route config for static sitemap-eligible routes.
+- Render each route through the explicit `renderRoute` API.
+- Create an isolated Redux store for each generated route.
+- Use `dist/index.html` as the base HTML template for every generated route.
+- Inject only managed SEO head, root app markup, and route-data slots for every generated route.
+- Preserve Vite-generated scripts, stylesheets, preload/modulepreload links, and asset references for every generated route.
+- Load Markdown and curriculum metadata as route data before rendering each `/content/:topicId/` route.
+- Seed each generated content page with the same route data that was used during pre-rendering.
+- Use each topic's `canonicalPath` for output paths.
+- Generate files that map cleanly to trailing-slash URLs, such as `dist/content/[topicId]/index.html`.
+- Generate required sitemap-eligible routes:
+  - `/`
+  - `/content/`
+  - `/content/:topicId/`
+  - `/roadmap/`
+  - `/about-us/`
+  - `/privacy/`
+  - `/terms/`
+- Generate optional sitemap-eligible routes only if they have enough unique visible content and are intended to rank:
+  - `/changelog/`
+  - `/simulation/`
+- Include route-specific title, description, canonical URL, Open Graph URL, and Open Graph image metadata in the initial HTML.
+- Include visible page content in source HTML for every sitemap URL.
+- Ensure content page source HTML contains real Markdown-derived content, not `Loading content...`.
+- Confirm MUI/Emotion styles render acceptably before hydration for representative route types.
+- If MUI/Emotion issues were found in the POC, apply the chosen Emotion SSR extraction/cache solution before adding affected routes to the sitemap.
+- Preserve React hydration and existing client-side routing.
+- Keep `/practice/:topicId/` routes excluded from the sitemap and `noindex` unless they are later redesigned as standalone searchable pages.
+- Keep app-only, user-flow-only, and session-specific routes out of the sitemap.
+
+Validation:
+
+```bash
+npm run lint
+npm run build
+```
+
+Manual validation:
+
+- Inspect generated `dist/content/[topicId]/index.html` files.
+- Confirm every sitemap URL has matching static/pre-rendered output.
+- Confirm representative pages include source HTML metadata and visible content before JavaScript runs.
+- Confirm representative content pages include route-data seeding and hydrate using that same data.
+- Confirm representative pages preserve Vite-generated JS and CSS references from `dist/index.html`.
+- Confirm representative generated HTML only changes managed SEO head, root app markup, and route-data regions from the base template.
+- Confirm public `dist` does not include the private server/static render bundle.
+- Confirm per-route rendering does not reuse Redux state across routes.
+- Confirm total `dist` size, route HTML size, serialized route-data size, route count, and build time stay within the defined budgets or have documented exceptions.
+- Confirm persisted selected-topic state does not override the URL topic during hydration.
+- Confirm pre-rendered pages still hydrate correctly in the browser.
+- Confirm browser console does not show hydration mismatch errors on representative pre-rendered routes.
+- Confirm browser console does not show MUI/Emotion hydration or style insertion warnings on representative pre-rendered routes.
+- Confirm canonical trailing-slash URLs still match the route indexability matrix.
+- Run a production-like local preview against `dist` after each major SEO build step.
+- In the local preview, verify nested static routes such as `/content/classes-structs-records/` load JS, CSS, images, and hydrated UI correctly.
+
+### Optional Task 14A: Local SEO Build Validation Script
+
+Add a local validation script after pre-rendering is implemented if repeated manual checks become noisy.
+
+Suggested file:
+
+```txt
+scripts/validate-seo-build.mjs
+```
+
+Suggested package script:
+
+```json
+{
+  "scripts": {
+    "validate:seo-build": "node scripts/validate-seo-build.mjs"
+  }
+}
+```
+
+Suggested checks:
+
+- Parse `dist/sitemap.xml`.
+- Verify every sitemap `<loc>` is absolute.
+- Verify every sitemap URL uses the canonical trailing-slash format.
+- Map every sitemap URL to a local static/pre-rendered output file.
+- Verify the matching output file exists.
+- Verify source HTML includes a route-specific `<title>`.
+- Verify source HTML includes a meta description.
+- Verify source HTML includes a self-matching canonical URL.
+- Verify source HTML includes `og:url` and `og:image`.
+- Verify source HTML includes visible page content, not only a generic app shell.
+- Verify source HTML does not include `noindex`.
+- Verify there are no duplicate sitemap URLs.
+- Verify `<lastmod>` is omitted unless an automated source generates accurate values.
+- Verify generated route HTML preserves Vite-generated JS and CSS references.
+- Verify generated route HTML mutates only managed SEO head, root app markup, and route-data regions.
+- Verify generated route HTML includes safe serialized route data where needed.
+- Verify generated content route source HTML does not render `Loading content...`.
+- Verify public `dist` does not include the private server/static render bundle.
+- Verify `dist/404.html`, if present, contains Not Found source content and `noindex`.
+- Optionally start a static preview server against `dist` and verify representative nested routes load assets and hydrate correctly.
+
+Important caveat: this script validates local build output only. It does not replace production validation with `curl -I` and `curl -L`.
+
+Validation:
+
+```bash
+npm run build
+npm run preview
+npm run validate:seo-build
+```
+
+### Task 15: Verify Hosting and Redirect Behavior
+
+Files to inspect:
+
+```txt
+.github/workflows/main.yml
+public/CNAME
+```
+
+Validation:
+
+- Confirm production is deployed by GitHub Pages.
+- Confirm the custom domain is managed through Cloudflare DNS.
+- Confirm whether Cloudflare proxy/rules are enabled.
+- Confirm any Cloudflare redirect rules are documented if they exist.
+- Confirm GitHub Actions order is:
+  1. Generate curriculum manifest.
+  2. Generate the Node-readable SEO manifest, either as part of curriculum generation or as an explicit step.
+  3. Build client assets.
+  4. Build server/static render entry to private build output such as `dist-server`, or run the chosen framework-mode pre-render build.
+  5. SEO postbuild reads `dist/index.html`, imports the built server/static render entry if using the custom path, creates route HTML artifacts, and writes `dist/sitemap.xml`.
+  6. Generate or validate `dist/404.html` as a dedicated Not Found + `noindex` document.
+  7. Run SEO build validation when available.
+  8. Deployment publishes only the final `dist`.
+- Confirm the `404.html` step does not overwrite a dedicated Not Found + `noindex` file or replace generated route artifacts.
+- Confirm `dist-server` is not uploaded to GitHub Pages.
+- Confirm sitemap URLs return `200 OK` without depending on `dist/404.html`.
+- Confirm non-canonical route variants redirect to or canonicalize to trailing-slash URLs.
+- Confirm valid trailing-slash routes direct-load in production.
+
+### Task 16: Search Console Setup
+
+No code changes required.
+
+Validation:
+
+- Domain verified.
+- Pre-rendered/static output for every sitemap-included route is deployed.
+- Production Validation Gate Before Search Console Submission passes.
+- Sitemap submitted.
+- Production sitemap URLs pass `curl -I` and `curl -L` checks.
+- Key pages inspected.
+- Indexing requested.
+
+### Task 17: Optional Scheduled Production SEO Validation
+
+Manual production validation is enough for the first SEO pass. Add automated validation later if repeated checks become useful.
+
+Use a scheduled Codex task to periodically check production SEO health.
+
+Suggested schedule:
+
+```txt
+Weekly after deployment
+```
+
+Suggested checks:
+
+- Fetch `https://www.dev-net-core.com/sitemap.xml`.
+- Parse every `<loc>` URL.
+- Verify each sitemap URL returns `200 OK`.
+- Verify sitemap URLs do not redirect.
+- Verify sitemap URLs use the canonical trailing-slash format.
+- Verify each page has a self-matching canonical tag.
+- Verify pages are not blocked by `robots.txt`.
+- Verify pages do not include `noindex`.
+- Verify each page has a unique title and meta description.
+- Verify each page has correct Open Graph URL and `og:image`.
+- Report any soft-404, redirect, duplicate canonical, or missing metadata issues.
+
+Important caveat: if any route-specific metadata is still added only by React at runtime, source HTML checks will not see that metadata. Record that as an expected limitation and keep those routes out of the sitemap until pre-rendering/static HTML generation covers them.
+
+This task is optional and should not block the initial manual Production Validation Gate Before Search Console Submission.
+
+### Task 18: Optional Framework or Pre-Rendering Follow-Up Research
+
+Create a follow-up plan only if the Vite-compatible pre-rendering path has meaningful limitations.
+
+Research:
+
+- Vite-compatible pre-rendering options.
+- GitHub Pages custom-domain deployment compatibility.
+- Cloudflare proxy/rules compatibility only if Cloudflare proxy/rules are explicitly enabled.
+- React Router compatibility.
+- Generated content route list from curriculum manifest.
+- Whether Astro, Next.js, or another framework would materially improve SEO, performance, or maintainability.
+
+Do not start a framework migration without a separate plan.
+
+## Risks
+
+### React SPA Rendering Risk
+
+Search engines may need to render JavaScript before seeing meaningful content. This can delay indexing.
+
+Mitigation:
+
+- Add sitemap.
+- Add metadata.
+- Add pre-rendering before submitting sitemap URLs to Search Console.
+
+### Premature Sitemap Submission Risk
+
+Submitting sitemap URLs before pre-rendered source HTML and production validation are ready may create weak crawl signals, inconsistent metadata, or soft-404-like behavior.
+
+Mitigation:
+
+- Generate the sitemap locally as part of the technical foundation, but do not submit it yet.
+- Pre-render every sitemap-eligible route first.
+- Validate production `200 OK` direct loads and source HTML metadata.
+- Submit the sitemap only after the Production Validation Gate passes.
+
+### Duplicate URL Risk
+
+Routes with and without trailing slash may create duplicate URLs.
+
+Mitigation:
+
+- Use canonical URLs.
+- Use one consistent URL format.
+- Avoid linking to both versions.
+- Treat trailing-slash URLs as the only sitemap/canonical format for GitHub Pages static output.
+- Do not rely on non-trailing production redirects unless Cloudflare or another layer explicitly implements and validates them.
+
+### Soft 404 Risk
+
+Invalid SPA routes may return the app shell instead of a real 404.
+
+Mitigation:
+
+- Add `noindex` to invalid routes.
+- Use a clear Not Found page.
+- Do not include invalid routes in `sitemap.xml`.
+- Do not block invalid SPA routes in `robots.txt` if relying on `noindex`.
+- Ensure sitemap URLs return `200 OK` on direct load and do not rely only on the generic `404.html` SPA fallback.
+
+### Hosting and Redirect Authority Risk
+
+The custom domain is managed in Cloudflare, but the application is hosted on GitHub Pages. This can cause confusion about where redirects, rewrites, and status codes are actually controlled.
+
+Mitigation:
+
+- Treat GitHub Pages as the production static host unless the site is explicitly migrated.
+- Treat Cloudflare as DNS/domain management unless Cloudflare proxy/rules are explicitly enabled.
+- Do not rely on Cloudflare redirects unless the exact rules are configured, documented, and validated.
+- Generate real static output for sitemap URLs where possible.
+- Validate production behavior with `curl -I` and `curl -L` before submitting the sitemap.
+
+### Sitemap Drift Risk
+
+Manual sitemap entries may become outdated as curriculum content changes.
+
+Mitigation:
+
+- Generate sitemap from the curriculum manifest.
+
+### Metadata Drift Risk
+
+Manual metadata can become outdated or duplicated.
+
+Mitigation:
+
+- Generate content metadata from frontmatter/curriculum data.
+- Validate duplicate canonical paths.
+- Keep fallback metadata only as a transition aid.
+
+### Manifest SEO Field Risk
+
+The current generated curriculum manifest may not expose enough SEO fields for sitemap, metadata, and pre-rendering output.
+
+Mitigation:
+
+- Extend the frontmatter parser before relying on generated metadata.
+- Add validation for required SEO fields and canonical path format.
+- Omit `lastmod` unless a future automated source can generate it accurately.
+- Do not output `<priority>` or `<changefreq>` in the sitemap.
+
+### Content Route Data Hydration Risk
+
+Content pages currently load selected-topic Markdown on the client after render. If pre-rendering uses the same effect-only loading path, source HTML may contain `Loading content...` instead of the actual article, and the client may hydrate with data that does not match the pre-rendered HTML.
+
+Mitigation:
+
+- Load Markdown and curriculum metadata as route data before pre-rendering content pages.
+- Serialize the same route data into generated HTML for the client to read before hydration.
+- Refactor `Content.tsx` to use matching preloaded route data before falling back to client-side loading.
+- Keep URL params as the content route source of truth.
+- Prevent persisted Redux selected-topic state from overriding the URL topic during hydration.
+- Validate that sitemap-included content pages contain real article content in source HTML.
+
+### React Router Framework-Mode Migration Risk
+
+React Router framework-mode SSG may reduce custom pre-rendering code, but migrating from the current Vite SPA structure may require routing, loader, provider, and build pipeline changes.
+
+Mitigation:
+
+- Run the React Router 7 SSG spike before committing to the implementation path.
+- Compare framework-mode SSG with the custom SEO postbuild approach.
+- Confirm GitHub Pages static deployment works before migration.
+- Do not start the full sitemap pre-render rollout until the spike outcome is documented.
+
+### Singleton Store and Hydration Bootstrap Risk
+
+The current app is client-first and may rely on a singleton Redux store plus localStorage persistence. If that store is reused during build-time rendering, route state can leak across generated pages. If the client does not hydrate from the same route data used during pre-rendering, React may replace or mismatch the source HTML.
+
+Mitigation:
+
+- Extract a `createAppStore(preloadedState?)` factory.
+- Create a fresh store for every server/static render call.
+- Keep browser persistence subscriptions client-only.
+- Read serialized route data before the first client render.
+- Use `hydrateRoot` for pre-rendered routes and `createRoot` only for non-pre-rendered shells.
+- Treat route-data mismatches and hydration warnings as bugs before expanding the sitemap.
+
+### Static Theme Bootstrap Risk
+
+Pre-rendered HTML may show the wrong theme before React hydrates if theme classes, attributes, or CSS variables are applied only in client effects.
+
+Mitigation:
+
+- Add a tiny before-paint theme bootstrap if needed.
+- Keep the bootstrap dependency-free and safe when localStorage is unavailable.
+- Align the bootstrap result with React's initial theme state.
+- Validate that pre-rendered pages do not flash the wrong theme or produce hydration warnings.
+
+### Node/Vite Build Boundary Risk
+
+SEO postbuild may accidentally depend on Vite-only imports, TypeScript runtime execution, `import.meta.glob`, or React app internals. It may also generate route HTML that loses Vite's hashed JS/CSS asset references.
+
+Mitigation:
+
+- Generate a Node-readable SEO manifest during curriculum generation.
+- Keep SEO postbuild dependent on JSON manifests, pure shared `.mjs` helpers, Node `fs`, `dist/index.html`, and the built server/static render entry only.
+- Use `dist/index.html` as the base template for generated route HTML.
+- Preserve Vite-generated script, stylesheet, preload, modulepreload, and asset references.
+- Build the server/static render entry to a private output such as `dist-server`.
+- Deploy only `dist` to GitHub Pages.
+- Validate generated nested routes load JS/CSS and hydrate correctly.
+
+### Structured Data Drift Risk
+
+JSON-LD can drift from canonical metadata or visible content if it is generated separately from title, description, canonical URL, and Open Graph tags.
+
+Mitigation:
+
+- Generate JSON-LD from the shared metadata builder.
+- Inject JSON-LD through SEO postbuild for sitemap URLs.
+- Let React mirror the same structured data after hydration, not own it separately.
+- Validate structured data against Google rules before deployment.
+
+### Template Injection and 404 Output Risk
+
+Ad hoc HTML string replacement can remove Vite-generated asset tags or inject metadata in the wrong place. A blind `dist/index.html` to `dist/404.html` copy can also make invalid URLs look like normal app-shell pages.
+
+Mitigation:
+
+- Use explicit managed template slots or a constrained HTML parser.
+- Mutate only SEO head tags, root app markup, and serialized route data.
+- Preserve Vite-generated script, style, preload, modulepreload, and public asset references.
+- Generate or validate a dedicated `dist/404.html` with Not Found source content and `noindex`.
+- Prevent GitHub Actions from overwriting the dedicated `404.html` after SEO postbuild.
+
+### MUI/Emotion Static Rendering Risk
+
+Material UI and Emotion may need SSR-specific style extraction or cache setup to avoid style-order warnings, hydration mismatch, or a flash of unstyled content on pre-rendered pages.
+
+Mitigation:
+
+- Check this during the one-route pre-render proof of concept.
+- If issues appear, add Emotion SSR extraction and a shared cache/provider setup before expanding to all sitemap routes.
+- Keep affected routes out of the sitemap until their pre-rendered source HTML hydrates without React, MUI, or Emotion warnings.
+
+### Pre-render Output Bloat Risk
+
+Pre-rendering every Markdown topic can significantly increase `dist` size, especially if each page contains rendered HTML plus duplicated full Markdown or large route-data JSON.
+
+Mitigation:
+
+- Define output-size and build-time budgets during the POC.
+- Measure generated HTML size, serialized route-data size, route count, total `dist` size, and build duration.
+- Serialize only the route data needed for hydration.
+- Document any budget exception before expanding to all sitemap routes.
+
+### Build Risk
+
+New sitemap or SEO scripts may break the Vite build if they depend on generated files in the wrong order.
+
+Mitigation:
+
+- Keep script order clear.
+- Use staged SEO postbuild modes: `off`, `warn`, then `strict`.
+- Keep strict postbuild validation disabled until the pre-render proof of concept passes.
+- Require strict postbuild validation before exposing a full production sitemap.
+- Validate with `npm run build`.
+
+## Assumptions
+
+- The production domain is `https://www.dev-net-core.com/`.
+- Apex/root domain behavior has already been deployed and validated; re-check only if DNS, GitHub Pages, Cloudflare, or canonical-domain settings change.
+- The production site is hosted on GitHub Pages.
+- The custom domain is managed through Cloudflare DNS.
+- Cloudflare should not be treated as the application host unless the site is explicitly migrated to Cloudflare Pages.
+- Cloudflare proxy/rules should not be assumed unless explicitly configured and documented.
+- The project remains a Vite + React app deployed as static output.
+- SSR-style rendering should be used only at build time for SSG/pre-rendering while GitHub Pages remains the host.
+- Runtime SSR is out of scope unless a separate hosting migration plan is created.
+- Markdown content remains the source of truth for curriculum pages.
+- The generated React curriculum manifest will continue to support app navigation and question extraction.
+- A generated Node-readable SEO manifest will contain enough data to build sitemap URLs, page metadata, route data, and the pre-rendered content route list.
+- Static non-content routes will be managed through the sitemap-eligible route list.
+- The goal is organic discoverability, not paid advertising.
+- The implementation should remain incremental, but the full sitemap should not be submitted until pre-rendered sitemap-eligible routes and production validation are complete.
+
+## Validation Checklist
+
+After implementation, validate:
+
+```bash
+npm run generate:curriculum
+npm run lint
+npm run build
+npm run preview
+```
+
+If Optional Task 14A is implemented, also validate:
+
+```bash
+npm run validate:seo-build
+```
+
+Manual checks:
+
+- Open `https://www.dev-net-core.com/robots.txt`.
+- Open `https://www.dev-net-core.com/sitemap.xml`.
+- Open `https://www.dev-net-core.com/og/default-og-image.png`.
+- Confirm final production sitemap output is written by `scripts/seo-postbuild.mjs`.
+- Confirm GitHub Pages is the production static host.
+- Confirm SSR/SSG rendering is build-time only and does not require a production Node server.
+- Confirm the server/static render entry is built before the SEO postbuild script imports or uses it.
+- Confirm the server/static render entry is built outside public `dist`.
+- Confirm the server/static render entry exposes the agreed `renderRoute` API.
+- Confirm the server/static render entry creates a fresh Redux store for each route render.
+- Confirm Redux/localStorage persistence subscriptions are client-only.
+- Confirm client hydration reads serialized route data before the first render.
+- Confirm pre-rendered routes use `hydrateRoot` and generic app shells use `createRoot`.
+- Confirm only `dist` is uploaded to GitHub Pages.
+- Confirm Cloudflare is being used for domain/DNS management.
+- Confirm whether Cloudflare proxy/rules are enabled and documented.
+- Confirm non-trailing URLs are not used in sitemap, canonical, Open Graph, Twitter/X, structured data, or internal generated SEO links.
+- Confirm non-trailing production redirects are not assumed unless Cloudflare or another layer explicitly implements and validates them.
+- Confirm the shared SEO route config matches the route indexability matrix.
+- Confirm the React Router 7 SSG spike has a documented outcome before full pre-render implementation starts.
+- Confirm the curriculum generation step outputs a Node-readable SEO manifest.
+- Confirm SEO postbuild consumes the Node-readable SEO manifest, not the TypeScript app manifest.
+- Confirm SEO postbuild does not rely on Vite-only imports, TypeScript runtime execution, `import.meta.glob`, or React app internals.
+- Confirm SEO postbuild uses `dist/index.html` as the base template and preserves Vite-generated asset references.
+- Confirm SEO postbuild mutates only managed SEO head, root app markup, and route-data regions.
+- Confirm `dist/404.html`, if present, is a dedicated Not Found + `noindex` document and is not a blind copy of `dist/index.html`.
+- Confirm sitemap URLs do not rely on the GitHub Pages `404.html` SPA fallback.
+- Confirm sitemap content URLs come from `canonicalPath`.
+- Confirm sitemap omits `<priority>` and `<changefreq>`.
+- Confirm sitemap omits `<lastmod>` unless an automated source generates accurate values.
+- Confirm pre-rendered output exists for every route included in `sitemap.xml`.
+- Confirm every sitemap URL source HTML includes route-specific title, description, canonical URL, Open Graph URL, default or custom `og:image`, and visible page content.
+- Confirm every sitemap URL with structured data has JSON-LD in source HTML generated from the shared metadata builder.
+- Confirm every sitemap-included content page receives Markdown and curriculum metadata as pre-render route data.
+- Confirm every sitemap-included content page serializes safe initial route data for hydration.
+- Confirm every sitemap-included content page source HTML contains real article content and not only `Loading content...`.
+- Confirm persisted selected-topic state does not override the URL topic during hydration.
+- Confirm serialized route data is minimized and safely escaped.
+- Confirm metadata-only static HTML shell output is not used as the basis for sitemap inclusion.
+- Confirm pre-rendered pages do not flash the wrong theme before hydration.
+- Confirm representative pre-rendered pages hydrate without React, MUI, or Emotion warnings.
+- Confirm output-size and build-time budgets are defined before all-routes pre-render rollout.
+- Confirm generated route count, total `dist` size, HTML file size, route-data JSON size, and build duration stay within budget or have documented exceptions.
+- Run production `curl -I` checks for representative sitemap URLs.
+- Run production `curl -L` HTML inspections for representative sitemap URLs.
+- Open several `/content/:topicId/` pages.
+- Open canonical trailing-slash static routes such as `/roadmap/`, `/about-us/`, `/privacy/`, `/terms/`, and optional sitemap routes if included.
+- Confirm explicit React Router support for canonical trailing-slash routes.
+- Check browser title changes per page.
+- Check meta description using browser dev tools.
+- Check canonical URL.
+- Check Open Graph tags.
+- Check `og:image` is absolute, public, and points to the default image when no custom image exists.
+- Check invalid routes have `noindex`.
+- Complete the Production Validation Gate Before Search Console Submission.
+- Submit sitemap to Google Search Console only after pre-rendering and production validation pass.
+- Inspect a few URLs with Google URL Inspection.
+- Confirm Google can render page content.
+- Submit sitemap to Bing Webmaster Tools.
+
+## Success Criteria
+
+This SEO plan is successful when:
+
+- Google Search Console shows the sitemap as successfully processed.
+- Important routes are indexed.
+- Curriculum topic pages appear in Search Console performance data.
+- Search result titles are relevant and unique.
+- Search result descriptions are relevant.
+- No important pages are blocked by `robots.txt`.
+- No important pages are marked `noindex`.
+- Invalid routes do not get indexed.
+- Content pages are discoverable through sitemap and internal links.
+
+## Recommended Next Step
+
+Start with a small first PR:
+
+```txt
+Add robots.txt, SEO frontmatter support, shared SEO route config, and generated sitemap infrastructure in warning mode
+```
+
+Then make a second PR:
+
+```txt
+Add metadata, canonical URLs, crawlable links, and trailing-slash route support
+```
+
+Then make a third PR:
+
+```txt
+Run React Router 7 SSG spike and document the chosen pre-rendering architecture
+```
+
+Then make a fourth PR:
+
+```txt
+Add SSR/SSG readiness refactor, renderRoute API, store factory, hydration bootstrap, and static theme bootstrap
+```
+
+Then make a fifth PR:
+
+```txt
+Add content route data loading and hydration seeding
+```
+
+Then make a sixth PR:
+
+```txt
+Add pre-render proof of concept for one content route and record output-size/build-time budgets
+```
+
+Then make a seventh PR:
+
+```txt
+Add pre-render/static HTML output for all sitemap-eligible routes
+```
+
+After deployment, complete production validation and then submit the sitemap to Google Search Console and Bing Webmaster Tools.
diff --git a/docs/plans/structured-data-rules.md b/docs/plans/structured-data-rules.md
new file mode 100644
index 0000000..075b063
--- /dev/null
+++ b/docs/plans/structured-data-rules.md
@@ -0,0 +1,153 @@
+# DEV_NET_CORE Structured Data Rules
+
+This note defines the rules DEV_NET_CORE must follow when implementing and
+validating structured data. It is the implementation guardrail for Task 8 of
+the SEO improvement plan.
+
+## Purpose
+
+Structured data should help search engines understand content that is already
+visible on the page. It must not introduce claims, entities, dates, authorship,
+ratings, or other facts that the page does not support.
+
+Valid structured data can make a page eligible for enhanced search features,
+but it does not guarantee that Google will display a rich result.
+
+## General Rules
+
+- Use JSON-LD.
+- Structured data must accurately represent the main visible page content.
+- Put structured data only on the page that it describes.
+- Use the most specific Google-supported schema type that accurately describes
+  the page.
+- Do not mark up hidden, irrelevant, misleading, or incomplete information.
+- Do not invent author, publisher, publication date, modification date, rating,
+  review, FAQ, organization, or ownership information.
+- Do not emit properties with empty, `null`, or `undefined` values.
+- Do not emit structured data on invalid, Not Found, or `noindex` routes.
+- Do not block an indexable structured-data page through `robots.txt`.
+- Treat successful validation as a correctness check, not a promise of a rich
+  result.
+
+## Approved Initial Types
+
+### Homepage
+
+Use one `WebSite` object on `/`.
+
+Initial properties:
+
+- `@context`
+- `@type`
+- `name`
+- `url`
+- `description`
+
+The URL must be the canonical production URL:
+
+```txt
+https://www.dev-net-core.com/
+```
+
+Do not add an `Organization`, publisher, owner, or alternate site name until
+the corresponding identity is explicitly defined and supported by visible
+site content.
+
+### Content Topics
+
+Use one `Article` object on each valid `/content/:topicId/` page because these
+routes contain the long-form educational content for a curriculum topic.
+
+Initial properties:
+
+- `@context`
+- `@type`
+- `headline`
+- `description`
+- `url`
+
+Build these values from the same Markdown frontmatter, generated manifest, and
+shared metadata builder used for title, description, and canonical metadata.
+The Article URL must exactly match the page's canonical trailing-slash URL.
+
+Omit these properties until their values are verified and visible:
+
+- `author`
+- `publisher`
+- `datePublished`
+- `dateModified`
+- `image`
+
+The default Open Graph image is a site-wide branding fallback. Do not use it as
+an Article image unless it is determined to be genuinely representative of the
+specific article. A future topic-specific image must be crawlable, indexable,
+and relevant to the marked-up content.
+
+## Deferred Types
+
+Do not add the following types during the initial implementation:
+
+- `FAQPage`
+- `QAPage`
+- `Course`
+- `HowTo`
+- `Review`
+- `AggregateRating`
+- `Person`
+- `Organization`
+- `BreadcrumbList`
+
+These types require a separate content and eligibility review. The presence of
+interview questions in Markdown does not by itself justify FAQ, Q&A, rating, or
+review markup.
+
+## Ownership and Consistency
+
+Structured data must follow the existing metadata source-of-truth chain:
+
+```txt
+Markdown frontmatter
+  -> generated curriculum/SEO manifest
+  -> shared SEO metadata builder
+  -> pre-rendered source HTML
+  -> React route metadata
+```
+
+The shared metadata builder should produce the JSON-LD data. The SEO postbuild
+pipeline must inject it into pre-rendered source HTML. The React SEO component
+may mirror the same object after hydration, but it must not maintain a separate
+hardcoded version.
+
+Differences between pre-rendered JSON-LD and hydrated JSON-LD are bugs.
+
+## Validation Checklist
+
+Before deployment:
+
+- Parse every generated JSON-LD block as JSON.
+- Confirm each page contains only the intended structured-data objects.
+- Confirm every structured-data value matches visible page content.
+- Confirm each URL is absolute, canonical, and uses the trailing-slash format.
+- Confirm invalid and `noindex` pages have no structured data.
+- Confirm pre-rendered sitemap routes contain JSON-LD in source HTML.
+- Run representative pages through Google's Rich Results Test.
+- Run representative JSON-LD through Schema.org's Schema Markup Validator.
+- Remove or defer any property that cannot be verified.
+
+Representative validation routes:
+
+```txt
+/
+/content/async-and-await-semantics-in-csharp/
+/content/not-a-real-topic/
+/practice/async-and-await-semantics-in-csharp/
+```
+
+## References
+
+- [Google: General structured data guidelines](https://developers.google.com/search/docs/appearance/structured-data/sd-policies)
+- [Google: Article structured data](https://developers.google.com/search/docs/appearance/structured-data/article)
+- [Google: Rich Results Test](https://search.google.com/test/rich-results)
+- [Schema.org: Article](https://schema.org/Article)
+- [Schema.org: WebSite](https://schema.org/WebSite)
+- [Schema.org: Schema Markup Validator](https://validator.schema.org/)
diff --git a/docs/spikes/react-router-7-ssg-spike.md b/docs/spikes/react-router-7-ssg-spike.md
new file mode 100644
index 0000000..ccbd302
--- /dev/null
+++ b/docs/spikes/react-router-7-ssg-spike.md
@@ -0,0 +1,142 @@
+# React Router 7 SSG Spike Result
+
+Date: 2026-06-27
+
+## Decision
+
+Proceed toward React Router framework-mode SSG with `ssr: false`.
+
+The spike proved that the project can generate GitHub Pages-compatible static
+HTML for canonical trailing-slash routes while retaining client hydration and
+route-loader navigation. The migration cost is moderate to high, but the
+framework removes more custom rendering and hydration risk than it introduces.
+
+Keep a small SEO finalization script for sitemap generation, output validation,
+and GitHub Pages `404.html` handling. Do not build a separate custom Vite SSR
+renderer unless the framework migration later fails on the real app tree.
+
+## Proof
+
+The isolated proof uses React Router 7.18.0 and:
+
+- `ssr: false`
+- `routeDiscovery: { mode: "initial" }`
+- `future.v8_trailingSlashAwareDataRequests: true`
+- dynamic `prerender` paths from
+  `shared/content/curriculumSeoManifest.generated.json`
+- Node build-time Markdown loading by manifest `contentPath`
+- the existing shared SEO metadata builder
+- route loader data shared by pre-rendering and hydration
+
+The build generated:
+
+```txt
+build/client/index.html
+build/client/content/index.html
+build/client/content/_.data
+build/client/content/<topic>/index.html
+build/client/content/<topic>/_.data
+build/client/__spa-fallback.html
+```
+
+The temporary server bundle was removed automatically because runtime SSR is
+disabled.
+
+## Questions Answered
+
+| Question | Result |
+|---|---|
+| Can the app use framework mode? | Yes, but routes and the app entry must migrate to route modules. |
+| Can static hosting use `ssr: false`? | Yes. No deployed Node server is required. |
+| Can all sitemap paths be pre-rendered? | Yes. Static paths and manifest-generated topic paths are supported. |
+| Can dynamic topic paths come from the SEO manifest? | Yes. The config reads the JSON manifest directly in Node. |
+| Can loaders receive Markdown and metadata at build time? | Yes. The topic loader read the Markdown file and shared metadata before rendering. |
+| Does hydration receive the same route data? | Yes. React Router generated `.data` output and hydrated without mismatch warnings. |
+| Is GitHub Pages output compatible? | Yes for pre-rendered trailing-slash routes. A small fallback adapter is still required. |
+| Does this eliminate the SEO postbuild step? | No. It reduces it to sitemap, validation, fallback, and output finalization work. |
+
+## Browser Validation
+
+Playwright verified:
+
+- direct topic load returned the pre-rendered document
+- the source document contained topic title, description, canonical, Open Graph,
+  JSON-LD, and visible Markdown
+- hydration completed with zero console errors
+- client navigation from `/content/` to the dynamic topic loaded the generated
+  topic `.data` file
+- no request was made to `/__manifest`
+
+For the sample topic, output included approximately 52 KB of HTML and 25 KB of
+route data. Full Markdown is therefore duplicated between HTML and `.data`;
+output-size budgets remain necessary before pre-rendering every topic.
+
+## Required Migration Work
+
+1. Replace `BrowserRouter`, component `<Routes>`, and `createRoot` ownership with
+   framework route modules and framework entries.
+2. Move shared providers into the framework root while preserving the current
+   layout and navigation.
+3. Create a Redux store factory and keep persistence subscriptions client-only.
+4. Make theme and SEO behavior safe during build-time rendering.
+5. Replace the content page's post-mount Markdown fetch with loader-provided
+   initial route data.
+6. Ensure the client hydrates from the same Markdown and curriculum metadata
+   used during pre-rendering.
+7. Convert route metadata to framework `meta` output backed by the shared
+   metadata builder.
+8. Generate every sitemap-eligible path through `prerender`.
+
+## GitHub Pages Caveats
+
+- Deploy `build/client` rather than a runtime server build.
+- Keep canonical sitemap routes as `route/index.html` static artifacts.
+- React Router emits `__spa-fallback.html`, while GitHub Pages uses `404.html`.
+  The finalizer must create a dedicated `404.html` with `noindex`; it must not
+  count as valid output for sitemap routes.
+- Keep `routeDiscovery` in `initial` mode because GitHub Pages cannot serve a
+  runtime `/__manifest` endpoint.
+- Enable `future.v8_trailingSlashAwareDataRequests`. React Router 7.18 otherwise
+  removes the trailing slash from generated data requests and rejects canonical
+  paths such as `/content/` during pre-rendering.
+- Pin React Router framework packages to the same version. Mixed framework
+  package versions caused peer-resolution conflicts during the spike.
+- Install `react-router` as a direct framework CLI peer alongside
+  `react-router-dom`; relying only on the nested DOM package copy did not satisfy
+  the 7.18 CLI.
+
+## Rejected Alternative
+
+Do not proceed with a fully custom Vite SSR/SSG renderer as the primary plan.
+It would need to duplicate route matching, loader execution, hydration data,
+metadata coordination, and asset handling already provided by React Router.
+
+Retain custom Node scripts only for responsibilities React Router does not own:
+sitemap generation, static-output validation, GitHub Pages fallback generation,
+and deployment checks.
+
+## Task 11A Staged Readiness Follow-Up
+
+The first readiness stage was completed without changing production route
+ownership:
+
+- `createAppStore(preloadedState?)` now creates isolated Redux stores.
+- Reducer defaults are deterministic and no longer read localStorage during
+  module evaluation.
+- Browser persistence loading and subscriptions are isolated from static
+  rendering.
+- `AppProviders` can use an injected store or create a fresh store from explicit
+  preloaded state.
+- Theme rendering uses an explicit initial mode and does not require `document`
+  during static rendering.
+- `Content` accepts serializable initial Markdown and curriculum metadata while
+  preserving its current SPA Markdown loader as a fallback.
+
+The spike now pre-renders the production providers and content page through a
+dedicated readiness route. The generated source HTML contains the real topic
+content instead of the loading placeholder, and Playwright hydration completed
+without console warnings.
+
+Production routing remains on `BrowserRouter` and component routes. Framework
+route modules, loaders, metadata exports, and client hydration ownership belong
+to the following migration task.
diff --git a/eslint.config.js b/eslint.config.js
index 5e6b472..ccde9ad 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -6,7 +6,7 @@ import tseslint from 'typescript-eslint'
 import { defineConfig, globalIgnores } from 'eslint/config'
 
 export default defineConfig([
-  globalIgnores(['dist']),
+  globalIgnores(['.react-router', 'build-framework', 'dist']),
   {
     files: ['**/*.{ts,tsx}'],
     extends: [
@@ -20,4 +20,13 @@ export default defineConfig([
       globals: globals.browser,
     },
   },
+  {
+    files: [
+      'app/**/*.tsx',
+      'spikes/react-router-7-ssg/app/routes/**/*.tsx',
+    ],
+    rules: {
+      'react-refresh/only-export-components': 'off',
+    },
+  },
 ])
diff --git a/index.html b/index.html
index 3da1d83..8ccb321 100644
--- a/index.html
+++ b/index.html
@@ -4,7 +4,46 @@
     <meta charset="UTF-8" />
     <link rel="icon" type="image/svg+xml" href="/icon.png" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>dev-net-core</title>
+    <script src="/theme-bootstrap.js"></script>
+    <title>DEV_NET_CORE | Developer Interview Preparation</title>
+    <meta
+      name="description"
+      content="Structured interview preparation for .NET, React, SQL, Azure, architecture, and modern software engineering topics."
+    />
+    <link rel="canonical" href="https://www.dev-net-core.com/" />
+    <meta
+      property="og:title"
+      content="DEV_NET_CORE | Developer Interview Preparation"
+    />
+    <meta
+      property="og:description"
+      content="Structured interview preparation for .NET, React, SQL, Azure, architecture, and modern software engineering topics."
+    />
+    <meta property="og:type" content="website" />
+    <meta property="og:url" content="https://www.dev-net-core.com/" />
+    <meta
+      property="og:image"
+      content="https://www.dev-net-core.com/og/default-og-image.png"
+    />
+    <meta property="og:image:width" content="1200" />
+    <meta property="og:image:height" content="630" />
+    <meta
+      property="og:image:alt"
+      content="DEV_NET_CORE developer interview preparation"
+    />
+    <meta name="twitter:card" content="summary_large_image" />
+    <meta
+      name="twitter:title"
+      content="DEV_NET_CORE | Developer Interview Preparation"
+    />
+    <meta
+      name="twitter:description"
+      content="Structured interview preparation for .NET, React, SQL, Azure, architecture, and modern software engineering topics."
+    />
+    <meta
+      name="twitter:image"
+      content="https://www.dev-net-core.com/og/default-og-image.png"
+    />
   </head>
   <body>
     <div id="root"></div>
diff --git a/package-lock.json b/package-lock.json
index ddbce5a..724c53e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -20,13 +20,16 @@
         "react-hook-form": "^7.71.1",
         "react-markdown": "^10.1.0",
         "react-redux": "^9.2.0",
-        "react-router-dom": "^7.12.0",
+        "react-router-dom": "7.18.0",
         "rehype-highlight": "^7.0.2",
         "remark-gfm": "^4.0.1",
         "yup": "^1.7.1"
       },
       "devDependencies": {
         "@eslint/js": "^9.39.1",
+        "@react-router/dev": "7.18.0",
+        "@react-router/node": "7.18.0",
+        "@react-router/serve": "7.18.0",
         "@tailwindcss/vite": "^4.3.0",
         "@types/node": "^24.10.1",
         "@types/react": "^19.2.5",
@@ -36,6 +39,7 @@
         "eslint-plugin-react-hooks": "^7.0.1",
         "eslint-plugin-react-refresh": "^0.4.24",
         "globals": "^16.5.0",
+        "react-router": "7.18.0",
         "tailwindcss": "^4.3.0",
         "typescript": "~5.9.3",
         "typescript-eslint": "^8.46.4",
@@ -43,12 +47,12 @@
       }
     },
     "node_modules/@babel/code-frame": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.28.6.tgz",
-      "integrity": "sha512-JYgintcMjRiCvS8mMECzaEn+m3PfoQiyqukOMCCVQtoJGYJw8j/8LBJEiqkHLkfwCcs74E3pbAUFNg7d9VNJ+Q==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz",
+      "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/helper-validator-identifier": "^7.29.7",
         "js-tokens": "^4.0.0",
         "picocolors": "^1.1.1"
       },
@@ -98,13 +102,13 @@
       }
     },
     "node_modules/@babel/generator": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.6.tgz",
-      "integrity": "sha512-lOoVRwADj8hjf7al89tvQ2a1lf53Z+7tiXMgpZJL3maQPDxh0DgLMN62B2MKUOFcoodBHLMbDM6WAbKgNy5Suw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.7.tgz",
+      "integrity": "sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/parser": "^7.28.6",
-        "@babel/types": "^7.28.6",
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7",
         "@jridgewell/gen-mapping": "^0.3.12",
         "@jridgewell/trace-mapping": "^0.3.28",
         "jsesc": "^3.0.2"
@@ -113,6 +117,19 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@babel/helper-annotate-as-pure": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.29.7.tgz",
+      "integrity": "sha512-OoK6239jHPuSQOoS0kfTVKn0b/rVTk0seKq4Gd2UMLtmOVLjDC0ki3e+c90Trqv2gMfvJFqkiljrr568+qddiw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@babel/helper-compilation-targets": {
       "version": "7.28.6",
       "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
@@ -130,38 +147,74 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@babel/helper-create-class-features-plugin": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.29.7.tgz",
+      "integrity": "sha512-IY3ZD9Tmooqr3TUhc3DUWxiuo8xx1DWLhd5M7hQ+ZWJamqM2BbalrBJb2MisSLoYorOj75U03qULCxQTY9r3hg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "@babel/helper-member-expression-to-functions": "^7.29.7",
+        "@babel/helper-optimise-call-expression": "^7.29.7",
+        "@babel/helper-replace-supers": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7",
+        "@babel/traverse": "^7.29.7",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
     "node_modules/@babel/helper-globals": {
-      "version": "7.28.0",
-      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
-      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz",
+      "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-member-expression-to-functions": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.29.7.tgz",
+      "integrity": "sha512-j+7JYmk1JYDtACIGj0QJqqWZjoUpMoEikQGADMaHgCMCSDqd2+P32rfcibUNrGOMWrlzK1WJBdxrB3JJQZwWtg==",
+      "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-module-imports": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
-      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz",
+      "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==",
       "license": "MIT",
       "dependencies": {
-        "@babel/traverse": "^7.28.6",
-        "@babel/types": "^7.28.6"
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-module-transforms": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
-      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz",
+      "integrity": "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-imports": "^7.28.6",
-        "@babel/helper-validator-identifier": "^7.28.5",
-        "@babel/traverse": "^7.28.6"
+        "@babel/helper-module-imports": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -170,38 +223,83 @@
         "@babel/core": "^7.0.0"
       }
     },
+    "node_modules/@babel/helper-optimise-call-expression": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.29.7.tgz",
+      "integrity": "sha512-+kmGVjcT9RGYzoDwdwEqEvGgKe3BYq+O1iGzjFubaNgZHwYHP6lsF2Yghf4kEuv9BV7tYDZ913aBW9am6YKong==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@babel/helper-plugin-utils": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
-      "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.29.7.tgz",
+      "integrity": "sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-replace-supers": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.29.7.tgz",
+      "integrity": "sha512-atfGXWSeCiF4DnKZIfmJfQRkSw9b9gNNXR1kqKjbhG4pGYCOnkp8OcTB8E3NXjBu8NpheSnOeNKz8KT7UNFTmQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-member-expression-to-functions": "^7.29.7",
+        "@babel/helper-optimise-call-expression": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-skip-transparent-expression-wrappers": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.29.7.tgz",
+      "integrity": "sha512-brcMGQaVzIeUb+6/bs1Av0f8YuNNjKY2JyvfRCsFuFsdKccEQ5Ges2y74D74NZ1Rz8lKJ9ksJkfqwQFJ/iNEyQ==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-string-parser": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
-      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+      "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
-      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+      "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-validator-option": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
-      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz",
+      "integrity": "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -223,12 +321,12 @@
       }
     },
     "node_modules/@babel/parser": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.6.tgz",
-      "integrity": "sha512-TeR9zWR18BvbfPmGbLampPMW+uW1NZnJlRuuHso8i87QZNq2JRF9i6RgxRqtEq+wQGsS19NNTWr2duhnE49mfQ==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.7.tgz",
+      "integrity": "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.28.6"
+        "@babel/types": "^7.29.7"
       },
       "bin": {
         "parser": "bin/babel-parser.js"
@@ -237,6 +335,55 @@
         "node": ">=6.0.0"
       }
     },
+    "node_modules/@babel/plugin-syntax-jsx": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.29.7.tgz",
+      "integrity": "sha512-TSu8+mHCoEaaCDEZ0I3+6mvTBYR4PCxQwf2z9/r5Tbztv6NaLR3B9thGTTxX2WGuGHJqRiAbKPeGTJ5XWXVg6A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-typescript": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.29.7.tgz",
+      "integrity": "sha512-ngr+82Sh0xMz25TPCZi+nC2iTzjfCdWS2ONXTp/PtSCHCgaCNBpdMqgvJ2ccdLlClVZ7sisIgB914j/JFe+RZA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-modules-commonjs": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.29.7.tgz",
+      "integrity": "sha512-j0vCldybPC5b5dwCQOJ21uKtHzt7hxLygJTg9eF1ScfaikEDNfzn94XoW5Fi+seBR0nCyL23xaBFFkq7dTM8XQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
     "node_modules/@babel/plugin-transform-react-jsx-self": {
       "version": "7.27.1",
       "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
@@ -269,6 +416,46 @@
         "@babel/core": "^7.0.0-0"
       }
     },
+    "node_modules/@babel/plugin-transform-typescript": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.29.7.tgz",
+      "integrity": "sha512-jK52h8LaLc7JarhQV2ofeFMts4H7vnOXnqZNA6fYglBTZewRBE51KWt3BUltW1P+KoPsYkHoJeXePuz4zo2LMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "@babel/helper-create-class-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7",
+        "@babel/plugin-syntax-typescript": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/preset-typescript": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.29.7.tgz",
+      "integrity": "sha512-/Foi8vKY2EVbed/1eZx0gJEEwHAIxogrySI7rULcRIvhZzbvoE/b5qG5Ghc0WKAFKOHA9SD1x7RsFlOYdutIiQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-validator-option": "^7.29.7",
+        "@babel/plugin-syntax-jsx": "^7.29.7",
+        "@babel/plugin-transform-modules-commonjs": "^7.29.7",
+        "@babel/plugin-transform-typescript": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
     "node_modules/@babel/runtime": {
       "version": "7.28.6",
       "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.6.tgz",
@@ -279,31 +466,31 @@
       }
     },
     "node_modules/@babel/template": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
-      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz",
+      "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.28.6",
-        "@babel/parser": "^7.28.6",
-        "@babel/types": "^7.28.6"
+        "@babel/code-frame": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/traverse": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.6.tgz",
-      "integrity": "sha512-fgWX62k02qtjqdSNTAGxmKYY/7FSL9WAS1o2Hu5+I5m9T0yxZzr4cnrfXQ/MX0rIifthCSs6FKTlzYbJcPtMNg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.7.tgz",
+      "integrity": "sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.28.6",
-        "@babel/generator": "^7.28.6",
-        "@babel/helper-globals": "^7.28.0",
-        "@babel/parser": "^7.28.6",
-        "@babel/template": "^7.28.6",
-        "@babel/types": "^7.28.6",
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.7",
+        "@babel/helper-globals": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.7",
         "debug": "^4.3.1"
       },
       "engines": {
@@ -311,13 +498,13 @@
       }
     },
     "node_modules/@babel/types": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.6.tgz",
-      "integrity": "sha512-0ZrskXVEHSWIqZM/sQZ4EV3jZJXRkio/WCxaqKZP1g//CEWEPSfeZFcms4XeKBCHU0ZKnIkdJeU/kF+eRp5lBg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.7.tgz",
+      "integrity": "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-string-parser": "^7.27.1",
-        "@babel/helper-validator-identifier": "^7.28.5"
+        "@babel/helper-string-parser": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1184,6 +1371,13 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
+    "node_modules/@mjackson/node-fetch-server": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/@mjackson/node-fetch-server/-/node-fetch-server-0.2.0.tgz",
+      "integrity": "sha512-EMlH1e30yzmTpGLQjlFmaDAjyOeZhng1/XCd7DExR8PNAnG/G1tyruZxEoUe11ClnwGhGrtsdnyyUx1frSzjng==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@mui/core-downloads-tracker": {
       "version": "7.3.7",
       "resolved": "https://registry.npmjs.org/@mui/core-downloads-tracker/-/core-downloads-tracker-7.3.7.tgz",
@@ -1427,6 +1621,182 @@
         "url": "https://opencollective.com/popperjs"
       }
     },
+    "node_modules/@react-router/dev": {
+      "version": "7.18.0",
+      "resolved": "https://registry.npmjs.org/@react-router/dev/-/dev-7.18.0.tgz",
+      "integrity": "sha512-GVTFvul0xlZHZyVXyRpiJv54Xfyj4eDOAlGYrzi7kDmN7n40rsrUqX+hvU0fy/41SCDMtckht59R3iGR94703g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.27.7",
+        "@babel/generator": "^7.27.5",
+        "@babel/parser": "^7.27.7",
+        "@babel/plugin-syntax-jsx": "^7.27.1",
+        "@babel/preset-typescript": "^7.27.1",
+        "@babel/traverse": "^7.27.7",
+        "@babel/types": "^7.27.7",
+        "@react-router/node": "7.18.0",
+        "@remix-run/node-fetch-server": "^0.13.0",
+        "arg": "^5.0.1",
+        "babel-dead-code-elimination": "^1.0.6",
+        "chokidar": "^4.0.0",
+        "dedent": "^1.5.3",
+        "es-module-lexer": "^1.3.1",
+        "exit-hook": "2.2.1",
+        "isbot": "^5.1.11",
+        "jsesc": "3.0.2",
+        "lodash": "^4.17.21",
+        "p-map": "^7.0.3",
+        "pathe": "^1.1.2",
+        "picocolors": "^1.1.1",
+        "pkg-types": "^2.3.0",
+        "prettier": "^3.6.2",
+        "react-refresh": "^0.14.0",
+        "semver": "^7.3.7",
+        "tinyglobby": "^0.2.14",
+        "valibot": "^1.2.0",
+        "vite-node": "^3.2.2"
+      },
+      "bin": {
+        "react-router": "bin.js"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "@react-router/serve": "^7.18.0",
+        "@vitejs/plugin-rsc": "~0.5.21",
+        "react-router": "^7.18.0",
+        "react-server-dom-webpack": "^19.2.3",
+        "typescript": "^5.1.0 || ^6.0.0",
+        "vite": "^5.1.0 || ^6.0.0 || ^7.0.0 || ^8.0.0",
+        "wrangler": "^3.28.2 || ^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@react-router/serve": {
+          "optional": true
+        },
+        "@vitejs/plugin-rsc": {
+          "optional": true
+        },
+        "react-server-dom-webpack": {
+          "optional": true
+        },
+        "typescript": {
+          "optional": true
+        },
+        "wrangler": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@react-router/dev/node_modules/jsesc": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.0.2.tgz",
+      "integrity": "sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/@react-router/dev/node_modules/react-refresh": {
+      "version": "0.14.2",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.14.2.tgz",
+      "integrity": "sha512-jCvmsr+1IUSMUyzOkRcvnVbX3ZYC6g9TDrDbFuFmRDq7PD4yaGbLKNQL6k2jnArV8hjYxh7hVhAZB6s9HDGpZA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/@react-router/dev/node_modules/semver": {
+      "version": "7.8.5",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
+      "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@react-router/express": {
+      "version": "7.18.0",
+      "resolved": "https://registry.npmjs.org/@react-router/express/-/express-7.18.0.tgz",
+      "integrity": "sha512-7+6oZJYdJ7ha7ASV0XkYZkmnTUYtRkzjzjpZh3W9tPdaUY1zJoDFiMlUJZoAg0mHw8BNTAwVWCCf8NFV1xlLZA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@react-router/node": "7.18.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "express": "^4.17.1 || ^5",
+        "react-router": "7.18.0",
+        "typescript": "^5.1.0 || ^6.0.0"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@react-router/node": {
+      "version": "7.18.0",
+      "resolved": "https://registry.npmjs.org/@react-router/node/-/node-7.18.0.tgz",
+      "integrity": "sha512-pRXJahLrdVfuVbaTpWsZ89mBuGiYH3Z4y+y1UidwxmJFKk6NjMyUvkJl3FjDWdD+nSlgFPSESUZS0hF560MUUQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@mjackson/node-fetch-server": "^0.2.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "react-router": "7.18.0",
+        "typescript": "^5.1.0 || ^6.0.0"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@react-router/serve": {
+      "version": "7.18.0",
+      "resolved": "https://registry.npmjs.org/@react-router/serve/-/serve-7.18.0.tgz",
+      "integrity": "sha512-IrF0cLcJNGBBavnRBm3HxaEGwRrLrLF8E4EzQFuCpkgP1sRli1x2xEOOTJl4zBgUbyIn0ey4TAD6ytg45MAUBQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@mjackson/node-fetch-server": "^0.2.0",
+        "@react-router/express": "7.18.0",
+        "@react-router/node": "7.18.0",
+        "compression": "^1.8.1",
+        "express": "^4.19.2",
+        "get-port": "5.1.1",
+        "morgan": "^1.10.1",
+        "source-map-support": "^0.5.21"
+      },
+      "bin": {
+        "react-router-serve": "bin.js"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "react-router": "7.18.0"
+      }
+    },
     "node_modules/@reduxjs/toolkit": {
       "version": "2.11.2",
       "resolved": "https://registry.npmjs.org/@reduxjs/toolkit/-/toolkit-2.11.2.tgz",
@@ -1453,6 +1823,13 @@
         }
       }
     },
+    "node_modules/@remix-run/node-fetch-server": {
+      "version": "0.13.3",
+      "resolved": "https://registry.npmjs.org/@remix-run/node-fetch-server/-/node-fetch-server-0.13.3.tgz",
+      "integrity": "sha512-UfjOXed/DQteaM5VyTfqTeGpHwyL2J5aoRGY6cydip4tt1ehNNeSwuXCC7AEGE0RWBs/7bgKxYkL/B/+UDe4AA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@rolldown/pluginutils": {
       "version": "1.0.0-beta.53",
       "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.53.tgz",
@@ -2286,6 +2663,7 @@
       "version": "19.2.9",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.9.tgz",
       "integrity": "sha512-Lpo8kgb/igvMIPeNV2rsYKTgaORYdO1XGVZ4Qz3akwOj0ySGYMPlQWa8BaLn0G63D1aSaAQ5ldR06wCpChQCjA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "csstype": "^3.2.2"
@@ -2618,6 +2996,30 @@
         "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
       }
     },
+    "node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/accepts/node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/acorn": {
       "version": "8.15.0",
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
@@ -2686,6 +3088,13 @@
         "url": "https://github.com/chalk/ansi-styles?sponsor=1"
       }
     },
+    "node_modules/arg": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz",
+      "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/argparse": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
@@ -2693,6 +3102,13 @@
       "dev": true,
       "license": "Python-2.0"
     },
+    "node_modules/array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/asynckit": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
@@ -2711,6 +3127,19 @@
         "proxy-from-env": "^2.1.0"
       }
     },
+    "node_modules/babel-dead-code-elimination": {
+      "version": "1.0.12",
+      "resolved": "https://registry.npmjs.org/babel-dead-code-elimination/-/babel-dead-code-elimination-1.0.12.tgz",
+      "integrity": "sha512-GERT7L2TiYcYDtYk1IpD+ASAYXjKbLTDPhBtYj7X1NuRMDTMtAx9kyBenub1Ev41lo91OHCKdmP+egTDmfQ7Ig==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.23.7",
+        "@babel/parser": "^7.23.6",
+        "@babel/traverse": "^7.23.7",
+        "@babel/types": "^7.23.6"
+      }
+    },
     "node_modules/babel-plugin-macros": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/babel-plugin-macros/-/babel-plugin-macros-3.1.0.tgz",
@@ -2753,7 +3182,69 @@
         "baseline-browser-mapping": "dist/cli.js"
       }
     },
-    "node_modules/brace-expansion": {
+    "node_modules/basic-auth": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/basic-auth/-/basic-auth-2.0.1.tgz",
+      "integrity": "sha512-NF+epuEdnUYVlGuhaxbbq+dvJttwLnGY+YixlXlME5KpQ5W3CnXA5cVTneY3SPbPDRkcjMbifrwmFYcClgOZeg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.1.2"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/basic-auth/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/body-parser": {
+      "version": "1.20.5",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.5.tgz",
+      "integrity": "sha512-3grm+/2tUOvu2cjJkvsIxrv/wVpfXQW4PsQHYm7yk4vfpu7Ekl6nEsYBoJUL6qDwZUx8wUhQ8tR2qz+ad9c9OA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "~3.1.2",
+        "content-type": "~1.0.5",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "~1.2.0",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.4.24",
+        "on-finished": "~2.4.1",
+        "qs": "~6.15.1",
+        "raw-body": "~2.5.3",
+        "type-is": "~1.6.18",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/body-parser/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/body-parser/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/brace-expansion": {
       "version": "1.1.12",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
       "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
@@ -2798,6 +3289,33 @@
         "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
       }
     },
+    "node_modules/buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/cac": {
+      "version": "6.7.14",
+      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
+      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/call-bind-apply-helpers": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
@@ -2811,6 +3329,23 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/callsites": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
@@ -2908,6 +3443,22 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/chokidar": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
+      "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "readdirp": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 14.16.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
     "node_modules/clsx": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
@@ -2959,6 +3510,55 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/compressible": {
+      "version": "2.0.18",
+      "resolved": "https://registry.npmjs.org/compressible/-/compressible-2.0.18.tgz",
+      "integrity": "sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": ">= 1.43.0 < 2"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/compression": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/compression/-/compression-1.8.1.tgz",
+      "integrity": "sha512-9mAqGPHLakhCLeNyxPkK4xVo746zQ/czLH1Ky+vkitMnWfWZps8r0qXuwhwizagCRttsL4lfG4pIOvaWLpAP0w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "compressible": "~2.0.18",
+        "debug": "2.6.9",
+        "negotiator": "~0.6.4",
+        "on-headers": "~1.1.0",
+        "safe-buffer": "5.2.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/compression/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/compression/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/concat-map": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
@@ -2966,6 +3566,36 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/confbox": {
+      "version": "0.2.4",
+      "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.2.4.tgz",
+      "integrity": "sha512-ysOGlgTFbN2/Y6Cg3Iye8YKulHw+R2fNXHrgSmXISQdMnomY6eNDprVdW9R5xBguEqI954+S6709UyiO7B+6OQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/content-disposition": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/convert-source-map": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
@@ -2986,6 +3616,13 @@
         "url": "https://opencollective.com/express"
       }
     },
+    "node_modules/cookie-signature": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.7.tgz",
+      "integrity": "sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/cosmiconfig": {
       "version": "7.1.0",
       "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-7.1.0.tgz",
@@ -3062,6 +3699,21 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/dedent": {
+      "version": "1.7.2",
+      "resolved": "https://registry.npmjs.org/dedent/-/dedent-1.7.2.tgz",
+      "integrity": "sha512-WzMx3mW98SN+zn3hgemf4OzdmyNhhhKz5Ay0pUfQiMQ3e1g+xmTJWp/pKdwKVXhdSkAEGIIzqeuWrL3mV/AXbA==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "babel-plugin-macros": "^3.1.0"
+      },
+      "peerDependenciesMeta": {
+        "babel-plugin-macros": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/deep-is": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
@@ -3078,6 +3730,16 @@
         "node": ">=0.4.0"
       }
     },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/dequal": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
@@ -3087,6 +3749,17 @@
         "node": ">=6"
       }
     },
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
     "node_modules/detect-libc": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
@@ -3134,6 +3807,13 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/electron-to-chromium": {
       "version": "1.5.277",
       "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.277.tgz",
@@ -3141,6 +3821,16 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/enhanced-resolve": {
       "version": "5.21.2",
       "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.21.2.tgz",
@@ -3182,6 +3872,13 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/es-module-lexer": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
+      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/es-object-atoms": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
@@ -3261,6 +3958,13 @@
         "node": ">=6"
       }
     },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/escape-string-regexp": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
@@ -3467,6 +4171,110 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/exit-hook": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/exit-hook/-/exit-hook-2.2.1.tgz",
+      "integrity": "sha512-eNTPlAD67BmP31LDINZ3U7HSF8l57TxOY2PmBJ1shpCvpnxBF93mWCE8YHBnXs8qiUZJc9WDcWIeC3a2HIAMfw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/express": {
+      "version": "4.22.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.22.2.tgz",
+      "integrity": "sha512-IuL+Elrou2ZvCFHs18/CIzy2Nzvo25nZ1/D2eIZlz7c+QUayAcYoiM2BthCjs+EBHVpjYjcuLDAiCWgeIX3X1Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "~1.20.5",
+        "content-disposition": "~0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "~0.7.1",
+        "cookie-signature": "~1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "~1.3.1",
+        "fresh": "~0.5.2",
+        "http-errors": "~2.0.0",
+        "merge-descriptors": "1.0.3",
+        "methods": "~1.1.2",
+        "on-finished": "~2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "~0.1.12",
+        "proxy-addr": "~2.0.7",
+        "qs": "~6.15.1",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "~0.19.0",
+        "serve-static": "~1.16.2",
+        "setprototypeof": "1.2.0",
+        "statuses": "~2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/express/node_modules/cookie": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/express/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/express/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/exsolve": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/exsolve/-/exsolve-1.1.0.tgz",
+      "integrity": "sha512-D+42+T12DdIlJM3uepa55qGiL3sYdLBOxIl2ifQCzCHz4c7eiolaHsi3BIqEr7JxBzxv2pYZQX9kw16ziMcEmw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/extend": {
       "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
@@ -3525,6 +4333,42 @@
         "node": ">=16.0.0"
       }
     },
+    "node_modules/finalhandler": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz",
+      "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "on-finished": "~2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "~2.0.2",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/finalhandler/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/finalhandler/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/find-root": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/find-root/-/find-root-1.1.0.tgz",
@@ -3605,6 +4449,26 @@
         "node": ">= 6"
       }
     },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/fsevents": {
       "version": "2.3.3",
       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
@@ -3663,6 +4527,19 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/get-port": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/get-port/-/get-port-5.1.1.tgz",
+      "integrity": "sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/get-proto": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
@@ -3890,6 +4767,27 @@
         "url": "https://opencollective.com/unified"
       }
     },
+    "node_modules/http-errors": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",
+      "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "depd": "~2.0.0",
+        "inherits": "~2.0.4",
+        "setprototypeof": "~1.2.0",
+        "statuses": "~2.0.2",
+        "toidentifier": "~1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
     "node_modules/https-proxy-agent": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz",
@@ -3903,14 +4801,27 @@
         "node": ">= 6"
       }
     },
-    "node_modules/ignore": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
-      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
       "engines": {
-        "node": ">= 4"
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
       }
     },
     "node_modules/immer": {
@@ -3949,12 +4860,29 @@
         "node": ">=0.8.19"
       }
     },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/inline-style-parser": {
       "version": "0.2.7",
       "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.7.tgz",
       "integrity": "sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA==",
       "license": "MIT"
     },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
     "node_modules/is-alphabetical": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-2.0.1.tgz",
@@ -4055,6 +4983,16 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/isbot": {
+      "version": "5.1.44",
+      "resolved": "https://registry.npmjs.org/isbot/-/isbot-5.1.44.tgz",
+      "integrity": "sha512-PGEHtwMnKbZpeSEXW2Utx+/JWed7dp6DiH0WWg33vGSDA7RUvpUeJSVlLrVkQ1RCpvDOUc/eH9ql7VsdbBZ8pA==",
+      "dev": true,
+      "license": "Unlicense",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/isexe": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
@@ -4450,6 +5388,13 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/lodash": {
+      "version": "4.18.1",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
+      "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/lodash.merge": {
       "version": "4.6.2",
       "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
@@ -4815,6 +5760,36 @@
         "url": "https://opencollective.com/unified"
       }
     },
+    "node_modules/media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/micromark": {
       "version": "4.0.2",
       "resolved": "https://registry.npmjs.org/micromark/-/micromark-4.0.2.tgz",
@@ -5378,6 +6353,19 @@
       ],
       "license": "MIT"
     },
+    "node_modules/mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/mime-db": {
       "version": "1.52.0",
       "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
@@ -5412,6 +6400,44 @@
         "node": "*"
       }
     },
+    "node_modules/morgan": {
+      "version": "1.11.0",
+      "resolved": "https://registry.npmjs.org/morgan/-/morgan-1.11.0.tgz",
+      "integrity": "sha512-zSkVu3t18r39pw4ixfBKvfZi3y2UOqr7d4WYwcj3m8nXpEQK4rPO6GLzs/CExoRgmX3y9EjmmcXqv6jq0SK46g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "basic-auth": "~2.0.1",
+        "debug": "2.6.9",
+        "depd": "~2.0.0",
+        "on-finished": "~2.4.1",
+        "on-headers": "~1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/morgan/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/morgan/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -5444,6 +6470,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/negotiator": {
+      "version": "0.6.4",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.4.tgz",
+      "integrity": "sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/node-releases": {
       "version": "2.0.27",
       "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz",
@@ -5460,6 +6496,42 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/on-headers": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/on-headers/-/on-headers-1.1.0.tgz",
+      "integrity": "sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/optionator": {
       "version": "0.9.4",
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
@@ -5510,6 +6582,19 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/p-map": {
+      "version": "7.0.4",
+      "resolved": "https://registry.npmjs.org/p-map/-/p-map-7.0.4.tgz",
+      "integrity": "sha512-tkAQEw8ysMzmkhgw8k+1U/iPhWNhykKnSk4Rd5zLoPJCuJaGRPo6YposrZgaxHKzDHdDWWZvE/Sk7hsL2X/CpQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/parent-module": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
@@ -5565,6 +6650,16 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/path-exists": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
@@ -5591,6 +6686,13 @@
       "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
       "license": "MIT"
     },
+    "node_modules/path-to-regexp": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.13.tgz",
+      "integrity": "sha512-A/AGNMFN3c8bOlvV9RreMdrv7jsmF9XIfDeCd87+I8RNg6s78BhJxMu69NEMHBSJFxKidViTEdruRwEk/WIKqA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/path-type": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
@@ -5600,6 +6702,13 @@
         "node": ">=8"
       }
     },
+    "node_modules/pathe": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz",
+      "integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -5619,6 +6728,25 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
+    "node_modules/pkg-types": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-2.3.1.tgz",
+      "integrity": "sha512-y+ichcgc2LrADuhLNAx8DFjVfgz91pRxfZdI3UDhxHvcVEZsenLO+7XaU5vOp0u/7V/wZ+plyuQxtrDlZJ+yeg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "confbox": "^0.2.4",
+        "exsolve": "^1.0.8",
+        "pathe": "^2.0.3"
+      }
+    },
+    "node_modules/pkg-types/node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/postcss": {
       "version": "8.5.6",
       "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
@@ -5658,6 +6786,22 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/prettier": {
+      "version": "3.9.0",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.9.0.tgz",
+      "integrity": "sha512-LjIqSIC5VYLzs9WedVmJ2ljNAGnU+DteIClbahu4L/DBeWjZ6iT/k1lAYyu9JUh+1xINxWadaPw/Pl63y/agAw==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "prettier": "bin/prettier.cjs"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      }
+    },
     "node_modules/prop-types": {
       "version": "15.8.1",
       "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
@@ -5691,6 +6835,20 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
     "node_modules/proxy-from-env": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-2.1.0.tgz",
@@ -5710,6 +6868,49 @@
         "node": ">=6"
       }
     },
+    "node_modules/qs": {
+      "version": "6.15.3",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.15.3.tgz",
+      "integrity": "sha512-O9gl3zCl5h5blw1KGUzQKhA5oUXSl8rwUIM5o0S3nCXMliSvy5Dzx7/DJcI+SwgICv+IneSZwhBh1oSyEHA71A==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "es-define-property": "^1.0.1",
+        "side-channel": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "2.5.3",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz",
+      "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "~3.1.2",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.4.24",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/react": {
       "version": "19.2.3",
       "resolved": "https://registry.npmjs.org/react/-/react-19.2.3.tgz",
@@ -5814,9 +7015,9 @@
       }
     },
     "node_modules/react-router": {
-      "version": "7.12.0",
-      "resolved": "https://registry.npmjs.org/react-router/-/react-router-7.12.0.tgz",
-      "integrity": "sha512-kTPDYPFzDVGIIGNLS5VJykK0HfHLY5MF3b+xj0/tTyNYL1gF1qs7u67Z9jEhQk2sQ98SUaHxlG31g1JtF7IfVw==",
+      "version": "7.18.0",
+      "resolved": "https://registry.npmjs.org/react-router/-/react-router-7.18.0.tgz",
+      "integrity": "sha512-pTTGt8J+ji1NOmYnjzT+bAJy/1zD+Jp4ziO6cL7T3ZLvXKtusO7BpFqlRXitqpcPVqllsIXFHRMt+2/k3Xn6HQ==",
       "license": "MIT",
       "dependencies": {
         "cookie": "^1.0.1",
@@ -5836,12 +7037,12 @@
       }
     },
     "node_modules/react-router-dom": {
-      "version": "7.12.0",
-      "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-7.12.0.tgz",
-      "integrity": "sha512-pfO9fiBcpEfX4Tx+iTYKDtPbrSLLCbwJ5EqP+SPYQu1VYCXdy79GSj0wttR0U4cikVdlImZuEZ/9ZNCgoaxwBA==",
+      "version": "7.18.0",
+      "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-7.18.0.tgz",
+      "integrity": "sha512-Fi0yY6kgtKae/Th2xibdWK0KSdYZ4B53Gyf6wRtomOKWgpNm7H7+DyfDhncdz9FKbpS+1jmDhg3F4WoGJ+yFOA==",
       "license": "MIT",
       "dependencies": {
-        "react-router": "7.12.0"
+        "react-router": "7.18.0"
       },
       "engines": {
         "node": ">=20.0.0"
@@ -5867,6 +7068,20 @@
         "react-dom": ">=16.6.0"
       }
     },
+    "node_modules/readdirp": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
+      "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.18.0"
+      },
+      "funding": {
+        "type": "individual",
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
     "node_modules/redux": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/redux/-/redux-5.0.1.tgz",
@@ -6045,6 +7260,34 @@
         "fsevents": "~2.3.2"
       }
     },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/scheduler": {
       "version": "0.27.0",
       "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
@@ -6061,12 +7304,77 @@
         "semver": "bin/semver.js"
       }
     },
+    "node_modules/send": {
+      "version": "0.19.2",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz",
+      "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "~0.5.2",
+        "http-errors": "~2.0.1",
+        "mime": "1.6.0",
+        "ms": "2.1.3",
+        "on-finished": "~2.4.1",
+        "range-parser": "~1.2.1",
+        "statuses": "~2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/send/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/send/node_modules/debug/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/serve-static": {
+      "version": "1.16.3",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz",
+      "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "~0.19.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
     "node_modules/set-cookie-parser": {
       "version": "2.7.2",
       "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-2.7.2.tgz",
       "integrity": "sha512-oeM1lpU/UvhTxw+g3cIfxXHyJRc/uidd3yK1P242gzHds0udQBYzs3y8j4gCCW+ZJ7ad0yctld8RYO+bdurlvw==",
       "license": "MIT"
     },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/shebang-command": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
@@ -6090,6 +7398,82 @@
         "node": ">=8"
       }
     },
+    "node_modules/side-channel": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.1.tgz",
+      "integrity": "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.4",
+        "side-channel-list": "^1.0.1",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.1.tgz",
+      "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.4"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/source-map": {
       "version": "0.5.7",
       "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
@@ -6109,6 +7493,27 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/source-map-support": {
+      "version": "0.5.21",
+      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
+      "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      }
+    },
+    "node_modules/source-map-support/node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/space-separated-tokens": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz",
@@ -6119,6 +7524,16 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/statuses": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
+      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/stringify-entities": {
       "version": "4.0.4",
       "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz",
@@ -6239,6 +7654,16 @@
         "url": "https://github.com/sponsors/SuperchupuDev"
       }
     },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
     "node_modules/toposort": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/toposort/-/toposort-2.0.2.tgz",
@@ -6303,6 +7728,20 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/typescript": {
       "version": "5.9.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
@@ -6449,6 +7888,16 @@
         "url": "https://opencollective.com/unified"
       }
     },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/update-browserslist-db": {
       "version": "1.2.3",
       "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
@@ -6499,6 +7948,41 @@
         "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
       }
     },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/valibot": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/valibot/-/valibot-1.4.1.tgz",
+      "integrity": "sha512-klCmFTz2jeDluy9RwX+F884TCiogtdBJ/YaxSx1EOBYXa3NXNWj8kR1jjN8rzluwojJVWWaHJ4r1U5LfICnM3g==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "typescript": ">=5"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/vfile": {
       "version": "6.0.3",
       "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz",
@@ -6602,6 +8086,36 @@
         }
       }
     },
+    "node_modules/vite-node": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-3.2.4.tgz",
+      "integrity": "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cac": "^6.7.14",
+        "debug": "^4.4.1",
+        "es-module-lexer": "^1.7.0",
+        "pathe": "^2.0.3",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
+      },
+      "bin": {
+        "vite-node": "vite-node.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/vite-node/node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -6635,24 +8149,6 @@
       "dev": true,
       "license": "ISC"
     },
-    "node_modules/yaml": {
-      "version": "2.8.2",
-      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.2.tgz",
-      "integrity": "sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==",
-      "dev": true,
-      "license": "ISC",
-      "optional": true,
-      "peer": true,
-      "bin": {
-        "yaml": "bin.mjs"
-      },
-      "engines": {
-        "node": ">= 14.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/eemeli"
-      }
-    },
     "node_modules/yocto-queue": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
diff --git a/package.json b/package.json
index ac1010f..7576869 100644
--- a/package.json
+++ b/package.json
@@ -9,8 +9,16 @@
     "dev": "vite",
     "prebuild": "npm run generate:curriculum",
     "build": "tsc -b && vite build",
+    "prebuild:framework": "npm run generate:curriculum",
+    "build:framework": "react-router build --config vite.framework.config.ts && tsc -p tsconfig.framework.json",
+    "finalize:framework": "node scripts/finalize-framework-output.mjs",
     "lint": "eslint .",
-    "preview": "vite preview"
+    "test:content-route-data": "node --test shared/content/loadContentRouteData.test.mjs",
+    "test:seo": "node --test shared/seo/*.test.mjs",
+    "test:theme-bootstrap": "node --test scripts/theme-bootstrap.test.mjs",
+    "validate:framework": "node scripts/validate-framework-build.mjs",
+    "preview": "vite preview",
+    "preview:framework": "node scripts/preview-framework.mjs"
   },
   "dependencies": {
     "@emotion/react": "^11.14.0",
@@ -25,13 +33,16 @@
     "react-hook-form": "^7.71.1",
     "react-markdown": "^10.1.0",
     "react-redux": "^9.2.0",
-    "react-router-dom": "^7.12.0",
+    "react-router-dom": "7.18.0",
     "rehype-highlight": "^7.0.2",
     "remark-gfm": "^4.0.1",
     "yup": "^1.7.1"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
+    "@react-router/dev": "7.18.0",
+    "@react-router/node": "7.18.0",
+    "@react-router/serve": "7.18.0",
     "@tailwindcss/vite": "^4.3.0",
     "@types/node": "^24.10.1",
     "@types/react": "^19.2.5",
@@ -41,6 +52,7 @@
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-refresh": "^0.4.24",
     "globals": "^16.5.0",
+    "react-router": "7.18.0",
     "tailwindcss": "^4.3.0",
     "typescript": "~5.9.3",
     "typescript-eslint": "^8.46.4",
diff --git a/public/og/default-og-image.png b/public/og/default-og-image.png
new file mode 100644
index 0000000..6ed49e7
Binary files /dev/null and b/public/og/default-og-image.png differ
diff --git a/public/robots.txt b/public/robots.txt
new file mode 100644
index 0000000..c2a49f4
--- /dev/null
+++ b/public/robots.txt
@@ -0,0 +1,2 @@
+User-agent: *
+Allow: /
diff --git a/public/theme-bootstrap.js b/public/theme-bootstrap.js
new file mode 100644
index 0000000..3bfd335
--- /dev/null
+++ b/public/theme-bootstrap.js
@@ -0,0 +1,20 @@
+(function () {
+  var storageKey = "dev-net-core:theme";
+  var mode = "dark";
+
+  try {
+    var storedMode = window.localStorage.getItem(storageKey);
+
+    if (storedMode === "dark" || storedMode === "light") {
+      mode = storedMode;
+    }
+  } catch {
+    // Keep the stable dark default when browser storage is unavailable.
+  }
+
+  var root = document.documentElement;
+  root.dataset.theme = mode;
+  root.classList.toggle("dark", mode === "dark");
+  root.classList.toggle("light", mode === "light");
+  root.style.colorScheme = mode;
+})();
diff --git a/react-router.config.ts b/react-router.config.ts
new file mode 100644
index 0000000..69c8654
--- /dev/null
+++ b/react-router.config.ts
@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import type { Config } from "@react-router/dev/config";
+import { staticSeoRoutes } from "./shared/seo/seoRoutes.mjs";
+
+type SeoManifest = {
+  entries: Array<{
+    canonicalPath: string;
+    id: string;
+  }>;
+};
+
+const manifestPath = fileURLToPath(
+  new URL("./shared/content/curriculumSeoManifest.generated.json", import.meta.url)
+);
+const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")) as SeoManifest;
+const topicPaths = manifest.entries.map((entry) => entry.canonicalPath);
+const staticSitemapPaths = staticSeoRoutes
+  .filter((route) => route.sitemap)
+  .map((route) => route.path);
+const prerenderPaths = Array.from(
+  new Set([...staticSitemapPaths, ...topicPaths])
+);
+
+if (topicPaths.length === 0) {
+  throw new Error("The curriculum SEO manifest must contain at least one topic.");
+}
+
+export default {
+  appDirectory: "app",
+  buildDirectory: "build-framework",
+  future: {
+    v8_trailingSlashAwareDataRequests: true,
+  },
+  prerender: {
+    concurrency: 4,
+    paths: prerenderPaths,
+  },
+  routeDiscovery: { mode: "initial" },
+  ssr: false,
+} satisfies Config;
diff --git a/scripts/finalize-framework-output.mjs b/scripts/finalize-framework-output.mjs
new file mode 100644
index 0000000..acce710
--- /dev/null
+++ b/scripts/finalize-framework-output.mjs
@@ -0,0 +1,176 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { SEO_SITE_ORIGIN } from "../shared/seo/buildSeoMetadata.mjs";
+import { staticSeoRoutes } from "../shared/seo/seoRoutes.mjs";
+
+const repositoryRoot = process.cwd();
+const clientRoot = path.join(repositoryRoot, "build-framework", "client");
+const manifestPath = path.join(
+  repositoryRoot,
+  "shared",
+  "content",
+  "curriculumSeoManifest.generated.json"
+);
+const fallbackPath = path.join(clientRoot, "__spa-fallback.html");
+const notFoundPath = path.join(clientRoot, "404.html");
+const sitemapPath = path.join(clientRoot, "sitemap.xml");
+const robotsPath = path.join(clientRoot, "robots.txt");
+
+assert.ok(
+  fs.existsSync(clientRoot),
+  "Run npm run build:framework before finalizing framework output."
+);
+assert.ok(
+  fs.existsSync(fallbackPath),
+  "Framework output is missing __spa-fallback.html."
+);
+assert.ok(fs.existsSync(manifestPath), "The curriculum SEO manifest is missing.");
+
+const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+const sitemapPaths = buildSitemapPaths({
+  contentEntries: manifest.entries,
+  staticRoutes: staticSeoRoutes,
+});
+
+for (const pathname of sitemapPaths) {
+  assert.ok(
+    fs.existsSync(getRouteHtmlPath(pathname)),
+    `Cannot finalize sitemap because ${pathname} has no static HTML artifact.`
+  );
+}
+
+const sitemap = createSitemapXml(sitemapPaths);
+const robots = createRobotsTxt();
+const finalizedFallback = addNotFoundMetadata(
+  fs.readFileSync(fallbackPath, "utf8")
+);
+
+fs.writeFileSync(sitemapPath, sitemap, "utf8");
+fs.writeFileSync(robotsPath, robots, "utf8");
+fs.writeFileSync(fallbackPath, finalizedFallback, "utf8");
+fs.writeFileSync(notFoundPath, finalizedFallback, "utf8");
+
+console.log(
+  `Finalized framework output with ${sitemapPaths.length} sitemap URLs, ` +
+    "candidate robots.txt, and dedicated 404.html."
+);
+
+export function buildSitemapPaths({ contentEntries, staticRoutes }) {
+  assert.ok(Array.isArray(contentEntries), "Content entries must be an array.");
+  assert.ok(Array.isArray(staticRoutes), "Static routes must be an array.");
+
+  const paths = [
+    ...staticRoutes.filter((route) => route.sitemap).map((route) => route.path),
+    ...contentEntries.map((entry) => entry.canonicalPath),
+  ];
+  const uniquePaths = new Set(paths);
+
+  assert.equal(
+    uniquePaths.size,
+    paths.length,
+    "Sitemap paths must be unique."
+  );
+
+  for (const pathname of paths) {
+    assert.ok(
+      isCanonicalPath(pathname),
+      `Sitemap path "${pathname}" must be canonical and trailing-slash.`
+    );
+  }
+
+  return paths;
+}
+
+export function createSitemapXml(paths) {
+  const urlEntries = paths
+    .map(
+      (pathname) =>
+        `  <url>\n    <loc>${escapeXml(
+          `${SEO_SITE_ORIGIN}${pathname}`
+        )}</loc>\n  </url>`
+    )
+    .join("\n");
+
+  return (
+    '<?xml version="1.0" encoding="UTF-8"?>\n' +
+    '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n' +
+    `${urlEntries}\n` +
+    "</urlset>\n"
+  );
+}
+
+export function createRobotsTxt() {
+  return (
+    "User-agent: *\n" +
+    "Allow: /\n\n" +
+    `Sitemap: ${SEO_SITE_ORIGIN}/sitemap.xml\n`
+  );
+}
+
+export function addNotFoundMetadata(html) {
+  const startMarker = "<!-- framework-finalizer:not-found-head:start -->";
+  const endMarker = "<!-- framework-finalizer:not-found-head:end -->";
+  const managedBlockPattern = new RegExp(
+    `${escapeRegExp(startMarker)}[\\s\\S]*?${escapeRegExp(endMarker)}`,
+    "g"
+  );
+  const withoutManagedBlock = html.replace(managedBlockPattern, "");
+  const metadataBlock =
+    `${startMarker}` +
+    "<title>Page Not Found | DEV_NET_CORE</title>" +
+    '<meta name="description" content="The requested DEV_NET_CORE page could not be found."/>' +
+    '<meta name="robots" content="noindex,follow"/>' +
+    `${endMarker}`;
+
+  assert.ok(
+    withoutManagedBlock.includes("</head>"),
+    "Framework fallback output must contain a closing head tag."
+  );
+  assert.ok(
+    withoutManagedBlock.includes("404 - Page Not Found"),
+    "Framework fallback output must contain visible Not Found content."
+  );
+  assert.equal(
+    /<link\b[^>]*\brel=["']canonical["']/i.test(withoutManagedBlock),
+    false,
+    "Framework fallback must not contain a canonical link."
+  );
+  assert.equal(
+    withoutManagedBlock.includes('type="application/ld+json"'),
+    false,
+    "Framework fallback must not contain structured data."
+  );
+
+  return withoutManagedBlock.replace(
+    "</head>",
+    `${metadataBlock}</head>`
+  );
+}
+
+function getRouteHtmlPath(pathname) {
+  return pathname === "/"
+    ? path.join(clientRoot, "index.html")
+    : path.join(clientRoot, ...pathname.split("/").filter(Boolean), "index.html");
+}
+
+function isCanonicalPath(value) {
+  return (
+    value === "/" ||
+    (typeof value === "string" &&
+      /^\/(?:[a-z0-9]+(?:-[a-z0-9]+)*\/)+$/.test(value))
+  );
+}
+
+function escapeXml(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
diff --git a/scripts/framework-output-budgets.mjs b/scripts/framework-output-budgets.mjs
new file mode 100644
index 0000000..764eeb8
--- /dev/null
+++ b/scripts/framework-output-budgets.mjs
@@ -0,0 +1,7 @@
+export const frameworkOutputBudgets = Object.freeze({
+  maximumBuildDurationSeconds: 60,
+  maximumHtmlBytes: 512 * 1024,
+  maximumRouteCount: 250,
+  maximumRouteDataBytes: 100 * 1024,
+  maximumTotalBytes: 80 * 1024 * 1024,
+});
diff --git a/scripts/generate-curriculum-manifest.mjs b/scripts/generate-curriculum-manifest.mjs
index dcee7f8..fd30fb7 100644
--- a/scripts/generate-curriculum-manifest.mjs
+++ b/scripts/generate-curriculum-manifest.mjs
@@ -11,7 +11,16 @@ const outputPath = path.join(
   "contents",
   "curriculumManifest.generated.ts"
 );
+const seoOutputPath = path.join(
+  projectRoot,
+  "shared",
+  "content",
+  "curriculumSeoManifest.generated.json"
+);
 const outputRelativePath = toPosix(path.relative(projectRoot, outputPath));
+const seoOutputRelativePath = toPosix(
+  path.relative(projectRoot, seoOutputPath)
+);
 const v1ContentRoot = "/src/contents/v1/";
 
 const specialLabels = {
@@ -53,6 +62,7 @@ const markdownFiles = collectMarkdownFiles(contentRoot)
   .sort((left, right) => left.relativePath.localeCompare(right.relativePath));
 
 const usedTopicIds = new Set();
+const usedCanonicalPaths = new Map();
 const entries = markdownFiles.map(({ absolutePath, relativePath }) => {
   const markdown = fs.readFileSync(absolutePath, "utf8");
   const segments = relativePath.split("/");
@@ -80,6 +90,14 @@ const entries = markdownFiles.map(({ absolutePath, relativePath }) => {
     usedTopicIds,
     relativePath
   );
+  const customCanonicalPath = frontmatter.canonicalPath?.trim();
+  const customSeoDescription = frontmatter.seoDescription?.trim();
+  const customSeoTitle = frontmatter.seoTitle?.trim();
+  const canonicalPath = customCanonicalPath || `/content/${id}/`;
+
+  validateCanonicalPath(canonicalPath, relativePath);
+  registerCanonicalPath(canonicalPath, relativePath, usedCanonicalPaths);
+
   const physicalFolderSegments = segments.slice(0, -1);
   const folders = physicalFolderSegments.map((folderSegment, index) => {
     const folderPath = physicalFolderSegments.slice(0, index + 1).join("/");
@@ -97,6 +115,8 @@ const entries = markdownFiles.map(({ absolutePath, relativePath }) => {
   const questionLevelCounts = getQuestionLevelCounts(questions);
 
   return {
+    canonicalPath,
+    canonicalPathSource: customCanonicalPath ? "frontmatter" : "generated",
     category,
     contentPath: `${v1ContentRoot}${relativePath}`,
     folders,
@@ -108,6 +128,14 @@ const entries = markdownFiles.map(({ absolutePath, relativePath }) => {
     ),
     questionLevelCounts,
     sampleQuestions: getSampleQuestions(questions),
+    seoDescription:
+      customSeoDescription ||
+      `Learn ${subtopicTitle} for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.`,
+    seoDescriptionSource: customSeoDescription ? "frontmatter" : "fallback",
+    seoTitle:
+      customSeoTitle ||
+      `${subtopicTitle} Interview Questions | DEV_NET_CORE`,
+    seoTitleSource: customSeoTitle ? "frontmatter" : "fallback",
     subtopic: subtopicTitle,
     title: subtopicTitle,
     topic: topicTitle,
@@ -115,9 +143,30 @@ const entries = markdownFiles.map(({ absolutePath, relativePath }) => {
   };
 });
 
-const output = `// This file is generated by scripts/generate-curriculum-manifest.mjs.
+const missingSeoTitleCount = entries.filter(
+  (entry) => entry.seoTitleSource === "fallback"
+).length;
+const missingSeoDescriptionCount = entries.filter(
+  (entry) => entry.seoDescriptionSource === "fallback"
+).length;
+
+if (missingSeoTitleCount > 0 || missingSeoDescriptionCount > 0) {
+  console.warn(
+    "SEO metadata transition fallbacks are active: " +
+      `${missingSeoTitleCount} title(s), ` +
+      `${missingSeoDescriptionCount} description(s).`
+  );
+}
+
+const typescriptOutput = `// This file is generated by scripts/generate-curriculum-manifest.mjs.
 // Do not edit it by hand.
 
+export type CurriculumManifestCanonicalPathSource =
+  | "frontmatter"
+  | "generated";
+
+export type CurriculumManifestSeoTextSource = "fallback" | "frontmatter";
+
 export type CurriculumManifestFolder = {
   path: string;
   title: string;
@@ -137,6 +186,8 @@ export type CurriculumManifestSampleQuestion = {
 };
 
 export type CurriculumManifestEntry = {
+  canonicalPath: string;
+  canonicalPathSource: CurriculumManifestCanonicalPathSource;
   category: string;
   contentPath: string;
   folders: CurriculumManifestFolder[];
@@ -145,6 +196,10 @@ export type CurriculumManifestEntry = {
   questionCount: number;
   questionLevelCounts: CurriculumManifestQuestionLevelCount[];
   sampleQuestions: CurriculumManifestSampleQuestion[];
+  seoDescription: string;
+  seoDescriptionSource: CurriculumManifestSeoTextSource;
+  seoTitle: string;
+  seoTitleSource: CurriculumManifestSeoTextSource;
   subtopic: string;
   title: string;
   topic: string;
@@ -158,9 +213,37 @@ export const curriculumManifest: CurriculumManifestEntry[] = ${JSON.stringify(
 )};
 `;
 
+const seoOutput = `${JSON.stringify(
+  {
+    schemaVersion: 1,
+    entries: entries.map((entry) => ({
+      canonicalPath: entry.canonicalPath,
+      canonicalPathSource: entry.canonicalPathSource,
+      category: entry.category,
+      contentPath: entry.contentPath.replace(/^\/+/, ""),
+      id: entry.id,
+      seoDescription: entry.seoDescription,
+      seoDescriptionSource: entry.seoDescriptionSource,
+      seoTitle: entry.seoTitle,
+      seoTitleSource: entry.seoTitleSource,
+      subtopic: entry.subtopic,
+      title: entry.title,
+      topic: entry.topic,
+    })),
+  },
+  null,
+  2
+)}
+`;
+
 fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-fs.writeFileSync(outputPath, output);
+fs.writeFileSync(outputPath, typescriptOutput);
+fs.mkdirSync(path.dirname(seoOutputPath), { recursive: true });
+fs.writeFileSync(seoOutputPath, seoOutput);
 console.log(`Generated ${entries.length} curriculum entries in ${outputRelativePath}`);
+console.log(
+  `Generated ${entries.length} curriculum SEO entries in ${seoOutputRelativePath}`
+);
 
 function collectMarkdownFiles(directory) {
   if (!fs.existsSync(directory)) {
@@ -202,7 +285,10 @@ function parseMarkdownFrontmatter(markdown) {
       key === "id" ||
       key === "topic" ||
       key === "subtopic" ||
-      key === "category"
+      key === "category" ||
+      key === "seoTitle" ||
+      key === "seoDescription" ||
+      key === "canonicalPath"
     ) {
       frontmatter[key] = value;
     }
@@ -560,6 +646,46 @@ function getUniqueTopicId(requestedId, fallbackId, usedTopicIds, contentPath) {
   return uniqueId;
 }
 
+function validateCanonicalPath(canonicalPath, contentPath) {
+  if (!canonicalPath.startsWith("/")) {
+    throw new Error(
+      `Canonical path "${canonicalPath}" in ${contentPath} must start with "/".`
+    );
+  }
+
+  if (!canonicalPath.endsWith("/")) {
+    throw new Error(
+      `Canonical path "${canonicalPath}" in ${contentPath} must use a trailing slash.`
+    );
+  }
+
+  if (
+    canonicalPath.includes("?") ||
+    canonicalPath.includes("#") ||
+    canonicalPath.includes("\\") ||
+    canonicalPath.includes("//") ||
+    !/^\/content\/[a-z0-9][a-z0-9-]*\/$/.test(canonicalPath)
+  ) {
+    throw new Error(
+      `Canonical path "${canonicalPath}" in ${contentPath} must match ` +
+        '"/content/topic-slug/".'
+    );
+  }
+}
+
+function registerCanonicalPath(canonicalPath, contentPath, usedCanonicalPaths) {
+  const existingContentPath = usedCanonicalPaths.get(canonicalPath);
+
+  if (existingContentPath) {
+    throw new Error(
+      `Duplicate canonical path "${canonicalPath}" found in ` +
+        `${existingContentPath} and ${contentPath}.`
+    );
+  }
+
+  usedCanonicalPaths.set(canonicalPath, contentPath);
+}
+
 function slugify(value) {
   return (
     value
diff --git a/scripts/preview-framework.mjs b/scripts/preview-framework.mjs
new file mode 100644
index 0000000..12d7290
--- /dev/null
+++ b/scripts/preview-framework.mjs
@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+
+const clientRoot = path.resolve("build-framework", "client");
+const frameworkFallbackPath = path.join(clientRoot, "__spa-fallback.html");
+const notFoundPath = path.join(clientRoot, "404.html");
+const requestedPort = Number(process.env.PORT || process.argv[2] || 4176);
+const contentTypes = new Map([
+  [".css", "text/css; charset=utf-8"],
+  [".html", "text/html; charset=utf-8"],
+  [".ico", "image/x-icon"],
+  [".jpeg", "image/jpeg"],
+  [".jpg", "image/jpeg"],
+  [".js", "text/javascript; charset=utf-8"],
+  [".json", "application/json; charset=utf-8"],
+  [".png", "image/png"],
+  [".svg", "image/svg+xml"],
+  [".webp", "image/webp"],
+]);
+
+if (!fs.existsSync(frameworkFallbackPath)) {
+  throw new Error("Run npm run build:framework before previewing.");
+}
+
+const server = http.createServer((request, response) => {
+  const requestUrl = new URL(request.url || "/", "http://localhost");
+  const requestPath = decodeURIComponent(requestUrl.pathname);
+  const { filePath, statusCode } = resolveRequestPath(requestPath);
+
+  response.statusCode = statusCode;
+  response.setHeader(
+    "Content-Type",
+    contentTypes.get(path.extname(filePath).toLowerCase()) ||
+      "application/octet-stream"
+  );
+  fs.createReadStream(filePath).pipe(response);
+});
+
+server.listen(requestedPort, "127.0.0.1", () => {
+  console.log(`Framework preview: http://127.0.0.1:${requestedPort}`);
+});
+
+function resolveRequestPath(requestPath) {
+  const relativePath = requestPath.replace(/^\/+/, "");
+  const candidates = [
+    path.resolve(clientRoot, relativePath),
+    path.resolve(clientRoot, relativePath, "index.html"),
+  ];
+
+  for (const candidate of candidates) {
+    if (
+      isInsideClientRoot(candidate) &&
+      fs.existsSync(candidate) &&
+      fs.statSync(candidate).isFile()
+    ) {
+      return { filePath: candidate, statusCode: 200 };
+    }
+  }
+
+  const fallbackPath = fs.existsSync(notFoundPath)
+    ? notFoundPath
+    : frameworkFallbackPath;
+
+  return {
+    filePath: fallbackPath,
+    statusCode: fs.existsSync(notFoundPath) ? 404 : 200,
+  };
+}
+
+function isInsideClientRoot(candidate) {
+  const relativePath = path.relative(clientRoot, candidate);
+
+  return !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+}
diff --git a/scripts/theme-bootstrap.test.mjs b/scripts/theme-bootstrap.test.mjs
new file mode 100644
index 0000000..2e56d6a
--- /dev/null
+++ b/scripts/theme-bootstrap.test.mjs
@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import test from "node:test";
+import vm from "node:vm";
+
+const bootstrapSource = fs.readFileSync(
+  new URL("../public/theme-bootstrap.js", import.meta.url),
+  "utf8"
+);
+
+test("uses the stable dark default without a stored preference", () => {
+  const result = runBootstrap();
+
+  assert.equal(result.dataset.theme, "dark");
+  assert.deepEqual(result.classes, ["dark"]);
+  assert.equal(result.style.colorScheme, "dark");
+});
+
+test("restores an explicit light preference", () => {
+  const result = runBootstrap({ storedMode: "light" });
+
+  assert.equal(result.dataset.theme, "light");
+  assert.deepEqual(result.classes, ["light"]);
+  assert.equal(result.style.colorScheme, "light");
+});
+
+test("ignores invalid stored values", () => {
+  const result = runBootstrap({ storedMode: "system" });
+
+  assert.equal(result.dataset.theme, "dark");
+  assert.deepEqual(result.classes, ["dark"]);
+});
+
+test("keeps dark mode when browser storage is unavailable", () => {
+  const result = runBootstrap({ storageUnavailable: true });
+
+  assert.equal(result.dataset.theme, "dark");
+  assert.deepEqual(result.classes, ["dark"]);
+});
+
+function runBootstrap({
+  storedMode = null,
+  storageUnavailable = false,
+} = {}) {
+  const classes = new Set();
+  const root = {
+    classList: {
+      toggle(className, force) {
+        if (force) {
+          classes.add(className);
+        } else {
+          classes.delete(className);
+        }
+      },
+    },
+    dataset: {},
+    style: {},
+  };
+  const localStorage = {
+    getItem() {
+      if (storageUnavailable) {
+        throw new Error("Storage is unavailable.");
+      }
+
+      return storedMode;
+    },
+  };
+
+  vm.runInNewContext(bootstrapSource, {
+    document: { documentElement: root },
+    window: { localStorage },
+  });
+
+  return {
+    classes: [...classes].sort(),
+    dataset: root.dataset,
+    style: root.style,
+  };
+}
diff --git a/scripts/validate-framework-build.mjs b/scripts/validate-framework-build.mjs
new file mode 100644
index 0000000..37633fc
--- /dev/null
+++ b/scripts/validate-framework-build.mjs
@@ -0,0 +1,385 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import {
+  buildSeoMetadata,
+  SEO_SITE_ORIGIN,
+} from "../shared/seo/buildSeoMetadata.mjs";
+import { staticSeoRoutes } from "../shared/seo/seoRoutes.mjs";
+import { frameworkOutputBudgets } from "./framework-output-budgets.mjs";
+
+const repositoryRoot = process.cwd();
+const clientRoot = path.join(repositoryRoot, "build-framework", "client");
+const frameworkFallbackPath = path.join(clientRoot, "__spa-fallback.html");
+const notFoundPath = path.join(clientRoot, "404.html");
+const robotsPath = path.join(clientRoot, "robots.txt");
+const sitemapPath = path.join(clientRoot, "sitemap.xml");
+const manifest = JSON.parse(
+  fs.readFileSync(
+    path.join(
+      repositoryRoot,
+      "shared",
+      "content",
+      "curriculumSeoManifest.generated.json"
+    ),
+    "utf8"
+  )
+);
+const staticRoutes = staticSeoRoutes.filter((route) => route.sitemap);
+const expectedRoutes = [
+  ...staticRoutes.map((route) => ({
+    contentEntry: undefined,
+    pathname: route.path,
+  })),
+  ...manifest.entries.map((entry) => ({
+    contentEntry: entry,
+    pathname: entry.canonicalPath,
+  })),
+];
+
+const spaIndexPath = path.join(repositoryRoot, "dist", "index.html");
+
+assert.ok(fs.existsSync(spaIndexPath));
+assert.ok(fs.existsSync(frameworkFallbackPath));
+assert.ok(fs.existsSync(path.join(clientRoot, "theme-bootstrap.js")));
+assert.ok(fs.existsSync(path.join(repositoryRoot, "dist", "theme-bootstrap.js")));
+assert.ok(
+  fs.readFileSync(spaIndexPath, "utf8").includes(
+    '<script src="/theme-bootstrap.js"></script>'
+  ),
+  "The SPA output must load the static theme bootstrap."
+);
+assert.ok(
+  fs.readFileSync(frameworkFallbackPath, "utf8").includes(
+    '<script src="/theme-bootstrap.js"></script>'
+  ),
+  "The framework SPA fallback must load the static theme bootstrap."
+);
+assert.equal(
+  fs.existsSync(path.join(repositoryRoot, "build-framework", "server")),
+  false
+);
+
+validateFinalizedOutput();
+
+for (const route of expectedRoutes) {
+  validateRoute(route);
+}
+
+for (const routePath of [
+  "/bug-report/",
+  "/changelog/",
+  "/practice/",
+  "/simulation/",
+  "/simulation/setup/",
+]) {
+  assert.equal(
+    fs.existsSync(getRouteHtmlPath(routePath)),
+    false,
+    `${routePath} must remain SPA-only while it is excluded from the sitemap.`
+  );
+}
+
+const generatedIndexFiles = findFiles(clientRoot, "index.html");
+const generatedRouteDataFiles = findFiles(clientRoot, "_.data");
+const generatedClientFiles = findAllFiles(clientRoot);
+
+assert.equal(
+  generatedIndexFiles.length,
+  expectedRoutes.length,
+  "Framework output contains an unexpected number of static route artifacts."
+);
+
+validateOutputBudgets({
+  generatedClientFiles,
+  generatedIndexFiles,
+  generatedRouteDataFiles,
+});
+
+console.log(
+  `Validated ${expectedRoutes.length} framework route artifacts ` +
+    `(${manifest.entries.length} curriculum topics).`
+);
+
+function validateRoute({ contentEntry, pathname }) {
+  const htmlPath = getRouteHtmlPath(pathname);
+  const dataPath = getRouteDataPath(pathname);
+  const metadata = buildSeoMetadata({ contentEntry, pathname });
+
+  assert.ok(fs.existsSync(htmlPath), `Missing HTML artifact for ${pathname}.`);
+  if (pathname.startsWith("/content/")) {
+    assert.ok(fs.existsSync(dataPath), `Missing data artifact for ${pathname}.`);
+  }
+
+  const html = fs.readFileSync(htmlPath, "utf8");
+  const canonicalUrl = `${SEO_SITE_ORIGIN}${pathname}`;
+
+  assert.ok(
+    html.includes(`<title>${escapeHtml(metadata.title)}</title>`),
+    `Incorrect title for ${pathname}.`
+  );
+  assert.ok(
+    html.includes(
+      `<meta name="description" content="${escapeHtml(metadata.description)}"/>`
+    ),
+    `Incorrect description for ${pathname}.`
+  );
+  assert.ok(
+    html.includes('<meta name="robots" content="index,follow"/>'),
+    `Missing index directive for ${pathname}.`
+  );
+  assert.ok(
+    html.includes(`<link rel="canonical" href="${canonicalUrl}"/>`),
+    `Incorrect canonical URL for ${pathname}.`
+  );
+  assert.ok(
+    html.includes(`<meta property="og:url" content="${canonicalUrl}"/>`),
+    `Incorrect Open Graph URL for ${pathname}.`
+  );
+  assert.ok(
+    html.includes(
+      '<meta property="og:image" content="https://www.dev-net-core.com/og/default-og-image.png"/>'
+    ),
+    `Missing Open Graph image for ${pathname}.`
+  );
+  assert.ok(
+    html.includes("<h1"),
+    `Missing visible source HTML heading for ${pathname}.`
+  );
+  assert.ok(
+    html.includes('<script src="/theme-bootstrap.js"></script>'),
+    `Missing static theme bootstrap for ${pathname}.`
+  );
+  assert.equal(
+    html.includes("Loading content..."),
+    false,
+    `Static output for ${pathname} contains a loading placeholder.`
+  );
+
+  if (metadata.structuredData) {
+    assert.ok(
+      html.includes('data-dev-net-core-seo="structured-data"'),
+      `Missing structured data for ${pathname}.`
+    );
+  }
+
+  if (contentEntry) {
+    assert.ok(
+      html.includes(escapeHtml(contentEntry.subtopic)),
+      `Missing topic content for ${pathname}.`
+    );
+  }
+}
+
+function validateFinalizedOutput() {
+  assert.ok(fs.existsSync(sitemapPath), "Missing finalized sitemap.xml.");
+  assert.ok(fs.existsSync(robotsPath), "Missing finalized robots.txt.");
+  assert.ok(fs.existsSync(notFoundPath), "Missing dedicated 404.html.");
+
+  const sitemap = fs.readFileSync(sitemapPath, "utf8");
+  const robots = fs.readFileSync(robotsPath, "utf8");
+  const expectedUrls = expectedRoutes.map(
+    ({ pathname }) => `${SEO_SITE_ORIGIN}${pathname}`
+  );
+  const sitemapUrls = Array.from(
+    sitemap.matchAll(/<loc>([^<]+)<\/loc>/g),
+    (match) => match[1]
+  );
+
+  assert.ok(
+    sitemap.startsWith('<?xml version="1.0" encoding="UTF-8"?>'),
+    "Sitemap must declare UTF-8 XML."
+  );
+  assert.ok(
+    sitemap.includes(
+      '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">'
+    ),
+    "Sitemap must use the standard sitemap namespace."
+  );
+  assert.equal(sitemap.includes("<lastmod>"), false);
+  assert.equal(sitemap.includes("<priority>"), false);
+  assert.equal(sitemap.includes("<changefreq>"), false);
+  assert.equal(
+    new Set(sitemapUrls).size,
+    sitemapUrls.length,
+    "Sitemap URLs must be unique."
+  );
+  assert.deepEqual(
+    sitemapUrls,
+    expectedUrls,
+    "Sitemap URLs must exactly match the validated static route set."
+  );
+
+  for (const sitemapUrl of sitemapUrls) {
+    const url = new URL(sitemapUrl);
+
+    assert.equal(url.origin, SEO_SITE_ORIGIN);
+    assert.ok(
+      url.pathname === "/" || url.pathname.endsWith("/"),
+      `Sitemap URL ${sitemapUrl} must use a trailing slash.`
+    );
+    assert.ok(
+      fs.existsSync(getRouteHtmlPath(url.pathname)),
+      `Sitemap URL ${sitemapUrl} has no static HTML artifact.`
+    );
+  }
+
+  for (const excludedPath of [
+    "/bug-report/",
+    "/changelog/",
+    "/practice/",
+    "/simulation/",
+    "/simulation/setup/",
+  ]) {
+    assert.equal(
+      sitemapUrls.includes(`${SEO_SITE_ORIGIN}${excludedPath}`),
+      false,
+      `${excludedPath} must remain excluded from the sitemap.`
+    );
+  }
+
+  assert.ok(
+    robots.includes(`Sitemap: ${SEO_SITE_ORIGIN}/sitemap.xml`),
+    "Candidate robots.txt must advertise the finalized sitemap."
+  );
+  assert.equal(
+    fs
+      .readFileSync(
+        path.join(repositoryRoot, "public", "robots.txt"),
+        "utf8"
+      )
+      .includes("Sitemap:"),
+    false,
+    "The legacy SPA robots source must not advertise the candidate sitemap."
+  );
+
+  for (const artifactPath of [frameworkFallbackPath, notFoundPath]) {
+    const html = fs.readFileSync(artifactPath, "utf8");
+
+    assert.ok(html.includes("<title>Page Not Found | DEV_NET_CORE</title>"));
+    assert.ok(html.includes('<meta name="robots" content="noindex,follow"/>'));
+    assert.ok(html.includes("404 - Page Not Found"));
+    assert.ok(html.includes('<script src="/theme-bootstrap.js"></script>'));
+    assert.ok(html.includes("window.__reactRouterContext"));
+    assert.equal(
+      /<link\b[^>]*\brel=["']canonical["']/i.test(html),
+      false,
+      `${path.basename(artifactPath)} must not contain a canonical link.`
+    );
+    assert.equal(
+      html.includes('property="og:url"'),
+      false,
+      `${path.basename(artifactPath)} must not contain an Open Graph URL.`
+    );
+    assert.equal(
+      html.includes('type="application/ld+json"'),
+      false,
+      `${path.basename(artifactPath)} must not contain structured data.`
+    );
+  }
+
+  assert.notEqual(
+    fs.readFileSync(notFoundPath, "utf8"),
+    fs.readFileSync(path.join(clientRoot, "index.html"), "utf8"),
+    "Dedicated 404.html must not be a copy of the homepage."
+  );
+}
+
+function getRouteHtmlPath(pathname) {
+  return pathname === "/"
+    ? path.join(clientRoot, "index.html")
+    : path.join(clientRoot, ...pathname.split("/").filter(Boolean), "index.html");
+}
+
+function getRouteDataPath(pathname) {
+  return pathname === "/"
+    ? path.join(clientRoot, "_.data")
+    : path.join(clientRoot, ...pathname.split("/").filter(Boolean), "_.data");
+}
+
+function findFiles(directory, fileName) {
+  return fs.readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+    const entryPath = path.join(directory, entry.name);
+
+    if (entry.isDirectory()) {
+      return findFiles(entryPath, fileName);
+    }
+
+    return entry.name === fileName ? [entryPath] : [];
+  });
+}
+
+function findAllFiles(directory) {
+  return fs.readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+    const entryPath = path.join(directory, entry.name);
+
+    return entry.isDirectory() ? findAllFiles(entryPath) : [entryPath];
+  });
+}
+
+function validateOutputBudgets({
+  generatedClientFiles,
+  generatedIndexFiles,
+  generatedRouteDataFiles,
+}) {
+  const totalBytes = sumFileSizes(generatedClientFiles);
+  const largestHtmlBytes = maximumFileSize(generatedIndexFiles);
+  const largestRouteDataBytes = maximumFileSize(generatedRouteDataFiles);
+
+  assert.ok(
+    generatedIndexFiles.length <= frameworkOutputBudgets.maximumRouteCount,
+    `Framework route count ${generatedIndexFiles.length} exceeds the ` +
+      `${frameworkOutputBudgets.maximumRouteCount} route budget.`
+  );
+  assert.ok(
+    totalBytes <= frameworkOutputBudgets.maximumTotalBytes,
+    `Framework client output ${formatMiB(totalBytes)} exceeds the ` +
+      `${formatMiB(frameworkOutputBudgets.maximumTotalBytes)} budget.`
+  );
+  assert.ok(
+    largestHtmlBytes <= frameworkOutputBudgets.maximumHtmlBytes,
+    `Largest route HTML ${formatKiB(largestHtmlBytes)} exceeds the ` +
+      `${formatKiB(frameworkOutputBudgets.maximumHtmlBytes)} budget.`
+  );
+  assert.ok(
+    largestRouteDataBytes <= frameworkOutputBudgets.maximumRouteDataBytes,
+    `Largest route data ${formatKiB(largestRouteDataBytes)} exceeds the ` +
+      `${formatKiB(frameworkOutputBudgets.maximumRouteDataBytes)} budget.`
+  );
+
+  console.log(
+    "Framework output budgets: " +
+      `${generatedIndexFiles.length}/${frameworkOutputBudgets.maximumRouteCount} routes, ` +
+      `${formatMiB(totalBytes)}/${formatMiB(frameworkOutputBudgets.maximumTotalBytes)} total, ` +
+      `${formatKiB(largestHtmlBytes)}/${formatKiB(frameworkOutputBudgets.maximumHtmlBytes)} max HTML, ` +
+      `${formatKiB(largestRouteDataBytes)}/${formatKiB(frameworkOutputBudgets.maximumRouteDataBytes)} max route data.`
+  );
+}
+
+function sumFileSizes(files) {
+  return files.reduce((total, filePath) => total + fs.statSync(filePath).size, 0);
+}
+
+function maximumFileSize(files) {
+  return files.reduce(
+    (maximum, filePath) => Math.max(maximum, fs.statSync(filePath).size),
+    0
+  );
+}
+
+function formatKiB(bytes) {
+  return `${(bytes / 1024).toFixed(2)} KiB`;
+}
+
+function formatMiB(bytes) {
+  return `${(bytes / 1024 / 1024).toFixed(2)} MiB`;
+}
+
+function escapeHtml(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#x27;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;");
+}
diff --git a/shared/content/curriculumSeoManifest.generated.json b/shared/content/curriculumSeoManifest.generated.json
new file mode 100644
index 0000000..34cfa94
--- /dev/null
+++ b/shared/content/curriculumSeoManifest.generated.json
@@ -0,0 +1,3099 @@
+{
+  "schemaVersion": 1,
+  "entries": [
+    {
+      "canonicalPath": "/content/alert-rules-action-groups-and-incident-response-workflows/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/alert-rules-action-groups-and-incident-response-workflows.md",
+      "id": "alert-rules-action-groups-and-incident-response-workflows",
+      "seoDescription": "Learn Alert rules, action groups, and incident response workflows for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Alert rules, action groups, and incident response workflows Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Alert rules, action groups, and incident response workflows",
+      "title": "Alert rules, action groups, and incident response workflows",
+      "topic": "Monitoring, tracing, and incident response on Azure"
+    },
+    {
+      "canonicalPath": "/content/app-service-plans-paas-web-hosting-fit/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/app-service-plans-paas-web-hosting-fit.md",
+      "id": "app-service-plans-paas-web-hosting-fit",
+      "seoDescription": "Learn App Service plans and PaaS web hosting fit for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "App Service plans and PaaS web hosting fit Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "App Service plans and PaaS web hosting fit",
+      "title": "App Service plans and PaaS web hosting fit",
+      "topic": "Azure compute choices and hosting models"
+    },
+    {
+      "canonicalPath": "/content/application-gateway-and-waf-concepts/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/application-gateway-and-waf-concepts.md",
+      "id": "application-gateway-and-waf-concepts",
+      "seoDescription": "Learn Application Gateway and WAF concepts for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Application Gateway and WAF concepts Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Application Gateway and WAF concepts",
+      "title": "Application Gateway and WAF concepts",
+      "topic": "Networking, API edge, and secure connectivity"
+    },
+    {
+      "canonicalPath": "/content/application-insights-and-opentelemetry-aligned-observability/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/application-insights-and-opentelemetry-aligned-observability.md",
+      "id": "application-insights-and-opentelemetry-aligned-observability",
+      "seoDescription": "Learn Application Insights and OpenTelemetry-aligned observability for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Application Insights and OpenTelemetry-aligned observability Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Application Insights and OpenTelemetry-aligned observability",
+      "title": "Application Insights and OpenTelemetry-aligned observability",
+      "topic": "Monitoring, tracing, and incident response on Azure"
+    },
+    {
+      "canonicalPath": "/content/azure-api-management-and-policy-based-gateways/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/azure-api-management-and-policy-based-gateways.md",
+      "id": "azure-api-management-and-policy-based-gateways",
+      "seoDescription": "Learn Azure API Management and policy-based gateways for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Azure API Management and policy-based gateways Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Azure API Management and policy-based gateways",
+      "title": "Azure API Management and policy-based gateways",
+      "topic": "Networking, API edge, and secure connectivity"
+    },
+    {
+      "canonicalPath": "/content/azure-cache-for-redis-low-latency-reads-and-session-state-scenarios/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/azure-cache-for-redis-low-latency-reads-and-session-state-scenarios.md",
+      "id": "azure-cache-for-redis-low-latency-reads-and-session-state-scenarios",
+      "seoDescription": "Learn Azure Cache for Redis for low-latency reads and session/state scenarios for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Azure Cache for Redis for low-latency reads and session/state scenarios Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Azure Cache for Redis for low-latency reads and session/state scenarios",
+      "title": "Azure Cache for Redis for low-latency reads and session/state scenarios",
+      "topic": "Azure data, storage, and caching services"
+    },
+    {
+      "canonicalPath": "/content/azure-container-apps-for-containerized-apis-and-background-workloads/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/azure-container-apps-for-containerized-apis-and-background-workloads.md",
+      "id": "azure-container-apps-for-containerized-apis-and-background-workloads",
+      "seoDescription": "Learn Azure Container Apps for containerized APIs and background workloads for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Azure Container Apps for containerized APIs and background workloads Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Azure Container Apps for containerized APIs and background workloads",
+      "title": "Azure Container Apps for containerized APIs and background workloads",
+      "topic": "Azure compute choices and hosting models"
+    },
+    {
+      "canonicalPath": "/content/azure-functions-hosting-options-and-current-scale-guidance/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/azure-functions-hosting-options-and-current-scale-guidance.md",
+      "id": "azure-functions-hosting-options-and-current-scale-guidance",
+      "seoDescription": "Learn Azure Functions Hosting Options and Current Scale Guidance for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Azure Functions Hosting Options and Current Scale Guidance Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Azure Functions Hosting Options and Current Scale Guidance",
+      "title": "Azure Functions Hosting Options and Current Scale Guidance",
+      "topic": "Azure compute choices and hosting models"
+    },
+    {
+      "canonicalPath": "/content/azure-key-vault-for-secrets-certificates-and-connection-settings/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/azure-key-vault-for-secrets-certificates-and-connection-settings.md",
+      "id": "azure-key-vault-for-secrets-certificates-and-connection-settings",
+      "seoDescription": "Learn Azure Key Vault for secrets, certificates, and connection settings for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Azure Key Vault for secrets, certificates, and connection settings Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Azure Key Vault for secrets, certificates, and connection settings",
+      "title": "Azure Key Vault for secrets, certificates, and connection settings",
+      "topic": "Identity, secrets, and access control"
+    },
+    {
+      "canonicalPath": "/content/azure-sql-database-tiers-scaling-serverless-options-and-failover-groups/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/azure-sql-database-tiers-scaling-serverless-options-and-failover-groups.md",
+      "id": "azure-sql-database-tiers-scaling-serverless-options-and-failover-groups",
+      "seoDescription": "Learn Azure SQL Database tiers, scaling, serverless options, and failover groups for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Azure SQL Database tiers, scaling, serverless options, and failover groups Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Azure SQL Database tiers, scaling, serverless options, and failover groups",
+      "title": "Azure SQL Database tiers, scaling, serverless options, and failover groups",
+      "topic": "Azure data, storage, and caching services"
+    },
+    {
+      "canonicalPath": "/content/bicep-fundamentals-modules-and-reusable-environment-definitions/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/bicep-fundamentals-modules-and-reusable-environment-definitions.md",
+      "id": "bicep-fundamentals-modules-and-reusable-environment-definitions",
+      "seoDescription": "Learn Bicep fundamentals, modules, and reusable environment definitions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Bicep fundamentals, modules, and reusable environment definitions Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Bicep fundamentals, modules, and reusable environment definitions",
+      "title": "Bicep fundamentals, modules, and reusable environment definitions",
+      "topic": "Delivery, infrastructure as code, scaling, and cost control"
+    },
+    {
+      "canonicalPath": "/content/bindings-connection-configuration-dependency-injection-logging-and-local-development/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/bindings-connection-configuration-dependency-injection-logging-and-local-development.md",
+      "id": "bindings-connection-configuration-dependency-injection-logging-and-local-development",
+      "seoDescription": "Learn Bindings, connection configuration, dependency injection, logging, and local development for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Bindings, connection configuration, dependency injection, logging, and local development Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Bindings, connection configuration, dependency injection, logging, and local development",
+      "title": "Bindings, connection configuration, dependency injection, logging, and local development",
+      "topic": "Azure Functions and Durable Functions"
+    },
+    {
+      "canonicalPath": "/content/blob-storage-access-tiers-lifecycle-management-and-immutability/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/blob-storage-access-tiers-lifecycle-management-and-immutability.md",
+      "id": "blob-storage-access-tiers-lifecycle-management-and-immutability",
+      "seoDescription": "Learn Blob Storage, access tiers, lifecycle management, and immutability for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Blob Storage, access tiers, lifecycle management, and immutability Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Blob Storage, access tiers, lifecycle management, and immutability",
+      "title": "Blob Storage, access tiers, lifecycle management, and immutability",
+      "topic": "Azure data, storage, and caching services"
+    },
+    {
+      "canonicalPath": "/content/block-blobs-append-blobs-and-page-blobs/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/block-blobs-append-blobs-and-page-blobs.md",
+      "id": "block-blobs-append-blobs-and-page-blobs",
+      "seoDescription": "Learn Block blobs, append blobs, and page blobs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Block blobs, append blobs, and page blobs Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Block blobs, append blobs, and page blobs",
+      "title": "Block blobs, append blobs, and page blobs",
+      "topic": "Azure Blob Storage and file handling"
+    },
+    {
+      "canonicalPath": "/content/choosing-queues-vs-topics-vs-event-notifications/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/choosing-queues-vs-topics-vs-event-notifications.md",
+      "id": "choosing-queues-vs-topics-vs-event-notifications",
+      "seoDescription": "Learn Choosing queues vs topics vs event notifications for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Choosing queues vs topics vs event notifications Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Choosing queues vs topics vs event notifications",
+      "title": "Choosing queues vs topics vs event notifications",
+      "topic": "Messaging and event-driven Azure integration"
+    },
+    {
+      "canonicalPath": "/content/cold-starts-hosting-plan-choices-timeout-configuration-and-scaling-behavior/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/cold-starts-hosting-plan-choices-timeout-configuration-and-scaling-behavior.md",
+      "id": "cold-starts-hosting-plan-choices-timeout-configuration-and-scaling-behavior",
+      "seoDescription": "Learn Cold starts, hosting plan choices, timeout configuration, and scaling behavior for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Cold starts, hosting plan choices, timeout configuration, and scaling behavior Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Cold starts, hosting plan choices, timeout configuration, and scaling behavior",
+      "title": "Cold starts, hosting plan choices, timeout configuration, and scaling behavior",
+      "topic": "Azure Functions and Durable Functions"
+    },
+    {
+      "canonicalPath": "/content/deployment-slots-rollout-safety-autoscaling-availability-zones-and-cost-aware-tiering/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/deployment-slots-rollout-safety-autoscaling-availability-zones-and-cost-aware-tiering.md",
+      "id": "deployment-slots-rollout-safety-autoscaling-availability-zones-and-cost-aware-tiering",
+      "seoDescription": "Learn Deployment slots, rollout safety, autoscaling, availability zones, and cost-aware tiering for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Deployment slots, rollout safety, autoscaling, availability zones, and cost-aware tiering Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Deployment slots, rollout safety, autoscaling, availability zones, and cost-aware tiering",
+      "title": "Deployment slots, rollout safety, autoscaling, availability zones, and cost-aware tiering",
+      "topic": "Delivery, infrastructure as code, scaling, and cost control"
+    },
+    {
+      "canonicalPath": "/content/dotnet-blob-clients-direct-browser-upload-and-separating-metadata-from-binary-content/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/dotnet-blob-clients-direct-browser-upload-and-separating-metadata-from-binary-content.md",
+      "id": "dotnet-blob-clients-direct-browser-upload-and-separating-metadata-from-binary-content",
+      "seoDescription": "Learn .NET Blob clients, direct browser upload patterns, and storing metadata separately from binary content for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": ".NET Blob clients, direct browser upload patterns, and storing metadata separately from binary content Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": ".NET Blob clients, direct browser upload patterns, and storing metadata separately from binary content",
+      "title": ".NET Blob clients, direct browser upload patterns, and storing metadata separately from binary content",
+      "topic": "Azure Blob Storage and file handling"
+    },
+    {
+      "canonicalPath": "/content/duplicate-detection-retries-and-poison-message-handling/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/duplicate-detection-retries-and-poison-message-handling.md",
+      "id": "duplicate-detection-retries-and-poison-message-handling",
+      "seoDescription": "Learn Duplicate detection, retries, and poison-message handling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Duplicate detection, retries, and poison-message handling Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Duplicate detection, retries, and poison-message handling",
+      "title": "Duplicate detection, retries, and poison-message handling",
+      "topic": "Messaging and event-driven Azure integration"
+    },
+    {
+      "canonicalPath": "/content/durable-functions-orchestrators-activities-timers-external-events-and-entities/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/durable-functions-orchestrators-activities-timers-external-events-and-entities.md",
+      "id": "durable-functions-orchestrators-activities-timers-external-events-and-entities",
+      "seoDescription": "Learn Durable Functions orchestrators, activity functions, durable timers, external events, and durable entities for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Durable Functions orchestrators, activity functions, durable timers, external events, and durable entities Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Durable Functions orchestrators, activity functions, durable timers, external events, and durable entities",
+      "title": "Durable Functions orchestrators, activity functions, durable timers, external events, and durable entities",
+      "topic": "Azure Functions and Durable Functions"
+    },
+    {
+      "canonicalPath": "/content/event-grid-for-event-publication-and-fan-out/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/event-grid-for-event-publication-and-fan-out.md",
+      "id": "event-grid-for-event-publication-and-fan-out",
+      "seoDescription": "Learn Event Grid for event publication and fan-out for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Event Grid for event publication and fan-out Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Event Grid for event publication and fan-out",
+      "title": "Event Grid for event publication and fan-out",
+      "topic": "Messaging and event-driven Azure integration"
+    },
+    {
+      "canonicalPath": "/content/function-chaining-fan-out-fan-in-async-workflow-state-replay-and-compensation/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/function-chaining-fan-out-fan-in-async-workflow-state-replay-and-compensation.md",
+      "id": "function-chaining-fan-out-fan-in-async-workflow-state-replay-and-compensation",
+      "seoDescription": "Learn Function chaining, fan-out/fan-in, async workflow state, replay-safe orchestrator code, and compensation for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Function chaining, fan-out/fan-in, async workflow state, replay-safe orchestrator code, and compensation Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Function chaining, fan-out/fan-in, async workflow state, replay-safe orchestrator code, and compensation",
+      "title": "Function chaining, fan-out/fan-in, async workflow state, replay-safe orchestrator code, and compensation",
+      "topic": "Azure Functions and Durable Functions"
+    },
+    {
+      "canonicalPath": "/content/github-actions-or-azure-devops-for-build-test-deploy-and-infrastructure-steps/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/github-actions-or-azure-devops-for-build-test-deploy-and-infrastructure-steps.md",
+      "id": "github-actions-or-azure-devops-for-build-test-deploy-and-infrastructure-steps",
+      "seoDescription": "Learn GitHub Actions or Azure DevOps for build, test, deploy, and infrastructure steps for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "GitHub Actions or Azure DevOps for build, test, deploy, and infrastructure steps Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "GitHub Actions or Azure DevOps for build, test, deploy, and infrastructure steps",
+      "title": "GitHub Actions or Azure DevOps for build, test, deploy, and infrastructure steps",
+      "topic": "Delivery, infrastructure as code, scaling, and cost control"
+    },
+    {
+      "canonicalPath": "/content/http-timer-queue-service-bus-event-grid-and-blob-triggers/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/http-timer-queue-service-bus-event-grid-and-blob-triggers.md",
+      "id": "http-timer-queue-service-bus-event-grid-and-blob-triggers",
+      "seoDescription": "Learn HTTP, timer, queue, Service Bus, Event Grid, and Blob triggers for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "HTTP, timer, queue, Service Bus, Event Grid, and Blob triggers Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "HTTP, timer, queue, Service Bus, Event Grid, and Blob triggers",
+      "title": "HTTP, timer, queue, Service Bus, Event Grid, and Blob triggers",
+      "topic": "Azure Functions and Durable Functions"
+    },
+    {
+      "canonicalPath": "/content/in-process-vs-isolated-worker-model-for-dotnet-functions/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/in-process-vs-isolated-worker-model-for-dotnet-functions.md",
+      "id": "in-process-vs-isolated-worker-model-for-dotnet-functions",
+      "seoDescription": "Learn In-process vs isolated worker model for .NET Functions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "In-process vs isolated worker model for .NET Functions Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "In-process vs isolated worker model for .NET Functions",
+      "title": "In-process vs isolated worker model for .NET Functions",
+      "topic": "Azure Functions and Durable Functions"
+    },
+    {
+      "canonicalPath": "/content/large-file-uploads-block-upload-retries-checksums-and-resumable-patterns/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/large-file-uploads-block-upload-retries-checksums-and-resumable-patterns.md",
+      "id": "large-file-uploads-block-upload-retries-checksums-and-resumable-patterns",
+      "seoDescription": "Learn Large file uploads, block upload, retry behavior, checksums, and resumable upload patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Large file uploads, block upload, retry behavior, checksums, and resumable upload patterns Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Large file uploads, block upload, retry behavior, checksums, and resumable upload patterns",
+      "title": "Large file uploads, block upload, retry behavior, checksums, and resumable upload patterns",
+      "topic": "Azure Blob Storage and file handling"
+    },
+    {
+      "canonicalPath": "/content/lifecycle-management-soft-delete-versioning-immutability-encryption-and-retention/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/lifecycle-management-soft-delete-versioning-immutability-encryption-and-retention.md",
+      "id": "lifecycle-management-soft-delete-versioning-immutability-encryption-and-retention",
+      "seoDescription": "Learn Lifecycle management, soft delete, versioning, immutability, encryption, and retention for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Lifecycle management, soft delete, versioning, immutability, encryption, and retention Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Lifecycle management, soft delete, versioning, immutability, encryption, and retention",
+      "title": "Lifecycle management, soft delete, versioning, immutability, encryption, and retention",
+      "topic": "Azure Blob Storage and file handling"
+    },
+    {
+      "canonicalPath": "/content/log-analytics-queries-dashboards-and-availability-tests/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/log-analytics-queries-dashboards-and-availability-tests.md",
+      "id": "log-analytics-queries-dashboards-and-availability-tests",
+      "seoDescription": "Learn Log Analytics queries, dashboards, and availability tests for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Log Analytics queries, dashboards, and availability tests Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Log Analytics queries, dashboards, and availability tests",
+      "title": "Log Analytics queries, dashboards, and availability tests",
+      "topic": "Monitoring, tracing, and incident response on Azure"
+    },
+    {
+      "canonicalPath": "/content/matching-storage-choices-to-relational-object-and-cache-workloads/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/matching-storage-choices-to-relational-object-and-cache-workloads.md",
+      "id": "matching-storage-choices-to-relational-object-and-cache-workloads",
+      "seoDescription": "Learn Matching storage choices to relational, object, and cache workloads for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Matching storage choices to relational, object, and cache workloads Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Matching storage choices to relational, object, and cache workloads",
+      "title": "Matching storage choices to relational, object, and cache workloads",
+      "topic": "Azure data, storage, and caching services"
+    },
+    {
+      "canonicalPath": "/content/metrics-vs-logs-vs-traces/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/metrics-vs-logs-vs-traces.md",
+      "id": "metrics-vs-logs-vs-traces",
+      "seoDescription": "Learn Metrics vs logs vs traces for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Metrics vs logs vs traces Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Metrics vs logs vs traces",
+      "title": "Metrics vs logs vs traces",
+      "topic": "Monitoring, tracing, and incident response on Azure"
+    },
+    {
+      "canonicalPath": "/content/microsoft-entra-app-registrations-scopes-and-auth-code-flow-basics/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/microsoft-entra-app-registrations-scopes-and-auth-code-flow-basics.md",
+      "id": "microsoft-entra-app-registrations-scopes-and-auth-code-flow-basics",
+      "seoDescription": "Learn Microsoft Entra app registrations, scopes, and auth-code flow basics for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Microsoft Entra app registrations, scopes, and auth-code flow basics Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Microsoft Entra app registrations, scopes, and auth-code flow basics",
+      "title": "Microsoft Entra app registrations, scopes, and auth-code flow basics",
+      "topic": "Identity, secrets, and access control"
+    },
+    {
+      "canonicalPath": "/content/oidc-based-azure-authentication-in-pipelines/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/oidc-based-azure-authentication-in-pipelines.md",
+      "id": "oidc-based-azure-authentication-in-pipelines",
+      "seoDescription": "Learn OIDC-based Azure authentication in pipelines for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "OIDC-based Azure authentication in pipelines Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "OIDC-based Azure authentication in pipelines",
+      "title": "OIDC-based Azure authentication in pipelines",
+      "topic": "Delivery, infrastructure as code, scaling, and cost control"
+    },
+    {
+      "canonicalPath": "/content/rate-limiting-quotas-auth-offload-and-request-transformation-at-the-edge/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/rate-limiting-quotas-auth-offload-and-request-transformation-at-the-edge.md",
+      "id": "rate-limiting-quotas-auth-offload-and-request-transformation-at-the-edge",
+      "seoDescription": "Learn Rate limiting, quotas, auth offload, and request transformation at the edge for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Rate limiting, quotas, auth offload, and request transformation at the edge Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Rate limiting, quotas, auth offload, and request transformation at the edge",
+      "title": "Rate limiting, quotas, auth offload, and request transformation at the edge",
+      "topic": "Networking, API edge, and secure connectivity"
+    },
+    {
+      "canonicalPath": "/content/rbac-least-privilege-and-separating-human-vs-workload-identities/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/rbac-least-privilege-and-separating-human-vs-workload-identities.md",
+      "id": "rbac-least-privilege-and-separating-human-vs-workload-identities",
+      "seoDescription": "Learn RBAC, least privilege, and separating human vs workload identities for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "RBAC, least privilege, and separating human vs workload identities Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "RBAC, least privilege, and separating human vs workload identities",
+      "title": "RBAC, least privilege, and separating human vs workload identities",
+      "topic": "Identity, secrets, and access control"
+    },
+    {
+      "canonicalPath": "/content/service-bus-queues-topics-subscriptions-and-dead-letter-queues/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/service-bus-queues-topics-subscriptions-and-dead-letter-queues.md",
+      "id": "service-bus-queues-topics-subscriptions-and-dead-letter-queues",
+      "seoDescription": "Learn Service Bus queues, topics, subscriptions, and dead-letter queues for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Service Bus queues, topics, subscriptions, and dead-letter queues Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Service Bus queues, topics, subscriptions, and dead-letter queues",
+      "title": "Service Bus queues, topics, subscriptions, and dead-letter queues",
+      "topic": "Messaging and event-driven Azure integration"
+    },
+    {
+      "canonicalPath": "/content/service-tags-private-networking-and-reducing-public-attack-surface/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/service-tags-private-networking-and-reducing-public-attack-surface.md",
+      "id": "service-tags-private-networking-and-reducing-public-attack-surface",
+      "seoDescription": "Learn Service tags, private networking, and reducing public attack surface for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Service tags, private networking, and reducing public attack surface Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Service tags, private networking, and reducing public attack surface",
+      "title": "Service tags, private networking, and reducing public attack surface",
+      "topic": "Networking, API edge, and secure connectivity"
+    },
+    {
+      "canonicalPath": "/content/shared-access-signatures-managed-identity-rbac-stored-access-policies-and-public-access-risks/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/shared-access-signatures-managed-identity-rbac-stored-access-policies-and-public-access-risks.md",
+      "id": "shared-access-signatures-managed-identity-rbac-stored-access-policies-and-public-access-risks",
+      "seoDescription": "Learn Shared access signatures, managed identity, RBAC, stored access policies, and public access risks for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Shared access signatures, managed identity, RBAC, stored access policies, and public access risks Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Shared access signatures, managed identity, RBAC, stored access policies, and public access risks",
+      "title": "Shared access signatures, managed identity, RBAC, stored access policies, and public access risks",
+      "topic": "Azure Blob Storage and file handling"
+    },
+    {
+      "canonicalPath": "/content/storage-accounts-containers-blobs-virtual-folders-metadata-and-access-tiers/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/storage-accounts-containers-blobs-virtual-folders-metadata-and-access-tiers.md",
+      "id": "storage-accounts-containers-blobs-virtual-folders-metadata-and-access-tiers",
+      "seoDescription": "Learn Storage accounts, containers, blobs, virtual folders, metadata, and access tiers for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Storage accounts, containers, blobs, virtual folders, metadata, and access tiers Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Storage accounts, containers, blobs, virtual folders, metadata, and access tiers",
+      "title": "Storage accounts, containers, blobs, virtual folders, metadata, and access tiers",
+      "topic": "Azure Blob Storage and file handling"
+    },
+    {
+      "canonicalPath": "/content/system-assigned-and-user-assigned-managed-identities/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/system-assigned-and-user-assigned-managed-identities.md",
+      "id": "system-assigned-and-user-assigned-managed-identities",
+      "seoDescription": "Learn System-assigned and user-assigned managed identities for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "System-assigned and user-assigned managed identities Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "System-assigned and user-assigned managed identities",
+      "title": "System-assigned and user-assigned managed identities",
+      "topic": "Identity, secrets, and access control"
+    },
+    {
+      "canonicalPath": "/content/trade-offs-among-simplicity-portability-autoscaling-and-operational-control/",
+      "canonicalPathSource": "generated",
+      "category": "Azure",
+      "contentPath": "src/contents/v1/Azure/trade-offs-among-simplicity-portability-autoscaling-and-operational-control.md",
+      "id": "trade-offs-among-simplicity-portability-autoscaling-and-operational-control",
+      "seoDescription": "Learn Trade-offs among simplicity, portability, autoscaling, and operational control for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Trade-offs among simplicity, portability, autoscaling, and operational control Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Trade-offs among simplicity, portability, autoscaling, and operational control",
+      "title": "Trade-offs among simplicity, portability, autoscaling, and operational control",
+      "topic": "Azure compute choices and hosting models"
+    },
+    {
+      "canonicalPath": "/content/adrs-coding-conventions-and-team-level-design-communication/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/adrs-coding-conventions-and-team-level-design-communication.md",
+      "id": "adrs-coding-conventions-and-team-level-design-communication",
+      "seoDescription": "Learn ADRs, coding conventions, and team-level design communication for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "ADRs, coding conventions, and team-level design communication Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "ADRs, coding conventions, and team-level design communication",
+      "title": "ADRs, coding conventions, and team-level design communication",
+      "topic": "Testing strategy, maintainability, and technical leadership"
+    },
+    {
+      "canonicalPath": "/content/api-gateway-and-bff-decisions-for-web-clients-and-microservices/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/api-gateway-and-bff-decisions-for-web-clients-and-microservices.md",
+      "id": "api-gateway-and-bff-decisions-for-web-clients-and-microservices",
+      "seoDescription": "Learn API gateway and BFF decisions for web clients and microservices for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "API gateway and BFF decisions for web clients and microservices Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "API gateway and BFF decisions for web clients and microservices",
+      "title": "API gateway and BFF decisions for web clients and microservices",
+      "topic": "API design and integration contracts"
+    },
+    {
+      "canonicalPath": "/content/assumptions-constraints-risks-failure-modes/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/assumptions-constraints-risks-failure-modes.md",
+      "id": "assumptions-constraints-risks-failure-modes",
+      "seoDescription": "Learn Assumptions, constraints, risks, and failure modes for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Assumptions, constraints, risks, and failure modes Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Assumptions, constraints, risks, and failure modes",
+      "title": "Assumptions, constraints, risks, and failure modes",
+      "topic": "Requirements decomposition and system trade-offs"
+    },
+    {
+      "canonicalPath": "/content/cache-aside-read-caching-and-invalidation-trade-offs/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/cache-aside-read-caching-and-invalidation-trade-offs.md",
+      "id": "cache-aside-read-caching-and-invalidation-trade-offs",
+      "seoDescription": "Learn Cache-aside, read caching, and invalidation trade-offs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Cache-aside, read caching, and invalidation trade-offs Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Cache-aside, read caching, and invalidation trade-offs",
+      "title": "Cache-aside, read caching, and invalidation trade-offs",
+      "topic": "Scalability, resilience, caching, and observability design"
+    },
+    {
+      "canonicalPath": "/content/capacity-planning-and-identifying-likely-bottlenecks/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/capacity-planning-and-identifying-likely-bottlenecks.md",
+      "id": "capacity-planning-and-identifying-likely-bottlenecks",
+      "seoDescription": "Learn Capacity Planning and Identifying Likely Bottlenecks for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Capacity Planning and Identifying Likely Bottlenecks Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Capacity Planning and Identifying Likely Bottlenecks",
+      "title": "Capacity Planning and Identifying Likely Bottlenecks",
+      "topic": "Requirements decomposition and system trade-offs"
+    },
+    {
+      "canonicalPath": "/content/command-injection-file-upload-risks-path-traversal-secrets-exposure-and-dos-ddos-basics/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/command-injection-file-upload-risks-path-traversal-secrets-exposure-and-dos-ddos-basics.md",
+      "id": "command-injection-file-upload-risks-path-traversal-secrets-exposure-and-dos-ddos-basics",
+      "seoDescription": "Learn Command injection, file upload risks, path traversal, secrets exposure, and DoS/DDoS basics for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Command injection, file upload risks, path traversal, secrets exposure, and DoS/DDoS basics Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Command injection, file upload risks, path traversal, secrets exposure, and DoS/DDoS basics",
+      "title": "Command injection, file upload risks, path traversal, secrets exposure, and DoS/DDoS basics",
+      "topic": "Web application security threat modeling and attack patterns"
+    },
+    {
+      "canonicalPath": "/content/correlation-ids-traces-health-checks-and-alertable-telemetry/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/correlation-ids-traces-health-checks-and-alertable-telemetry.md",
+      "id": "correlation-ids-traces-health-checks-and-alertable-telemetry",
+      "seoDescription": "Learn Correlation IDs, traces, health checks, and alertable telemetry for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Correlation IDs, traces, health checks, and alertable telemetry Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Correlation IDs, traces, health checks, and alertable telemetry",
+      "title": "Correlation IDs, traces, health checks, and alertable telemetry",
+      "topic": "Scalability, resilience, caching, and observability design"
+    },
+    {
+      "canonicalPath": "/content/cqrs-and-when-separate-read-and-write-models-make-sense/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/cqrs-and-when-separate-read-and-write-models-make-sense.md",
+      "id": "cqrs-and-when-separate-read-and-write-models-make-sense",
+      "seoDescription": "Learn CQRS and when separate read and write models make sense for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "CQRS and when separate read and write models make sense Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "CQRS and when separate read and write models make sense",
+      "title": "CQRS and when separate read and write models make sense",
+      "topic": "Distributed systems patterns"
+    },
+    {
+      "canonicalPath": "/content/cross-site-request-forgery-and-cookie-based-authentication/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/cross-site-request-forgery-and-cookie-based-authentication.md",
+      "id": "cross-site-request-forgery-and-cookie-based-authentication",
+      "seoDescription": "Learn Cross-Site Request Forgery and how cookie-based authentication changes the risk model for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Cross-Site Request Forgery and how cookie-based authentication changes the risk model Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Cross-Site Request Forgery and how cookie-based authentication changes the risk model",
+      "title": "Cross-Site Request Forgery and how cookie-based authentication changes the risk model",
+      "topic": "Web application security threat modeling and attack patterns"
+    },
+    {
+      "canonicalPath": "/content/cross-site-scripting-output-encoding-dangerous-html-rendering-and-content-security/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/cross-site-scripting-output-encoding-dangerous-html-rendering-and-content-security.md",
+      "id": "cross-site-scripting-output-encoding-dangerous-html-rendering-and-content-security",
+      "seoDescription": "Learn Cross-Site Scripting, output encoding, dangerous HTML rendering, and content security controls for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Cross-Site Scripting, output encoding, dangerous HTML rendering, and content security controls Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Cross-Site Scripting, output encoding, dangerous HTML rendering, and content security controls",
+      "title": "Cross-Site Scripting, output encoding, dangerous HTML rendering, and content security controls",
+      "topic": "Web application security threat modeling and attack patterns"
+    },
+    {
+      "canonicalPath": "/content/dependency-inversion-and-inward-facing-dependencies/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/dependency-inversion-and-inward-facing-dependencies.md",
+      "id": "dependency-inversion-and-inward-facing-dependencies",
+      "seoDescription": "Learn Dependency inversion and inward-facing dependencies for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Dependency inversion and inward-facing dependencies Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Dependency inversion and inward-facing dependencies",
+      "title": "Dependency inversion and inward-facing dependencies",
+      "topic": "Clean Architecture and modular boundaries"
+    },
+    {
+      "canonicalPath": "/content/domain-services-and-domain-events/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/domain-services-and-domain-events.md",
+      "id": "domain-services-and-domain-events",
+      "seoDescription": "Learn Domain services and domain events for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Domain services and domain events Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Domain services and domain events",
+      "title": "Domain services and domain events",
+      "topic": "Domain modeling and Domain-Driven Design"
+    },
+    {
+      "canonicalPath": "/content/entities-value-objects-aggregates-and-invariants/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/entities-value-objects-aggregates-and-invariants.md",
+      "id": "entities-value-objects-aggregates-and-invariants",
+      "seoDescription": "Learn Entities, value objects, aggregates, and invariants for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Entities, value objects, aggregates, and invariants Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Entities, value objects, aggregates, and invariants",
+      "title": "Entities, value objects, aggregates, and invariants",
+      "topic": "Domain modeling and Domain-Driven Design"
+    },
+    {
+      "canonicalPath": "/content/event-driven-communication-and-asynchronous-request-reply/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/event-driven-communication-and-asynchronous-request-reply.md",
+      "id": "event-driven-communication-and-asynchronous-request-reply",
+      "seoDescription": "Learn Event-driven communication and asynchronous request-reply for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Event-driven communication and asynchronous request-reply Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Event-driven communication and asynchronous request-reply",
+      "title": "Event-driven communication and asynchronous request-reply",
+      "topic": "Distributed systems patterns"
+    },
+    {
+      "canonicalPath": "/content/factory-builder-strategy-adapter-decorator-facade-proxy-and-chain-of-responsibility/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/factory-builder-strategy-adapter-decorator-facade-proxy-and-chain-of-responsibility.md",
+      "id": "factory-builder-strategy-adapter-decorator-facade-proxy-and-chain-of-responsibility",
+      "seoDescription": "Learn Factory, Builder, Strategy, Adapter, Decorator, Facade, Proxy, and Chain of Responsibility for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Factory, Builder, Strategy, Adapter, Decorator, Facade, Proxy, and Chain of Responsibility Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Factory, Builder, Strategy, Adapter, Decorator, Facade, Proxy, and Chain of Responsibility",
+      "title": "Factory, Builder, Strategy, Adapter, Decorator, Facade, Proxy, and Chain of Responsibility",
+      "topic": "Software design principles and common .NET patterns"
+    },
+    {
+      "canonicalPath": "/content/functional-requirements-vs-nonfunctional-requirements/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/functional-requirements-vs-nonfunctional-requirements.md",
+      "id": "functional-requirements-vs-nonfunctional-requirements",
+      "seoDescription": "Learn Functional Requirements vs Nonfunctional Requirements for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Functional Requirements vs Nonfunctional Requirements Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Functional Requirements vs Nonfunctional Requirements",
+      "title": "Functional Requirements vs Nonfunctional Requirements",
+      "topic": "Requirements decomposition and system trade-offs"
+    },
+    {
+      "canonicalPath": "/content/horizontal-scaling-stateless-services-and-backpressure/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/horizontal-scaling-stateless-services-and-backpressure.md",
+      "id": "horizontal-scaling-stateless-services-and-backpressure",
+      "seoDescription": "Learn Horizontal scaling, stateless services, and backpressure for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Horizontal scaling, stateless services, and backpressure Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Horizontal scaling, stateless services, and backpressure",
+      "title": "Horizontal scaling, stateless services, and backpressure",
+      "topic": "Scalability, resilience, caching, and observability design"
+    },
+    {
+      "canonicalPath": "/content/idempotent-consumers-and-duplicate-message-handling/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/idempotent-consumers-and-duplicate-message-handling.md",
+      "id": "idempotent-consumers-and-duplicate-message-handling",
+      "seoDescription": "Learn Idempotent consumers and duplicate-message handling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Idempotent consumers and duplicate-message handling Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Idempotent consumers and duplicate-message handling",
+      "title": "Idempotent consumers and duplicate-message handling",
+      "topic": "Distributed systems patterns"
+    },
+    {
+      "canonicalPath": "/content/insecure-direct-object-reference-broken-access-control-and-object-level-authorization/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/insecure-direct-object-reference-broken-access-control-and-object-level-authorization.md",
+      "id": "insecure-direct-object-reference-broken-access-control-and-object-level-authorization",
+      "seoDescription": "Learn Insecure Direct Object Reference, broken access control, and object-level authorization for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Insecure Direct Object Reference, broken access control, and object-level authorization Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Insecure Direct Object Reference, broken access control, and object-level authorization",
+      "title": "Insecure Direct Object Reference, broken access control, and object-level authorization",
+      "topic": "Web application security threat modeling and attack patterns"
+    },
+    {
+      "canonicalPath": "/content/kiss-dry-yagni-separation-of-concerns-cohesion-and-coupling/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/kiss-dry-yagni-separation-of-concerns-cohesion-and-coupling.md",
+      "id": "kiss-dry-yagni-separation-of-concerns-cohesion-and-coupling",
+      "seoDescription": "Learn KISS, DRY, YAGNI, Separation of Concerns, Cohesion, and Coupling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "KISS, DRY, YAGNI, Separation of Concerns, Cohesion, and Coupling Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "KISS, DRY, YAGNI, Separation of Concerns, Cohesion, and Coupling",
+      "title": "KISS, DRY, YAGNI, Separation of Concerns, Cohesion, and Coupling",
+      "topic": "Software design principles and common .NET patterns"
+    },
+    {
+      "canonicalPath": "/content/layered-architecture-vs-clean-architecture-vs-ports-and-adapters/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/layered-architecture-vs-clean-architecture-vs-ports-and-adapters.md",
+      "id": "layered-architecture-vs-clean-architecture-vs-ports-and-adapters",
+      "seoDescription": "Learn Layered architecture vs Clean Architecture vs ports-and-adapters for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Layered architecture vs Clean Architecture vs ports-and-adapters Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Layered architecture vs Clean Architecture vs ports-and-adapters",
+      "title": "Layered architecture vs Clean Architecture vs ports-and-adapters",
+      "topic": "Clean Architecture and modular boundaries"
+    },
+    {
+      "canonicalPath": "/content/mapping-domain-models-to-persistence-without-corrupting-the-model/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/mapping-domain-models-to-persistence-without-corrupting-the-model.md",
+      "id": "mapping-domain-models-to-persistence-without-corrupting-the-model",
+      "seoDescription": "Learn Mapping domain models to persistence without corrupting the model for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Mapping domain models to persistence without corrupting the model Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Mapping domain models to persistence without corrupting the model",
+      "title": "Mapping domain models to persistence without corrupting the model",
+      "topic": "Domain modeling and Domain-Driven Design"
+    },
+    {
+      "canonicalPath": "/content/mentoring-ownership-and-incremental-modernization/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/mentoring-ownership-and-incremental-modernization.md",
+      "id": "mentoring-ownership-and-incremental-modernization",
+      "seoDescription": "Learn Mentoring, ownership, and incremental modernization for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Mentoring, ownership, and incremental modernization Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Mentoring, ownership, and incremental modernization",
+      "title": "Mentoring, ownership, and incremental modernization",
+      "topic": "Testing strategy, maintainability, and technical leadership"
+    },
+    {
+      "canonicalPath": "/content/modular-monolith-structure-and-feature-based-organization/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/modular-monolith-structure-and-feature-based-organization.md",
+      "id": "modular-monolith-structure-and-feature-based-organization",
+      "seoDescription": "Learn Modular monolith structure and feature-based organization for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Modular monolith structure and feature-based organization Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Modular monolith structure and feature-based organization",
+      "title": "Modular monolith structure and feature-based organization",
+      "topic": "Clean Architecture and modular boundaries"
+    },
+    {
+      "canonicalPath": "/content/openapi-contracts-and-consumer-facing-documentation/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/openapi-contracts-and-consumer-facing-documentation.md",
+      "id": "openapi-contracts-and-consumer-facing-documentation",
+      "seoDescription": "Learn OpenAPI contracts and consumer-facing documentation for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "OpenAPI contracts and consumer-facing documentation Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "OpenAPI contracts and consumer-facing documentation",
+      "title": "OpenAPI contracts and consumer-facing documentation",
+      "topic": "API design and integration contracts"
+    },
+    {
+      "canonicalPath": "/content/recognizing-when-a-pattern-improves-maintainability-vs-when-it-adds-unnecessary-complexity/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/recognizing-when-a-pattern-improves-maintainability-vs-when-it-adds-unnecessary-complexity.md",
+      "id": "recognizing-when-a-pattern-improves-maintainability-vs-when-it-adds-unnecessary-complexity",
+      "seoDescription": "Learn Recognizing when a pattern improves maintainability vs when it adds unnecessary complexity for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Recognizing when a pattern improves maintainability vs when it adds unnecessary complexity Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Recognizing when a pattern improves maintainability vs when it adds unnecessary complexity",
+      "title": "Recognizing when a pattern improves maintainability vs when it adds unnecessary complexity",
+      "topic": "Software design principles and common .NET patterns"
+    },
+    {
+      "canonicalPath": "/content/refactoring-strategy-code-review-standards-and-technical-debt-management/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/refactoring-strategy-code-review-standards-and-technical-debt-management.md",
+      "id": "refactoring-strategy-code-review-standards-and-technical-debt-management",
+      "seoDescription": "Learn Refactoring strategy, code review standards, and technical debt management for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Refactoring strategy, code review standards, and technical debt management Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Refactoring strategy, code review standards, and technical debt management",
+      "title": "Refactoring strategy, code review standards, and technical debt management",
+      "topic": "Testing strategy, maintainability, and technical leadership"
+    },
+    {
+      "canonicalPath": "/content/repository-unit-of-work-mediator-specification-dotnet-patterns/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/repository-unit-of-work-mediator-specification-dotnet-patterns.md",
+      "id": "repository-unit-of-work-mediator-specification-dotnet-patterns",
+      "seoDescription": "Learn Repository, Unit of Work, Mediator, and Specification Patterns in .NET for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Repository, Unit of Work, Mediator, and Specification Patterns in .NET Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Repository, Unit of Work, Mediator, and Specification Patterns in .NET",
+      "title": "Repository, Unit of Work, Mediator, and Specification Patterns in .NET",
+      "topic": "Software design principles and common .NET patterns"
+    },
+    {
+      "canonicalPath": "/content/resource-modeling-rest-semantics-and-rpc-style-endpoints/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/resource-modeling-rest-semantics-and-rpc-style-endpoints.md",
+      "id": "resource-modeling-rest-semantics-and-rpc-style-endpoints",
+      "seoDescription": "Learn Resource modeling, REST semantics, and when RPC-style endpoints are acceptable for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Resource modeling, REST semantics, and when RPC-style endpoints are acceptable Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Resource modeling, REST semantics, and when RPC-style endpoints are acceptable",
+      "title": "Resource modeling, REST semantics, and when RPC-style endpoints are acceptable",
+      "topic": "API design and integration contracts"
+    },
+    {
+      "canonicalPath": "/content/retry-circuit-breaker-bulkhead-and-queue-based-load-leveling/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/retry-circuit-breaker-bulkhead-and-queue-based-load-leveling.md",
+      "id": "retry-circuit-breaker-bulkhead-and-queue-based-load-leveling",
+      "seoDescription": "Learn Retry, circuit breaker, bulkhead, and queue-based load leveling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Retry, circuit breaker, bulkhead, and queue-based load leveling Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Retry, circuit breaker, bulkhead, and queue-based load leveling",
+      "title": "Retry, circuit breaker, bulkhead, and queue-based load leveling",
+      "topic": "Scalability, resilience, caching, and observability design"
+    },
+    {
+      "canonicalPath": "/content/saga-and-compensating-transaction-patterns/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/saga-and-compensating-transaction-patterns.md",
+      "id": "saga-and-compensating-transaction-patterns",
+      "seoDescription": "Learn Saga and compensating transaction patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Saga and compensating transaction patterns Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Saga and compensating transaction patterns",
+      "title": "Saga and compensating transaction patterns",
+      "topic": "Distributed systems patterns"
+    },
+    {
+      "canonicalPath": "/content/session-hijacking-credential-stuffing-brute-force-protection-lockout-and-multi-factor-authentication/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/session-hijacking-credential-stuffing-brute-force-protection-lockout-and-multi-factor-authentication.md",
+      "id": "session-hijacking-credential-stuffing-brute-force-protection-lockout-and-multi-factor-authentication",
+      "seoDescription": "Learn Session hijacking, credential stuffing, brute-force protection, lockout, and multi-factor authentication for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Session hijacking, credential stuffing, brute-force protection, lockout, and multi-factor authentication Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Session hijacking, credential stuffing, brute-force protection, lockout, and multi-factor authentication",
+      "title": "Session hijacking, credential stuffing, brute-force protection, lockout, and multi-factor authentication",
+      "topic": "Web application security threat modeling and attack patterns"
+    },
+    {
+      "canonicalPath": "/content/solid-principles-in-dotnet-design/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/solid-principles-in-dotnet-design.md",
+      "id": "solid-principles-in-dotnet-design",
+      "seoDescription": "Learn SOLID Principles in .NET Design for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "SOLID Principles in .NET Design Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "SOLID Principles in .NET Design",
+      "title": "SOLID Principles in .NET Design",
+      "topic": "Software design principles and common .NET patterns"
+    },
+    {
+      "canonicalPath": "/content/sql-injection-parameterized-queries-orm-safety-and-unsafe-dynamic-sql/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/sql-injection-parameterized-queries-orm-safety-and-unsafe-dynamic-sql.md",
+      "id": "sql-injection-parameterized-queries-orm-safety-and-unsafe-dynamic-sql",
+      "seoDescription": "Learn SQL Injection, parameterized queries, ORM safety, and unsafe dynamic SQL for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "SQL Injection, parameterized queries, ORM safety, and unsafe dynamic SQL Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "SQL Injection, parameterized queries, ORM safety, and unsafe dynamic SQL",
+      "title": "SQL Injection, parameterized queries, ORM safety, and unsafe dynamic SQL",
+      "topic": "Web application security threat modeling and attack patterns"
+    },
+    {
+      "canonicalPath": "/content/test-pyramid-contract-tests-and-architecture-fitness-checks/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/test-pyramid-contract-tests-and-architecture-fitness-checks.md",
+      "id": "test-pyramid-contract-tests-and-architecture-fitness-checks",
+      "seoDescription": "Learn Test pyramid, contract tests, and architecture fitness checks for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Test pyramid, contract tests, and architecture fitness checks Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Test pyramid, contract tests, and architecture fitness checks",
+      "title": "Test pyramid, contract tests, and architecture fitness checks",
+      "topic": "Testing strategy, maintainability, and technical leadership"
+    },
+    {
+      "canonicalPath": "/content/threat-modeling-user-input-trust-boundaries-authentication-flows-and-admin-only-operations/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/threat-modeling-user-input-trust-boundaries-authentication-flows-and-admin-only-operations.md",
+      "id": "threat-modeling-user-input-trust-boundaries-authentication-flows-and-admin-only-operations",
+      "seoDescription": "Learn Threat modeling user input, trust boundaries, authentication flows, and admin-only operations for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Threat modeling user input, trust boundaries, authentication flows, and admin-only operations Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Threat modeling user input, trust boundaries, authentication flows, and admin-only operations",
+      "title": "Threat modeling user input, trust boundaries, authentication flows, and admin-only operations",
+      "topic": "Web application security threat modeling and attack patterns"
+    },
+    {
+      "canonicalPath": "/content/throughput-latency-concurrency-availability-consistency-cost-targets/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/throughput-latency-concurrency-availability-consistency-cost-targets.md",
+      "id": "throughput-latency-concurrency-availability-consistency-cost-targets",
+      "seoDescription": "Learn Throughput, latency, concurrency, availability, consistency, and cost targets for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Throughput, latency, concurrency, availability, consistency, and cost targets Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Throughput, latency, concurrency, availability, consistency, and cost targets",
+      "title": "Throughput, latency, concurrency, availability, consistency, and cost targets",
+      "topic": "Requirements decomposition and system trade-offs"
+    },
+    {
+      "canonicalPath": "/content/ubiquitous-language-and-bounded-contexts/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/ubiquitous-language-and-bounded-contexts.md",
+      "id": "ubiquitous-language-and-bounded-contexts",
+      "seoDescription": "Learn Ubiquitous language and bounded contexts for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Ubiquitous language and bounded contexts Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Ubiquitous language and bounded contexts",
+      "title": "Ubiquitous language and bounded contexts",
+      "topic": "Domain modeling and Domain-Driven Design"
+    },
+    {
+      "canonicalPath": "/content/versioning-idempotency-pagination-filtering-and-sorting/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/versioning-idempotency-pagination-filtering-and-sorting.md",
+      "id": "versioning-idempotency-pagination-filtering-and-sorting",
+      "seoDescription": "Learn Versioning, idempotency, pagination, filtering, and sorting for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Versioning, idempotency, pagination, filtering, and sorting Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Versioning, idempotency, pagination, filtering, and sorting",
+      "title": "Versioning, idempotency, pagination, filtering, and sorting",
+      "topic": "API design and integration contracts"
+    },
+    {
+      "canonicalPath": "/content/when-not-to-over-architect-a-simple-application/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/Design & Architecture/when-not-to-over-architect-a-simple-application.md",
+      "id": "when-not-to-over-architect-a-simple-application",
+      "seoDescription": "Learn When not to over-architect a simple application for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "When not to over-architect a simple application Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "When not to over-architect a simple application",
+      "title": "When not to over-architect a simple application",
+      "topic": "Clean Architecture and modular boundaries"
+    },
+    {
+      "canonicalPath": "/content/api-controller-behavior-automatic-model-validation-binding-source-inference-and-validation-responses/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/api-controller-behavior-automatic-model-validation-binding-source-inference-and-validation-responses.md",
+      "id": "api-controller-behavior-automatic-model-validation-binding-source-inference-and-validation-responses",
+      "seoDescription": "Learn [ApiController] Behavior for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "[ApiController] Behavior Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "[ApiController] Behavior",
+      "title": "[ApiController] Behavior",
+      "topic": "API design and implementation"
+    },
+    {
+      "canonicalPath": "/content/aspnet-core-filters-and-middleware-boundaries/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/aspnet-core-filters-and-middleware-boundaries.md",
+      "id": "aspnet-core-filters-and-middleware-boundaries",
+      "seoDescription": "Learn ASP.NET Core filters and middleware boundaries for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "ASP.NET Core filters and middleware boundaries Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "ASP.NET Core filters and middleware boundaries",
+      "title": "ASP.NET Core filters and middleware boundaries",
+      "topic": "API design and implementation"
+    },
+    {
+      "canonicalPath": "/content/async-and-await-semantics-in-csharp/",
+      "canonicalPathSource": "frontmatter",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/async-and-await-semantics-in-csharp.md",
+      "id": "async-and-await-semantics-in-csharp",
+      "seoDescription": "Learn async and await in C# for technical interviews, including Task, cancellation, exception handling, and common deadlock risks.",
+      "seoDescriptionSource": "frontmatter",
+      "seoTitle": "Async and Await in C# Interview Questions",
+      "seoTitleSource": "frontmatter",
+      "subtopic": "Async and Await Semantics",
+      "title": "Async and Await Semantics",
+      "topic": "Async programming, tasks, cancellation, and concurrency"
+    },
+    {
+      "canonicalPath": "/content/authentication-vs-authorization-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/authentication-vs-authorization-in-csharp.md",
+      "id": "authentication-vs-authorization-in-csharp",
+      "seoDescription": "Learn Authentication vs Authorization in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Authentication vs Authorization in C# Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Authentication vs Authorization in C#",
+      "title": "Authentication vs Authorization in C#",
+      "topic": "Authentication, authorization, and web security"
+    },
+    {
+      "canonicalPath": "/content/cancellationtoken-propagation-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/cancellationtoken-propagation-in-csharp.md",
+      "id": "cancellationtoken-propagation-in-csharp",
+      "seoDescription": "Learn CancellationToken Propagation for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "CancellationToken Propagation Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "CancellationToken Propagation",
+      "title": "CancellationToken Propagation",
+      "topic": "Async programming, tasks, cancellation, and concurrency"
+    },
+    {
+      "canonicalPath": "/content/classes-structs-records/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/classes-structs-records-object-oriented-fundamentals.md",
+      "id": "classes-structs-records",
+      "seoDescription": "Learn Classes, structs, records for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Classes, structs, records Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Classes, structs, records",
+      "title": "Classes, structs, records",
+      "topic": "C# Language Foundations"
+    },
+    {
+      "canonicalPath": "/content/code-coverage-useful-assertions-flaky-test-prevention-and-ci-test-execution/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/code-coverage-useful-assertions-flaky-test-prevention-and-ci-test-execution.md",
+      "id": "code-coverage-useful-assertions-flaky-test-prevention-and-ci-test-execution",
+      "seoDescription": "Learn Code Coverage, Useful Assertions, Flaky Test Prevention, and CI Test Execution for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Code Coverage, Useful Assertions, Flaky Test Prevention, and CI Test Execution Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Code Coverage, Useful Assertions, Flaky Test Prevention, and CI Test Execution",
+      "title": "Code Coverage, Useful Assertions, Flaky Test Prevention, and CI Test Execution",
+      "topic": "Testing strategy and integration testing"
+    },
+    {
+      "canonicalPath": "/content/collection-choices-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/collection-choices-in-csharp.md",
+      "id": "collection-choices-in-csharp",
+      "seoDescription": "Learn Collection Choices in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Collection Choices in C# Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Collection Choices in C#",
+      "title": "Collection Choices in C#",
+      "topic": "C# Language Foundations"
+    },
+    {
+      "canonicalPath": "/content/common-bcl-types-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/common-bcl-types-in-csharp.md",
+      "id": "common-bcl-types-in-csharp",
+      "seoDescription": "Learn Common BCL Types in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Common BCL Types in C# Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Common BCL Types in C#",
+      "title": "Common BCL Types in C#",
+      "topic": "C# Language Foundations"
+    },
+    {
+      "canonicalPath": "/content/configuration-sources-and-the-options-pattern/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/configuration-sources-and-the-options-pattern.md",
+      "id": "configuration-sources-and-the-options-pattern",
+      "seoDescription": "Learn Configuration Sources and the Options Pattern for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Configuration Sources and the Options Pattern Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Configuration Sources and the Options Pattern",
+      "title": "Configuration Sources and the Options Pattern",
+      "topic": "Dependency injection, configuration, middleware, and logging"
+    },
+    {
+      "canonicalPath": "/content/content-negotiation-status-codes-dtos-request-response-contracts/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/content-negotiation-status-codes-dtos-request-response-contracts.md",
+      "id": "content-negotiation-status-codes-dtos-request-response-contracts",
+      "seoDescription": "Learn Content negotiation, status codes and request/response contracts for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Content negotiation, status codes and request/response contracts Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Content negotiation, status codes and request/response contracts",
+      "title": "Content negotiation, status codes and request/response contracts",
+      "topic": "API design and implementation"
+    },
+    {
+      "canonicalPath": "/content/controllers-vs-minimal-apis-when-to-choose-each/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/controllers-vs-minimal-apis-when-to-choose-each.md",
+      "id": "controllers-vs-minimal-apis-when-to-choose-each",
+      "seoDescription": "Learn Controllers vs Minimal APIs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Controllers vs Minimal APIs Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Controllers vs Minimal APIs",
+      "title": "Controllers vs Minimal APIs",
+      "topic": "API design and implementation"
+    },
+    {
+      "canonicalPath": "/content/conventions-fluent-api-owned-complex-data-and-relationship-mapping/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/conventions-fluent-api-owned-complex-data-and-relationship-mapping.md",
+      "id": "conventions-fluent-api-owned-complex-data-and-relationship-mapping",
+      "seoDescription": "Learn Conventions, Fluent API, Owned/Complex Data, and Relationship Mapping for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Conventions, Fluent API, Owned/Complex Data, and Relationship Mapping Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Conventions, Fluent API, Owned/Complex Data, and Relationship Mapping",
+      "title": "Conventions, Fluent API, Owned/Complex Data, and Relationship Mapping",
+      "topic": "Entity Framework"
+    },
+    {
+      "canonicalPath": "/content/cookie-behavior-csrf-browser-security-concerns/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/cookie-behavior-csrf-browser-security-concerns.md",
+      "id": "cookie-behavior-csrf-browser-security-concerns",
+      "seoDescription": "Learn Cookie behavior, CSRF, and browser-based security concerns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Cookie behavior, CSRF, and browser-based security concerns Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Cookie behavior, CSRF, and browser-based security concerns",
+      "title": "Cookie behavior, CSRF, and browser-based security concerns",
+      "topic": "Authentication, authorization, and web security"
+    },
+    {
+      "canonicalPath": "/content/coordinating-multiple-tasks-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/coordinating-multiple-tasks-in-csharp.md",
+      "id": "coordinating-multiple-tasks-in-csharp",
+      "seoDescription": "Learn Coordinating Multiple Tasks in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Coordinating Multiple Tasks in C# Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Coordinating Multiple Tasks in C#",
+      "title": "Coordinating Multiple Tasks in C#",
+      "topic": "Async programming, tasks, cancellation, and concurrency"
+    },
+    {
+      "canonicalPath": "/content/cors-secure-headers-secret-handling-and-least-privilege/",
+      "canonicalPathSource": "generated",
+      "category": "Design & Architecture",
+      "contentPath": "src/contents/v1/NET/cors-secure-headers-secret-handling-least-privilege.md",
+      "id": "cors-secure-headers-secret-handling-and-least-privilege",
+      "seoDescription": "Learn CORS, secure headers, secret handling, and least privilege for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "CORS, secure headers, secret handling, and least privilege Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "CORS, secure headers, secret handling, and least privilege",
+      "title": "CORS, secure headers, secret handling, and least privilege",
+      "topic": "Authentication, authorization, and web security"
+    },
+    {
+      "canonicalPath": "/content/cpu-bound-vs-io-bound-work-and-task-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/cpu-bound-vs-io-bound-work-and-task-in-csharp.md",
+      "id": "cpu-bound-vs-io-bound-work-and-task-in-csharp",
+      "seoDescription": "Learn CPU-bound vs I/O-bound Work and Task for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "CPU-bound vs I/O-bound Work and Task Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "CPU-bound vs I/O-bound Work and Task",
+      "title": "CPU-bound vs I/O-bound Work and Task",
+      "topic": "Async programming, tasks, cancellation, and concurrency"
+    },
+    {
+      "canonicalPath": "/content/data-seeding-choices-including-hasdata-vs-runtime-seed-logic/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/data-seeding-choices-including-hasdata-vs-runtime-seed-logic.md",
+      "id": "data-seeding-choices-including-hasdata-vs-runtime-seed-logic",
+      "seoDescription": "Learn Data Seeding Choices, Including HasData vs Runtime Seed Logic for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Data Seeding Choices, Including HasData vs Runtime Seed Logic Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Data Seeding Choices, Including HasData vs Runtime Seed Logic",
+      "title": "Data Seeding Choices, Including HasData vs Runtime Seed Logic",
+      "topic": "Entity Framework"
+    },
+    {
+      "canonicalPath": "/content/dbcontext-change-tracking-and-entity-state-management-in-ef-core/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/dbcontext-change-tracking-and-entity-state-management-in-ef-core.md",
+      "id": "dbcontext-change-tracking-and-entity-state-management-in-ef-core",
+      "seoDescription": "Learn DbContext change tracking and entity state management in EF Core for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "DbContext change tracking and entity state management in EF Core Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "DbContext change tracking and entity state management in EF Core",
+      "title": "DbContext change tracking and entity state management in EF Core",
+      "topic": "Entity Framework"
+    },
+    {
+      "canonicalPath": "/content/dbcontext-lifetime-thread-safety-connection-usage-and-when-to-avoid-sharing-a-context/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/dbcontext-lifetime-thread-safety-connection-usage-and-when-to-avoid-sharing-a-context.md",
+      "id": "dbcontext-lifetime-thread-safety-connection-usage-and-when-to-avoid-sharing-a-context",
+      "seoDescription": "Learn DbContext Lifetime, Thread Safety, Connection Usage, and When to Avoid Sharing a Context for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "DbContext Lifetime, Thread Safety, Connection Usage, and When to Avoid Sharing a Context Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "DbContext Lifetime, Thread Safety, Connection Usage, and When to Avoid Sharing a Context",
+      "title": "DbContext Lifetime, Thread Safety, Connection Usage, and When to Avoid Sharing a Context",
+      "topic": "Entity Framework"
+    },
+    {
+      "canonicalPath": "/content/deferred-execution-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/deferred-execution-in-csharp.md",
+      "id": "deferred-execution-in-csharp",
+      "seoDescription": "Learn Deferred Execution in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Deferred Execution in C# Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Deferred Execution in C#",
+      "title": "Deferred Execution in C#",
+      "topic": "Modern C# patterns"
+    },
+    {
+      "canonicalPath": "/content/delegates-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/delegates-in-csharp.md",
+      "id": "delegates-in-csharp",
+      "seoDescription": "Learn Delegates for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Delegates Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Delegates",
+      "title": "Delegates",
+      "topic": "Modern C# patterns"
+    },
+    {
+      "canonicalPath": "/content/di-di-container-basics-lifetimes-and-constructor-selection-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/di-di-container-basics-lifetimes-and-constructor-selection-in-csharp.md",
+      "id": "di-di-container-basics-lifetimes-and-constructor-selection-in-csharp",
+      "seoDescription": "Learn DI, DI Container Basics for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "DI, DI Container Basics Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "DI, DI Container Basics",
+      "title": "DI, DI Container Basics",
+      "topic": "Dependency injection, configuration, middleware, and logging"
+    },
+    {
+      "canonicalPath": "/content/eager-explicit-and-lazy-loading-including-the-n-plus-one-query-problem/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/eager-explicit-and-lazy-loading-including-the-n-plus-one-query-problem.md",
+      "id": "eager-explicit-and-lazy-loading-including-the-n-plus-one-query-problem",
+      "seoDescription": "Learn Eager, Explicit, and Lazy Loading, Including the N+1 Query Problem for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Eager, Explicit, and Lazy Loading, Including the N+1 Query Problem Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Eager, Explicit, and Lazy Loading, Including the N+1 Query Problem",
+      "title": "Eager, Explicit, and Lazy Loading, Including the N+1 Query Problem",
+      "topic": "Entity Framework"
+    },
+    {
+      "canonicalPath": "/content/ef-core-inmemory-provider-caveats-and-when-sqlite-docker-databases-or-testcontainers-are-safer/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/ef-core-inmemory-provider-caveats-and-when-sqlite-docker-databases-or-testcontainers-are-safer.md",
+      "id": "ef-core-inmemory-provider-caveats-and-when-sqlite-docker-databases-or-testcontainers-are-safer",
+      "seoDescription": "Learn EF Core InMemory Provider Caveats and When SQLite, Docker Databases, or Testcontainers Are Safer for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "EF Core InMemory Provider Caveats and When SQLite, Docker Databases, or Testcontainers Are Safer Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "EF Core InMemory Provider Caveats and When SQLite, Docker Databases, or Testcontainers Are Safer",
+      "title": "EF Core InMemory Provider Caveats and When SQLite, Docker Databases, or Testcontainers Are Safer",
+      "topic": "Testing strategy and integration testing"
+    },
+    {
+      "canonicalPath": "/content/ef-core-migrations-and-production-migration-safety/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/ef-core-migrations-and-production-migration-safety.md",
+      "id": "ef-core-migrations-and-production-migration-safety",
+      "seoDescription": "Learn EF Core migrations and production migration safety for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "EF Core migrations and production migration safety Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "EF Core migrations and production migration safety",
+      "title": "EF Core migrations and production migration safety",
+      "topic": "Entity Framework"
+    },
+    {
+      "canonicalPath": "/content/endpoint-routing-and-route-matching-in-aspnet-core/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/endpoint-routing-and-route-matching-in-aspnet-core.md",
+      "id": "endpoint-routing-and-route-matching-in-aspnet-core",
+      "seoDescription": "Learn Endpoint routing and route matching for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Endpoint routing and route matching Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Endpoint routing and route matching",
+      "title": "Endpoint routing and route matching",
+      "topic": "API design and implementation"
+    },
+    {
+      "canonicalPath": "/content/exception-handling-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/exception-handling-in-csharp.md",
+      "id": "exception-handling-in-csharp",
+      "seoDescription": "Learn Exception Handling in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Exception Handling in C# Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Exception Handling in C#",
+      "title": "Exception Handling in C#",
+      "topic": "Async programming, tasks, cancellation, and concurrency"
+    },
+    {
+      "canonicalPath": "/content/exceptions-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/exceptions-in-csharp.md",
+      "id": "exceptions-in-csharp",
+      "seoDescription": "Learn Exceptions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Exceptions Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Exceptions",
+      "title": "Exceptions",
+      "topic": "C# Language Foundations"
+    },
+    {
+      "canonicalPath": "/content/generic-type-constraints-and-reusable-components-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/generic-type-constraints-and-reusable-components-csharp.md",
+      "id": "generic-type-constraints-and-reusable-components-csharp",
+      "seoDescription": "Learn Generic Type Constraints and Reusable Components for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Generic Type Constraints and Reusable Components Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Generic Type Constraints and Reusable Components",
+      "title": "Generic Type Constraints and Reusable Components",
+      "topic": "Modern C# patterns"
+    },
+    {
+      "canonicalPath": "/content/ienumerable-vs-iqueryable-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/ienumerable-vs-iqueryable-in-csharp.md",
+      "id": "ienumerable-vs-iqueryable-in-csharp",
+      "seoDescription": "Learn IEnumerable vs IQueryable in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "IEnumerable vs IQueryable in C# Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "IEnumerable vs IQueryable in C#",
+      "title": "IEnumerable vs IQueryable in C#",
+      "topic": "Modern C# patterns"
+    },
+    {
+      "canonicalPath": "/content/ihttpclientfactory-and-resilient-outbound-http/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/ihttpclientfactory-and-resilient-outbound-http.md",
+      "id": "ihttpclientfactory-and-resilient-outbound-http",
+      "seoDescription": "Learn IHttpClientFactory and Resilient Outbound HTTP for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "IHttpClientFactory and Resilient Outbound HTTP Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "IHttpClientFactory and Resilient Outbound HTTP",
+      "title": "IHttpClientFactory and Resilient Outbound HTTP",
+      "topic": "Performance, scalability, and caching"
+    },
+    {
+      "canonicalPath": "/content/in-memory-distributed-hybrid-output-caching/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/in-memory-distributed-hybrid-output-caching.md",
+      "id": "in-memory-distributed-hybrid-output-caching",
+      "seoDescription": "Learn In-memory, distributed, hybrid, and output caching for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "In-memory, distributed, hybrid, and output caching Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "In-memory, distributed, hybrid, and output caching",
+      "title": "In-memory, distributed, hybrid, and output caching",
+      "topic": "Performance, scalability, and caching"
+    },
+    {
+      "canonicalPath": "/content/jwt-bearer-auth-claims-scopes-and-policy-based-authorization/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/jwt-bearer-auth-claims-scopes-and-policy-based-authorization.md",
+      "id": "jwt-bearer-auth-claims-scopes-and-policy-based-authorization",
+      "seoDescription": "Learn JWT Bearer Auth, Claims, Scopes, and Policy-Based Authorization for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "JWT Bearer Auth, Claims, Scopes, and Policy-Based Authorization Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "JWT Bearer Auth, Claims, Scopes, and Policy-Based Authorization",
+      "title": "JWT Bearer Auth, Claims, Scopes, and Policy-Based Authorization",
+      "topic": "Authentication, authorization, and web security"
+    },
+    {
+      "canonicalPath": "/content/linq-querying-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/linq-querying-in-csharp.md",
+      "id": "linq-querying-in-csharp",
+      "seoDescription": "Learn LINQ Querying for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "LINQ Querying Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "LINQ Querying",
+      "title": "LINQ Querying",
+      "topic": "Modern C# patterns"
+    },
+    {
+      "canonicalPath": "/content/middleware-ordering-and-cross-cutting-behavior/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/middleware-ordering-and-cross-cutting-behavior.md",
+      "id": "middleware-ordering-and-cross-cutting-behavior",
+      "seoDescription": "Learn Middleware Ordering and Cross-Cutting Behavior for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Middleware Ordering and Cross-Cutting Behavior Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Middleware Ordering and Cross-Cutting Behavior",
+      "title": "Middleware Ordering and Cross-Cutting Behavior",
+      "topic": "Dependency injection, configuration, middleware, and logging"
+    },
+    {
+      "canonicalPath": "/content/nullable-reference-types-and-null-safety-habits-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/nullable-reference-types-and-null-safety-habits-in-csharp.md",
+      "id": "nullable-reference-types-and-null-safety-habits-in-csharp",
+      "seoDescription": "Learn Nullable reference  C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Nullable reference  C# Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Nullable reference  C#",
+      "title": "Nullable reference  C#",
+      "topic": "C# Language Foundations"
+    },
+    {
+      "canonicalPath": "/content/observer-style-communication-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/observer-style-communication-in-csharp.md",
+      "id": "observer-style-communication-in-csharp",
+      "seoDescription": "Learn Observer-Style Communication in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Observer-Style Communication in C# Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Observer-Style Communication in C#",
+      "title": "Observer-Style Communication in C#",
+      "topic": "Modern C# patterns"
+    },
+    {
+      "canonicalPath": "/content/object-oriented-fundamentals/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/oop.md",
+      "id": "object-oriented-fundamentals",
+      "seoDescription": "Learn Object-Oriented Programming for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Object-Oriented Programming Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Object-Oriented Programming",
+      "title": "Object-Oriented Programming",
+      "topic": "C# Language Foundations"
+    },
+    {
+      "canonicalPath": "/content/openapi-generation-endpoint-metadata-api-discoverability/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/openapi-generation-endpoint-metadata-api-discoverability.md",
+      "id": "openapi-generation-endpoint-metadata-api-discoverability",
+      "seoDescription": "Learn OpenAPI generation and API discoverability for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "OpenAPI generation and API discoverability Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "OpenAPI generation and API discoverability",
+      "title": "OpenAPI generation and API discoverability",
+      "topic": "API design and implementation"
+    },
+    {
+      "canonicalPath": "/content/optimistic-concurrency-transactions-savepoints-conflict-handling/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/optimistic-concurrency-transactions-savepoints-conflict-handling.md",
+      "id": "optimistic-concurrency-transactions-savepoints-conflict-handling",
+      "seoDescription": "Learn Optimistic concurrency, transactions, savepoints, and conflict handling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Optimistic concurrency, transactions, savepoints, and conflict handling Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Optimistic concurrency, transactions, savepoints, and conflict handling",
+      "title": "Optimistic concurrency, transactions, savepoints, and conflict handling",
+      "topic": "Entity Framework"
+    },
+    {
+      "canonicalPath": "/content/overriding-services-and-configuration-for-tests/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/overriding-services-and-configuration-for-tests.md",
+      "id": "overriding-services-and-configuration-for-tests",
+      "seoDescription": "Learn Overriding services and configuration in .NET tests for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Overriding services and configuration in .NET tests Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Overriding services and configuration in .NET tests",
+      "title": "Overriding services and configuration in .NET tests",
+      "topic": "Testing strategy and integration testing"
+    },
+    {
+      "canonicalPath": "/content/parameter-binding-from-route-query-string-body-form-header-and-services/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/parameter-binding-from-route-query-string-body-form-header-and-services.md",
+      "id": "parameter-binding-from-route-query-string-body-form-header-and-services",
+      "seoDescription": "Learn Parameter Binding for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Parameter Binding Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Parameter Binding",
+      "title": "Parameter Binding",
+      "topic": "API design and implementation"
+    },
+    {
+      "canonicalPath": "/content/pattern-matching-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/pattern-matching-in-csharp.md",
+      "id": "pattern-matching-in-csharp",
+      "seoDescription": "Learn Pattern Matching in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Pattern Matching in C# Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Pattern Matching in C#",
+      "title": "Pattern Matching in C#",
+      "topic": "Modern C# patterns"
+    },
+    {
+      "canonicalPath": "/content/rate-limiting-memory-gc-awareness-runtime-diagnostics/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/rate-limiting-memory-gc-awareness-runtime-diagnostics.md",
+      "id": "rate-limiting-memory-gc-awareness-runtime-diagnostics",
+      "seoDescription": "Learn Rate limiting, memory/GC awareness, and runtime diagnostics for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Rate limiting, memory/GC awareness, and runtime diagnostics Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Rate limiting, memory/GC awareness, and runtime diagnostics",
+      "title": "Rate limiting, memory/GC awareness, and runtime diagnostics",
+      "topic": "Performance, scalability, and caching"
+    },
+    {
+      "canonicalPath": "/content/records-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/records-in-csharp.md",
+      "id": "records-in-csharp",
+      "seoDescription": "Learn Records in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Records in C# Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Records in C#",
+      "title": "Records in C#",
+      "topic": "Modern C# patterns"
+    },
+    {
+      "canonicalPath": "/content/structured-logging-and-correlation/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/structured-logging-and-correlation.md",
+      "id": "structured-logging-and-correlation",
+      "seoDescription": "Learn Structured Logging and Correlation for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Structured Logging and Correlation Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Structured Logging and Correlation",
+      "title": "Structured Logging and Correlation",
+      "topic": "Dependency injection, configuration, middleware, and logging"
+    },
+    {
+      "canonicalPath": "/content/switch-expressions-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/switch-expressions-in-csharp.md",
+      "id": "switch-expressions-in-csharp",
+      "seoDescription": "Learn Switch Expressions in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Switch Expressions in C# Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Switch Expressions in C#",
+      "title": "Switch Expressions in C#",
+      "topic": "Modern C# patterns"
+    },
+    {
+      "canonicalPath": "/content/test-doubles-mocks-stubs-fakes-mocking-integration-problems/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/test-doubles-mocks-stubs-fakes-mocking-integration-problems.md",
+      "id": "test-doubles-mocks-stubs-fakes-mocking-integration-problems",
+      "seoDescription": "Learn Test doubles, mocking boundaries, and integration risks in .NET for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Test doubles, mocking boundaries, and integration risks in .NET Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Test doubles, mocking boundaries, and integration risks in .NET",
+      "title": "Test doubles, mocking boundaries, and integration risks in .NET",
+      "topic": "Testing strategy and integration testing"
+    },
+    {
+      "canonicalPath": "/content/testing-authentication-authorization-middleware-filters-validation-error-responses/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/testing-authentication-authorization-middleware-filters-validation-error-responses.md",
+      "id": "testing-authentication-authorization-middleware-filters-validation-error-responses",
+      "seoDescription": "Learn Testing ASP.NET Core security, pipeline behavior, validation, and error responses for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Testing ASP.NET Core security, pipeline behavior, validation, and error responses Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Testing ASP.NET Core security, pipeline behavior, validation, and error responses",
+      "title": "Testing ASP.NET Core security, pipeline behavior, validation, and error responses",
+      "topic": "Testing strategy and integration testing"
+    },
+    {
+      "canonicalPath": "/content/timeouts-in-csharp/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/timeouts-in-csharp.md",
+      "id": "timeouts-in-csharp",
+      "seoDescription": "Learn Timeouts in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Timeouts in C# Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Timeouts in C#",
+      "title": "Timeouts in C#",
+      "topic": "Async programming, tasks, cancellation, and concurrency"
+    },
+    {
+      "canonicalPath": "/content/tracking-vs-no-tracking-queries-and-identity-resolution/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/tracking-vs-no-tracking-queries-and-identity-resolution.md",
+      "id": "tracking-vs-no-tracking-queries-and-identity-resolution",
+      "seoDescription": "Learn Tracking vs no-tracking queries and identity resolution for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Tracking vs no-tracking queries and identity resolution Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Tracking vs no-tracking queries and identity resolution",
+      "title": "Tracking vs no-tracking queries and identity resolution",
+      "topic": "Entity Framework"
+    },
+    {
+      "canonicalPath": "/content/unit-tests-integration-tests-and-hosted-services-for-background-jobs/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/unit-tests-integration-tests-and-hosted-services-for-background-jobs.md",
+      "id": "unit-tests-integration-tests-and-hosted-services-for-background-jobs",
+      "seoDescription": "Learn Unit Tests, Integration Tests, and Hosted Services for Background Jobs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Unit Tests, Integration Tests, and Hosted Services for Background Jobs Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Unit Tests, Integration Tests, and Hosted Services for Background Jobs",
+      "title": "Unit Tests, Integration Tests, and Hosted Services for Background Jobs",
+      "topic": "Performance, scalability, and caching"
+    },
+    {
+      "canonicalPath": "/content/unit-tests-vs-integration-tests-vs-end-to-end-tests/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/unit-tests-vs-integration-tests-vs-end-to-end-tests.md",
+      "id": "unit-tests-vs-integration-tests-vs-end-to-end-tests",
+      "seoDescription": "Learn Unit Tests vs Integration Tests vs End-to-End Tests for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Unit Tests vs Integration Tests vs End-to-End Tests Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Unit Tests vs Integration Tests vs End-to-End Tests",
+      "title": "Unit Tests vs Integration Tests vs End-to-End Tests",
+      "topic": "Testing strategy and integration testing"
+    },
+    {
+      "canonicalPath": "/content/value-types-vs-reference-types/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/value-types-vs-reference-types.md",
+      "id": "value-types-vs-reference-types",
+      "seoDescription": "Learn Value Types vs Reference Types for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Value Types vs Reference Types Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Value Types vs Reference Types",
+      "title": "Value Types vs Reference Types",
+      "topic": "C# Language Foundations"
+    },
+    {
+      "canonicalPath": "/content/webapplicationfactory-testserver-httpclient-and-full-aspnet-core-pipeline-testing/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/webapplicationfactory-testserver-httpclient-and-full-aspnet-core-pipeline-testing.md",
+      "id": "webapplicationfactory-testserver-httpclient-and-full-aspnet-core-pipeline-testing",
+      "seoDescription": "Learn WebApplicationFactory, TestServer, HttpClient, and Full ASP.NET Core Pipeline Testing for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "WebApplicationFactory, TestServer, HttpClient, and Full ASP.NET Core Pipeline Testing Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "WebApplicationFactory, TestServer, HttpClient, and Full ASP.NET Core Pipeline Testing",
+      "title": "WebApplicationFactory, TestServer, HttpClient, and Full ASP.NET Core Pipeline Testing",
+      "topic": "Testing strategy and integration testing"
+    },
+    {
+      "canonicalPath": "/content/xunit-nunit-mstest-test-naming-aaa-test-data-setup/",
+      "canonicalPathSource": "generated",
+      "category": ".NET",
+      "contentPath": "src/contents/v1/NET/xunit-nunit-mstest-test-naming-aaa-test-data-setup.md",
+      "id": "xunit-nunit-mstest-test-naming-aaa-test-data-setup",
+      "seoDescription": "Learn Unit testing frameworks, naming, AAA, and test data setup in .NET for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Unit testing frameworks, naming, AAA, and test data setup in .NET Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Unit testing frameworks, naming, AAA, and test data setup in .NET",
+      "title": "Unit testing frameworks, naming, AAA, and test data setup in .NET",
+      "topic": "Testing strategy and integration testing"
+    },
+    {
+      "canonicalPath": "/content/access-tokens-refresh-tokens-expiration-handling-retrying-original-requests-and-refresh-token-queue-patterns/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/access-tokens-refresh-tokens-expiration-handling-retrying-original-requests-and-refresh-token-queue-patterns.md",
+      "id": "access-tokens-refresh-tokens-expiration-handling-retrying-original-requests-and-refresh-token-queue-patterns",
+      "seoDescription": "Learn Access tokens, refresh tokens, expiration handling, retrying original requests, and refresh-token queue patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Access tokens, refresh tokens, expiration handling, retrying original requests, and refresh-token queue patterns Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Access tokens, refresh tokens, expiration handling, retrying original requests, and refresh-token queue patterns",
+      "title": "Access tokens, refresh tokens, expiration handling, retrying original requests, and refresh-token queue patterns",
+      "topic": "Production data access, API clients, and frontend auth"
+    },
+    {
+      "canonicalPath": "/content/axios-request-and-response-interceptors-for-auth-headers-global-errors-logging-and-retry-behavior/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/axios-request-and-response-interceptors-for-auth-headers-global-errors-logging-and-retry-behavior.md",
+      "id": "axios-request-and-response-interceptors-for-auth-headers-global-errors-logging-and-retry-behavior",
+      "seoDescription": "Learn Axios request and response interceptors for auth headers, global errors, logging, and retry behavior for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Axios request and response interceptors for auth headers, global errors, logging, and retry behavior Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Axios request and response interceptors for auth headers, global errors, logging, and retry behavior",
+      "title": "Axios request and response interceptors for auth headers, global errors, logging, and retry behavior",
+      "topic": "Production data access, API clients, and frontend auth"
+    },
+    {
+      "canonicalPath": "/content/browser-storage-trade-offs-localstorage-sessionstorage-memory-storage-and-cookies/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/browser-storage-trade-offs-localstorage-sessionstorage-memory-storage-and-cookies.md",
+      "id": "browser-storage-trade-offs-localstorage-sessionstorage-memory-storage-and-cookies",
+      "seoDescription": "Learn Browser storage trade-offs: localStorage, sessionStorage, memory storage, and cookies for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Browser storage trade-offs: localStorage, sessionStorage, memory storage, and cookies Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Browser storage trade-offs: localStorage, sessionStorage, memory storage, and cookies",
+      "title": "Browser storage trade-offs: localStorage, sessionStorage, memory storage, and cookies",
+      "topic": "Production data access, API clients, and frontend auth"
+    },
+    {
+      "canonicalPath": "/content/built-in-validation-async-validation-and-schema-resolvers-with-yup-or-zod/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/built-in-validation-async-validation-and-schema-resolvers-with-yup-or-zod.md",
+      "id": "built-in-validation-async-validation-and-schema-resolvers-with-yup-or-zod",
+      "seoDescription": "Learn Built-in validation, async validation, and schema resolvers with Yup or Zod for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Built-in validation, async validation, and schema resolvers with Yup or Zod Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Built-in validation, async validation, and schema resolvers with Yup or Zod",
+      "title": "Built-in validation, async validation, and schema resolvers with Yup or Zod",
+      "topic": "Forms, validation, and frontend performance in production"
+    },
+    {
+      "canonicalPath": "/content/centralized-api-clients-with-fetch-axios-rtk-query-or-tanstack-query/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/centralized-api-clients-with-fetch-axios-rtk-query-or-tanstack-query.md",
+      "id": "centralized-api-clients-with-fetch-axios-rtk-query-or-tanstack-query",
+      "seoDescription": "Learn Centralized API clients with `fetch`, Axios, RTK Query, or TanStack Query for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Centralized API clients with `fetch`, Axios, RTK Query, or TanStack Query Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Centralized API clients with `fetch`, Axios, RTK Query, or TanStack Query",
+      "title": "Centralized API clients with `fetch`, Axios, RTK Query, or TanStack Query",
+      "topic": "Production data access, API clients, and frontend auth"
+    },
+    {
+      "canonicalPath": "/content/closures-lexical-scope/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/closures-lexical-scope.md",
+      "id": "closures-lexical-scope",
+      "seoDescription": "Learn Closures and lexical scope for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Closures and lexical scope Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Closures and lexical scope",
+      "title": "Closures and lexical scope",
+      "topic": "JavaScript fundamentals"
+    },
+    {
+      "canonicalPath": "/content/code-splitting-lazy-loading-bundle-analysis-and-route-level-loading/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/code-splitting-lazy-loading-bundle-analysis-and-route-level-loading.md",
+      "id": "code-splitting-lazy-loading-bundle-analysis-and-route-level-loading",
+      "seoDescription": "Learn Code splitting, lazy loading, bundle analysis, and route-level loading for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Code splitting, lazy loading, bundle analysis, and route-level loading Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Code splitting, lazy loading, bundle analysis, and route-level loading",
+      "title": "Code splitting, lazy loading, bundle analysis, and route-level loading",
+      "topic": "Forms, validation, and frontend performance in production"
+    },
+    {
+      "canonicalPath": "/content/context-plus-reducer-vs-external-stores/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/context-plus-reducer-vs-external-stores.md",
+      "id": "context-plus-reducer-vs-external-stores",
+      "seoDescription": "Learn Context plus reducer vs external stores for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Context plus reducer vs external stores Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Context plus reducer vs external stores",
+      "title": "Context plus reducer vs external stores",
+      "topic": "State management, performance, and rendering optimization"
+    },
+    {
+      "canonicalPath": "/content/controlled-inputs-and-event-handling/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/controlled-inputs-and-event-handling.md",
+      "id": "controlled-inputs-and-event-handling",
+      "seoDescription": "Learn Controlled inputs and event handling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Controlled inputs and event handling Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Controlled inputs and event handling",
+      "title": "Controlled inputs and event handling",
+      "topic": "Components, props, state, and rendering behavior"
+    },
+    {
+      "canonicalPath": "/content/debounce-and-throttle-for-search-filtering-autosave-and-expensive-ui-updates/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/debounce-and-throttle-for-search-filtering-autosave-and-expensive-ui-updates.md",
+      "id": "debounce-and-throttle-for-search-filtering-autosave-and-expensive-ui-updates",
+      "seoDescription": "Learn Debounce and throttle for search, filtering, autosave, and expensive UI updates for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Debounce and throttle for search, filtering, autosave, and expensive UI updates Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Debounce and throttle for search, filtering, autosave, and expensive UI updates",
+      "title": "Debounce and throttle for search, filtering, autosave, and expensive UI updates",
+      "topic": "Forms, validation, and frontend performance in production"
+    },
+    {
+      "canonicalPath": "/content/debugging-rendering-hydration-and-interaction-issues/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/debugging-rendering-hydration-and-interaction-issues.md",
+      "id": "debugging-rendering-hydration-and-interaction-issues",
+      "seoDescription": "Learn Debugging rendering, hydration, and interaction issues for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Debugging rendering, hydration, and interaction issues Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Debugging rendering, hydration, and interaction issues",
+      "title": "Debugging rendering, hydration, and interaction issues",
+      "topic": "Testing, accessibility, and frontend debugging"
+    },
+    {
+      "canonicalPath": "/content/error-states-and-retry-ux-for-failed-requests/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/error-states-and-retry-ux-for-failed-requests.md",
+      "id": "error-states-and-retry-ux-for-failed-requests",
+      "seoDescription": "Learn Error states and retry UX for failed requests for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Error states and retry UX for failed requests Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Error states and retry UX for failed requests",
+      "title": "Error states and retry UX for failed requests",
+      "topic": "Routing, forms, and server communication"
+    },
+    {
+      "canonicalPath": "/content/forms-validation-optimistic-updates-and-mutation-states/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/forms-validation-optimistic-updates-and-mutation-states.md",
+      "id": "forms-validation-optimistic-updates-and-mutation-states",
+      "seoDescription": "Learn Forms, validation, optimistic updates, and mutation states for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Forms, validation, optimistic updates, and mutation states Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Forms, validation, optimistic updates, and mutation states",
+      "title": "Forms, validation, optimistic updates, and mutation states",
+      "topic": "Routing, forms, and server communication"
+    },
+    {
+      "canonicalPath": "/content/functional-components-and-jsx-composition/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/functional-components-and-jsx-composition.md",
+      "id": "functional-components-and-jsx-composition",
+      "seoDescription": "Learn Functional components and JSX composition for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Functional components and JSX composition Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Functional components and JSX composition",
+      "title": "Functional components and JSX composition",
+      "topic": "Components, props, state, and rendering behavior"
+    },
+    {
+      "canonicalPath": "/content/global-loading-error-unauthorized-and-network-failure-ux-patterns/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/global-loading-error-unauthorized-and-network-failure-ux-patterns.md",
+      "id": "global-loading-error-unauthorized-and-network-failure-ux-patterns",
+      "seoDescription": "Learn Global loading, error, unauthorized, and network-failure UX patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Global loading, error, unauthorized, and network-failure UX patterns Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Global loading, error, unauthorized, and network-failure UX patterns",
+      "title": "Global loading, error, unauthorized, and network-failure UX patterns",
+      "topic": "Production data access, API clients, and frontend auth"
+    },
+    {
+      "canonicalPath": "/content/keyboard-accessibility-semantic-html-aria-and-labels-ids/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/keyboard-accessibility-semantic-html-aria-and-labels-ids.md",
+      "id": "keyboard-accessibility-semantic-html-aria-and-labels-ids",
+      "seoDescription": "Learn Keyboard accessibility, semantic HTML, ARIA, and labels/IDs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Keyboard accessibility, semantic HTML, ARIA, and labels/IDs Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Keyboard accessibility, semantic HTML, ARIA, and labels/IDs",
+      "title": "Keyboard accessibility, semantic HTML, ARIA, and labels/IDs",
+      "topic": "Testing, accessibility, and frontend debugging"
+    },
+    {
+      "canonicalPath": "/content/memoization-and-avoiding-needless-rerenders/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/memoization-and-avoiding-needless-rerenders.md",
+      "id": "memoization-and-avoiding-needless-rerenders",
+      "seoDescription": "Learn Memoization and avoiding needless rerenders for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Memoization and avoiding needless rerenders Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Memoization and avoiding needless rerenders",
+      "title": "Memoization and avoiding needless rerenders",
+      "topic": "State management, performance, and rendering optimization"
+    },
+    {
+      "canonicalPath": "/content/memoization-with-usememo-and-dependency-correctness/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/memoization-with-usememo-and-dependency-correctness.md",
+      "id": "memoization-with-usememo-and-dependency-correctness",
+      "seoDescription": "Learn Memoization with useMemo and dependency correctness for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Memoization with useMemo and dependency correctness Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Memoization with useMemo and dependency correctness",
+      "title": "Memoization with useMemo and dependency correctness",
+      "topic": "Hooks, effects, and custom hooks"
+    },
+    {
+      "canonicalPath": "/content/modules-and-import-export-behavior/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/modules-and-import-export-behavior.md",
+      "id": "modules-and-import-export-behavior",
+      "seoDescription": "Learn Modules and import/export behavior for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Modules and import/export behavior Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Modules and import/export behavior",
+      "title": "Modules and import/export behavior",
+      "topic": "JavaScript fundamentals"
+    },
+    {
+      "canonicalPath": "/content/narrowing-and-control-flow-analysis/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/narrowing-and-control-flow-analysis.md",
+      "id": "narrowing-and-control-flow-analysis",
+      "seoDescription": "Learn Narrowing and control-flow analysis for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Narrowing and control-flow analysis Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Narrowing and control-flow analysis",
+      "title": "Narrowing and control-flow analysis",
+      "topic": "TypeScript for React"
+    },
+    {
+      "canonicalPath": "/content/nested-routes-layouts-params-and-route-boundaries/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/nested-routes-layouts-params-and-route-boundaries.md",
+      "id": "nested-routes-layouts-params-and-route-boundaries",
+      "seoDescription": "Learn Nested routes, layouts, params, and route boundaries for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Nested routes, layouts, params, and route boundaries Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Nested routes, layouts, params, and route boundaries",
+      "title": "Nested routes, layouts, params, and route boundaries",
+      "topic": "Routing, forms, and server communication"
+    },
+    {
+      "canonicalPath": "/content/preventing-duplicate-requests-canceling-stale-requests-and-avoiding-race-conditions/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/preventing-duplicate-requests-canceling-stale-requests-and-avoiding-race-conditions.md",
+      "id": "preventing-duplicate-requests-canceling-stale-requests-and-avoiding-race-conditions",
+      "seoDescription": "Learn Preventing duplicate requests, canceling stale requests, and avoiding race conditions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Preventing duplicate requests, canceling stale requests, and avoiding race conditions Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Preventing duplicate requests, canceling stale requests, and avoiding race conditions",
+      "title": "Preventing duplicate requests, canceling stale requests, and avoiding race conditions",
+      "topic": "Forms, validation, and frontend performance in production"
+    },
+    {
+      "canonicalPath": "/content/promises-asynchronous-javascript/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/promises-asynchronous-javascript.md",
+      "id": "promises-asynchronous-javascript",
+      "seoDescription": "Learn Promises and asynchronous JavaScript for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Promises and asynchronous JavaScript Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Promises and asynchronous JavaScript",
+      "title": "Promises and asynchronous JavaScript",
+      "topic": "JavaScript fundamentals"
+    },
+    {
+      "canonicalPath": "/content/proper-use-effect-usage-and-cleanup/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/proper-use-effect-usage-and-cleanup.md",
+      "id": "proper-use-effect-usage-and-cleanup",
+      "seoDescription": "Learn Proper useEffect usage and cleanup for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Proper useEffect usage and cleanup Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Proper useEffect usage and cleanup",
+      "title": "Proper useEffect usage and cleanup",
+      "topic": "Hooks, effects, and custom hooks"
+    },
+    {
+      "canonicalPath": "/content/props-flow-local-state-and-lifting-state-up/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/props-flow-local-state-and-lifting-state-up.md",
+      "id": "props-flow-local-state-and-lifting-state-up",
+      "seoDescription": "Learn Props flow, local state, and lifting state up for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Props flow, local state, and lifting state up Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Props flow, local state, and lifting state up",
+      "title": "Props flow, local state, and lifting state up",
+      "topic": "Components, props, state, and rendering behavior"
+    },
+    {
+      "canonicalPath": "/content/query-strategy-and-avoiding-implementation-detail-assertions/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/query-strategy-and-avoiding-implementation-detail-assertions.md",
+      "id": "query-strategy-and-avoiding-implementation-detail-assertions",
+      "seoDescription": "Learn Query strategy and avoiding implementation-detail assertions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Query strategy and avoiding implementation-detail assertions Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Query strategy and avoiding implementation-detail assertions",
+      "title": "Query strategy and avoiding implementation-detail assertions",
+      "topic": "Testing, accessibility, and frontend debugging"
+    },
+    {
+      "canonicalPath": "/content/react-hook-form-fundamentals-uncontrolled-inputs-controller-and-form-state/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/react-hook-form-fundamentals-uncontrolled-inputs-controller-and-form-state.md",
+      "id": "react-hook-form-fundamentals-uncontrolled-inputs-controller-and-form-state",
+      "seoDescription": "Learn React Hook Form fundamentals, uncontrolled inputs, `Controller`, and form state for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "React Hook Form fundamentals, uncontrolled inputs, `Controller`, and form state Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "React Hook Form fundamentals, uncontrolled inputs, `Controller`, and form state",
+      "title": "React Hook Form fundamentals, uncontrolled inputs, `Controller`, and form state",
+      "topic": "Forms, validation, and frontend performance in production"
+    },
+    {
+      "canonicalPath": "/content/reducing-state-complexity-and-avoiding-unnecessary-rerenders-in-form-heavy-pages/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/reducing-state-complexity-and-avoiding-unnecessary-rerenders-in-form-heavy-pages.md",
+      "id": "reducing-state-complexity-and-avoiding-unnecessary-rerenders-in-form-heavy-pages",
+      "seoDescription": "Learn Reducing state complexity and avoiding unnecessary rerenders in form-heavy pages for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Reducing state complexity and avoiding unnecessary rerenders in form-heavy pages Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Reducing state complexity and avoiding unnecessary rerenders in form-heavy pages",
+      "title": "Reducing state complexity and avoiding unnecessary rerenders in form-heavy pages",
+      "topic": "Forms, validation, and frontend performance in production"
+    },
+    {
+      "canonicalPath": "/content/rerender-triggers-derived-state-and-avoiding-duplicated-state/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/rerender-triggers-derived-state-and-avoiding-duplicated-state.md",
+      "id": "rerender-triggers-derived-state-and-avoiding-duplicated-state",
+      "seoDescription": "Learn Rerender triggers, derived state, and avoiding duplicated state for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Rerender triggers, derived state, and avoiding duplicated state Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Rerender triggers, derived state, and avoiding duplicated state",
+      "title": "Rerender triggers, derived state, and avoiding duplicated state",
+      "topic": "Components, props, state, and rendering behavior"
+    },
+    {
+      "canonicalPath": "/content/route-loaders-actions-or-equivalent-data-loading-patterns/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/route-loaders-actions-or-equivalent-data-loading-patterns.md",
+      "id": "route-loaders-actions-or-equivalent-data-loading-patterns",
+      "seoDescription": "Learn Route loaders/actions or equivalent data-loading patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Route loaders/actions or equivalent data-loading patterns Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Route loaders/actions or equivalent data-loading patterns",
+      "title": "Route loaders/actions or equivalent data-loading patterns",
+      "topic": "Routing, forms, and server communication"
+    },
+    {
+      "canonicalPath": "/content/rtk-query-custom-base-queries-including-axios-based-basequery-patterns/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/rtk-query-custom-base-queries-including-axios-based-basequery-patterns.md",
+      "id": "rtk-query-custom-base-queries-including-axios-based-basequery-patterns",
+      "seoDescription": "Learn RTK Query custom base queries, including Axios-based baseQuery patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "RTK Query custom base queries, including Axios-based baseQuery patterns Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "RTK Query custom base queries, including Axios-based baseQuery patterns",
+      "title": "RTK Query custom base queries, including Axios-based baseQuery patterns",
+      "topic": "Production data access, API clients, and frontend auth"
+    },
+    {
+      "canonicalPath": "/content/secure-cookie-flags-httponly-secure-samesite-path-domain-and-expiration/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/secure-cookie-flags-httponly-secure-samesite-path-domain-and-expiration.md",
+      "id": "secure-cookie-flags-httponly-secure-samesite-path-domain-and-expiration",
+      "seoDescription": "Learn Secure cookie flags: `HttpOnly`, `Secure`, `SameSite`, path, domain, and expiration for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Secure cookie flags: `HttpOnly`, `Secure`, `SameSite`, path, domain, and expiration Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Secure cookie flags: `HttpOnly`, `Secure`, `SameSite`, path, domain, and expiration",
+      "title": "Secure cookie flags: `HttpOnly`, `Secure`, `SameSite`, path, domain, and expiration",
+      "topic": "Production data access, API clients, and frontend auth"
+    },
+    {
+      "canonicalPath": "/content/strict-equality-reference-identity-and-immutability-implications/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/strict-equality-reference-identity-and-immutability-implications.md",
+      "id": "strict-equality-reference-identity-and-immutability-implications",
+      "seoDescription": "Learn Strict equality, reference identity, and immutability implications for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Strict equality, reference identity, and immutability implications Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Strict equality, reference identity, and immutability implications",
+      "title": "Strict equality, reference identity, and immutability implications",
+      "topic": "JavaScript fundamentals"
+    },
+    {
+      "canonicalPath": "/content/suspense-transitions-and-rendering-priority-concepts/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/suspense-transitions-and-rendering-priority-concepts.md",
+      "id": "suspense-transitions-and-rendering-priority-concepts",
+      "seoDescription": "Learn Suspense, transitions, and rendering priority concepts for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Suspense, transitions, and rendering priority concepts Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Suspense, transitions, and rendering priority concepts",
+      "title": "Suspense, transitions, and rendering priority concepts",
+      "topic": "State management, performance, and rendering optimization"
+    },
+    {
+      "canonicalPath": "/content/tsconfig-basics-strict-mode-module-settings/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/tsconfig-basics-strict-mode-module-settings.md",
+      "id": "tsconfig-basics-strict-mode-module-settings",
+      "seoDescription": "Learn tsconfig basics, strict mode, and module settings for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "tsconfig basics, strict mode, and module settings Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "tsconfig basics, strict mode, and module settings",
+      "title": "tsconfig basics, strict mode, and module settings",
+      "topic": "TypeScript for React"
+    },
+    {
+      "canonicalPath": "/content/types-unions-intersections-discriminated-unions/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/types-unions-intersections-discriminated-unions.md",
+      "id": "types-unions-intersections-discriminated-unions",
+      "seoDescription": "Learn Types, unions, intersections, and discriminated unions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Types, unions, intersections, and discriminated unions Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Types, unions, intersections, and discriminated unions",
+      "title": "Types, unions, intersections, and discriminated unions",
+      "topic": "TypeScript for React"
+    },
+    {
+      "canonicalPath": "/content/use-state-use-reducer-use-context-and-custom-hooks/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/use-state-use-reducer-use-context-and-custom-hooks.md",
+      "id": "use-state-use-reducer-use-context-and-custom-hooks",
+      "seoDescription": "Learn useState, useReducer, useContext, and custom hooks for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "useState, useReducer, useContext, and custom hooks Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "useState, useReducer, useContext, and custom hooks",
+      "title": "useState, useReducer, useContext, and custom hooks",
+      "topic": "Hooks, effects, and custom hooks"
+    },
+    {
+      "canonicalPath": "/content/use-sync-external-store-and-subscribing-to-external-state/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/use-sync-external-store-and-subscribing-to-external-state.md",
+      "id": "use-sync-external-store-and-subscribing-to-external-state",
+      "seoDescription": "Learn useSyncExternalStore and subscribing to external state for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "useSyncExternalStore and subscribing to external state Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "useSyncExternalStore and subscribing to external state",
+      "title": "useSyncExternalStore and subscribing to external state",
+      "topic": "State management, performance, and rendering optimization"
+    },
+    {
+      "canonicalPath": "/content/user-centric-testing-with-react-testing-library/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/user-centric-testing-with-react-testing-library.md",
+      "id": "user-centric-testing-with-react-testing-library",
+      "seoDescription": "Learn User-centric testing with React Testing Library for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "User-centric testing with React Testing Library Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "User-centric testing with React Testing Library",
+      "title": "User-centric testing with React Testing Library",
+      "topic": "Testing, accessibility, and frontend debugging"
+    },
+    {
+      "canonicalPath": "/content/utility-types-and-conditional-types/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/utility-types-and-conditional-types.md",
+      "id": "utility-types-and-conditional-types",
+      "seoDescription": "Learn Utility types and conditional types for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Utility types and conditional types Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Utility types and conditional types",
+      "title": "Utility types and conditional types",
+      "topic": "TypeScript for React"
+    },
+    {
+      "canonicalPath": "/content/watch-vs-usewatch-form-render-isolation-and-large-form-performance/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/watch-vs-usewatch-form-render-isolation-and-large-form-performance.md",
+      "id": "watch-vs-usewatch-form-render-isolation-and-large-form-performance",
+      "seoDescription": "Learn `watch` vs `useWatch`, form render isolation, and large-form performance for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "`watch` vs `useWatch`, form render isolation, and large-form performance Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "`watch` vs `useWatch`, form render isolation, and large-form performance",
+      "title": "`watch` vs `useWatch`, form render isolation, and large-form performance",
+      "topic": "Forms, validation, and frontend performance in production"
+    },
+    {
+      "canonicalPath": "/content/you-might-not-need-an-effect-patterns/",
+      "canonicalPathSource": "generated",
+      "category": "React",
+      "contentPath": "src/contents/v1/React/you-might-not-need-an-effect-patterns.md",
+      "id": "you-might-not-need-an-effect-patterns",
+      "seoDescription": "Learn “You might not need an effect” patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "“You might not need an effect” patterns Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "“You might not need an effect” patterns",
+      "title": "“You might not need an effect” patterns",
+      "topic": "Hooks, effects, and custom hooks"
+    },
+    {
+      "canonicalPath": "/content/acid-basics-and-transaction-scope/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/acid-basics-and-transaction-scope.md",
+      "id": "acid-basics-and-transaction-scope",
+      "seoDescription": "Learn ACID basics and transaction scope for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "ACID basics and transaction scope Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "ACID basics and transaction scope",
+      "title": "ACID basics and transaction scope",
+      "topic": "Transactions, isolation, locking, and deadlocks"
+    },
+    {
+      "canonicalPath": "/content/backup-types-restore-strategy-and-recovery-objectives/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/backup-types-restore-strategy-and-recovery-objectives.md",
+      "id": "backup-types-restore-strategy-and-recovery-objectives",
+      "seoDescription": "Learn Backup types, restore strategy, and recovery objectives for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Backup types, restore strategy, and recovery objectives Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Backup types, restore strategy, and recovery objectives",
+      "title": "Backup types, restore strategy, and recovery objectives",
+      "topic": "Backup, recovery, HA/DR, security, and temporal data"
+    },
+    {
+      "canonicalPath": "/content/baselines-workload-comparisons-and-targeted-tuning/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/baselines-workload-comparisons-and-targeted-tuning.md",
+      "id": "baselines-workload-comparisons-and-targeted-tuning",
+      "seoDescription": "Learn Baselines, workload comparisons, and targeted tuning for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Baselines, workload comparisons, and targeted tuning Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Baselines, workload comparisons, and targeted tuning",
+      "title": "Baselines, workload comparisons, and targeted tuning",
+      "topic": "Query tuning, Query Store, and plan stability"
+    },
+    {
+      "canonicalPath": "/content/char-vs-varchar-vs-nvarchar-and-unicode-storage-choices/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/char-vs-varchar-vs-nvarchar-and-unicode-storage-choices.md",
+      "id": "char-vs-varchar-vs-nvarchar-and-unicode-storage-choices",
+      "seoDescription": "Learn CHAR vs VARCHAR vs NVARCHAR and Unicode storage choices for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "CHAR vs VARCHAR vs NVARCHAR and Unicode storage choices Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "CHAR vs VARCHAR vs NVARCHAR and Unicode storage choices",
+      "title": "CHAR vs VARCHAR vs NVARCHAR and Unicode storage choices",
+      "topic": "SQL practical interview comparisons and SQL Server-specific features"
+    },
+    {
+      "canonicalPath": "/content/clustered-vs-nonclustered-indexes/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/clustered-vs-nonclustered-indexes.md",
+      "id": "clustered-vs-nonclustered-indexes",
+      "seoDescription": "Learn Clustered vs nonclustered indexes for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Clustered vs nonclustered indexes Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Clustered vs nonclustered indexes",
+      "title": "Clustered vs nonclustered indexes",
+      "topic": "Indexes, statistics, and execution plans"
+    },
+    {
+      "canonicalPath": "/content/computed-columns-persisted-computed-columns-and-indexed-views/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/computed-columns-persisted-computed-columns-and-indexed-views.md",
+      "id": "computed-columns-persisted-computed-columns-and-indexed-views",
+      "seoDescription": "Learn Computed columns, persisted computed columns, and indexed views for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Computed columns, persisted computed columns, and indexed views Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Computed columns, persisted computed columns, and indexed views",
+      "title": "Computed columns, persisted computed columns, and indexed views",
+      "topic": "SQL practical interview comparisons and SQL Server-specific features"
+    },
+    {
+      "canonicalPath": "/content/data-types-nullability-and-business-rule-enforcement/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/data-types-nullability-and-business-rule-enforcement.md",
+      "id": "data-types-nullability-and-business-rule-enforcement",
+      "seoDescription": "Learn Data types, nullability, and business-rule enforcement for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Data types, nullability, and business-rule enforcement Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Data types, nullability, and business-rule enforcement",
+      "title": "Data types, nullability, and business-rule enforcement",
+      "topic": "Relational modeling and normalization"
+    },
+    {
+      "canonicalPath": "/content/ddl-vs-dml-vs-dcl-and-how-schema-data-and-permissions-changes-differ/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/ddl-vs-dml-vs-dcl-and-how-schema-data-and-permissions-changes-differ.md",
+      "id": "ddl-vs-dml-vs-dcl-and-how-schema-data-and-permissions-changes-differ",
+      "seoDescription": "Learn DDL vs DML vs DCL and how schema, data, and permissions changes differ for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "DDL vs DML vs DCL and how schema, data, and permissions changes differ Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "DDL vs DML vs DCL and how schema, data, and permissions changes differ",
+      "title": "DDL vs DML vs DCL and how schema, data, and permissions changes differ",
+      "topic": "SQL practical interview comparisons and SQL Server-specific features"
+    },
+    {
+      "canonicalPath": "/content/deadlocks-detection-and-mitigation/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/deadlocks-detection-and-mitigation.md",
+      "id": "deadlocks-detection-and-mitigation",
+      "seoDescription": "Learn Deadlocks, detection, and mitigation for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Deadlocks, detection, and mitigation Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Deadlocks, detection, and mitigation",
+      "title": "Deadlocks, detection, and mitigation",
+      "topic": "Transactions, isolation, locking, and deadlocks"
+    },
+    {
+      "canonicalPath": "/content/delete-vs-truncate-including-logging-identity-reset-rollback-behavior-and-foreign-key-limitations/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/delete-vs-truncate-including-logging-identity-reset-rollback-behavior-and-foreign-key-limitations.md",
+      "id": "delete-vs-truncate-including-logging-identity-reset-rollback-behavior-and-foreign-key-limitations",
+      "seoDescription": "Learn DELETE vs TRUNCATE, including logging, identity reset, rollback behavior, and foreign key limitations for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "DELETE vs TRUNCATE, including logging, identity reset, rollback behavior, and foreign key limitations Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "DELETE vs TRUNCATE, including logging, identity reset, rollback behavior, and foreign key limitations",
+      "title": "DELETE vs TRUNCATE, including logging, identity reset, rollback behavior, and foreign key limitations",
+      "topic": "SQL practical interview comparisons and SQL Server-specific features"
+    },
+    {
+      "canonicalPath": "/content/estimated-vs-actual-execution-plans/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/estimated-vs-actual-execution-plans.md",
+      "id": "estimated-vs-actual-execution-plans",
+      "seoDescription": "Learn Estimated vs actual execution plans for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Estimated vs actual execution plans Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Estimated vs actual execution plans",
+      "title": "Estimated vs actual execution plans",
+      "topic": "Indexes, statistics, and execution plans"
+    },
+    {
+      "canonicalPath": "/content/group-by-and-aggregate-functions/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/group-by-and-aggregate-functions.md",
+      "id": "group-by-and-aggregate-functions",
+      "seoDescription": "Learn GROUP BY and aggregate functions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "GROUP BY and aggregate functions Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "GROUP BY and aggregate functions",
+      "title": "GROUP BY and aggregate functions",
+      "topic": "Core querying and data retrieval"
+    },
+    {
+      "canonicalPath": "/content/high-availability-and-disaster-recovery-basics/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/high-availability-and-disaster-recovery-basics.md",
+      "id": "high-availability-and-disaster-recovery-basics",
+      "seoDescription": "Learn High availability and disaster recovery basics for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "High availability and disaster recovery basics Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "High availability and disaster recovery basics",
+      "title": "High availability and disaster recovery basics",
+      "topic": "Backup, recovery, HA/DR, security, and temporal data"
+    },
+    {
+      "canonicalPath": "/content/inner-left-other-join-patterns/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/inner-left-other-join-patterns.md",
+      "id": "inner-left-other-join-patterns",
+      "seoDescription": "Learn INNER, LEFT, and other join patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "INNER, LEFT, and other join patterns Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "INNER, LEFT, and other join patterns",
+      "title": "INNER, LEFT, and other join patterns",
+      "topic": "Relational modeling and normalization"
+    },
+    {
+      "canonicalPath": "/content/isolation-levels-and-row-versioning/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/isolation-levels-and-row-versioning.md",
+      "id": "isolation-levels-and-row-versioning",
+      "seoDescription": "Learn Isolation levels and row versioning for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Isolation levels and row versioning Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Isolation levels and row versioning",
+      "title": "Isolation levels and row versioning",
+      "topic": "Transactions, isolation, locking, and deadlocks"
+    },
+    {
+      "canonicalPath": "/content/knowing-when-to-change-sql-indexes-or-schema-instead-of-forcing-hints/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/knowing-when-to-change-sql-indexes-or-schema-instead-of-forcing-hints.md",
+      "id": "knowing-when-to-change-sql-indexes-or-schema-instead-of-forcing-hints",
+      "seoDescription": "Learn Knowing when to change SQL, indexes, or schema instead of forcing hints for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Knowing when to change SQL, indexes, or schema instead of forcing hints Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Knowing when to change SQL, indexes, or schema instead of forcing hints",
+      "title": "Knowing when to change SQL, indexes, or schema instead of forcing hints",
+      "topic": "Query tuning, Query Store, and plan stability"
+    },
+    {
+      "canonicalPath": "/content/least-privilege-roles-row-level-security-and-masking/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/least-privilege-roles-row-level-security-and-masking.md",
+      "id": "least-privilege-roles-row-level-security-and-masking",
+      "seoDescription": "Learn Least privilege, roles, row-level security, and masking for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Least privilege, roles, row-level security, and masking Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Least privilege, roles, row-level security, and masking",
+      "title": "Least privilege, roles, row-level security, and masking",
+      "topic": "Backup, recovery, HA/DR, security, and temporal data"
+    },
+    {
+      "canonicalPath": "/content/local-vs-global-temporary-tables-and-table-variables/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/local-vs-global-temporary-tables-and-table-variables.md",
+      "id": "local-vs-global-temporary-tables-and-table-variables",
+      "seoDescription": "Learn Local vs global temporary tables and table variables for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Local vs global temporary tables and table variables Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Local vs global temporary tables and table variables",
+      "title": "Local vs global temporary tables and table variables",
+      "topic": "SQL practical interview comparisons and SQL Server-specific features"
+    },
+    {
+      "canonicalPath": "/content/locking-behavior-and-blocking/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/locking-behavior-and-blocking.md",
+      "id": "locking-behavior-and-blocking",
+      "seoDescription": "Learn Locking behavior and blocking for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Locking behavior and blocking Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Locking behavior and blocking",
+      "title": "Locking behavior and blocking",
+      "topic": "Transactions, isolation, locking, and deadlocks"
+    },
+    {
+      "canonicalPath": "/content/merge-and-upsert-patterns-including-concurrency-cautions/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/merge-and-upsert-patterns-including-concurrency-cautions.md",
+      "id": "merge-and-upsert-patterns-including-concurrency-cautions",
+      "seoDescription": "Learn MERGE and upsert patterns, including concurrency cautions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "MERGE and upsert patterns, including concurrency cautions Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "MERGE and upsert patterns, including concurrency cautions",
+      "title": "MERGE and upsert patterns, including concurrency cautions",
+      "topic": "SQL practical interview comparisons and SQL Server-specific features"
+    },
+    {
+      "canonicalPath": "/content/normalization-and-when-denormalization-is-justified/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/normalization-and-when-denormalization-is-justified.md",
+      "id": "normalization-and-when-denormalization-is-justified",
+      "seoDescription": "Learn Normalization and when denormalization is justified for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Normalization and when denormalization is justified Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Normalization and when denormalization is justified",
+      "title": "Normalization and when denormalization is justified",
+      "topic": "Relational modeling and normalization"
+    },
+    {
+      "canonicalPath": "/content/null-handling-and-common-filtering-mistakes/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/null-handling-and-common-filtering-mistakes.md",
+      "id": "null-handling-and-common-filtering-mistakes",
+      "seoDescription": "Learn NULL handling and common filtering mistakes for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "NULL handling and common filtering mistakes Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "NULL handling and common filtering mistakes",
+      "title": "NULL handling and common filtering mistakes",
+      "topic": "Core querying and data retrieval"
+    },
+    {
+      "canonicalPath": "/content/one-to-one-one-to-many-many-to-many-relationships/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/one-to-one-one-to-many-many-to-many-relationships.md",
+      "id": "one-to-one-one-to-many-many-to-many-relationships",
+      "seoDescription": "Learn One-to-one, one-to-many, and many-to-many relationships for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "One-to-one, one-to-many, and many-to-many relationships Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "One-to-one, one-to-many, and many-to-many relationships",
+      "title": "One-to-one, one-to-many, and many-to-many relationships",
+      "topic": "Core querying and data retrieval"
+    },
+    {
+      "canonicalPath": "/content/over-partition-by-row-number-rank-and-running-aggregates/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/over-partition-by-row-number-rank-and-running-aggregates.md",
+      "id": "over-partition-by-row-number-rank-and-running-aggregates",
+      "seoDescription": "Learn OVER, PARTITION BY, ROW_NUMBER, RANK, and running aggregates for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "OVER, PARTITION BY, ROW_NUMBER, RANK, and running aggregates Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "OVER, PARTITION BY, ROW_NUMBER, RANK, and running aggregates",
+      "title": "OVER, PARTITION BY, ROW_NUMBER, RANK, and running aggregates",
+      "topic": "Advanced querying with window functions and CTEs"
+    },
+    {
+      "canonicalPath": "/content/parameter-sensitive-plans-and-skewed-data-distributions/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/parameter-sensitive-plans-and-skewed-data-distributions.md",
+      "id": "parameter-sensitive-plans-and-skewed-data-distributions",
+      "seoDescription": "Learn Parameter-sensitive plans and skewed data distributions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Parameter-sensitive plans and skewed data distributions Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Parameter-sensitive plans and skewed data distributions",
+      "title": "Parameter-sensitive plans and skewed data distributions",
+      "topic": "Query tuning, Query Store, and plan stability"
+    },
+    {
+      "canonicalPath": "/content/primary-key-vs-unique-constraint-candidate-keys-foreign-keys-and-constraint-design/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/primary-key-vs-unique-constraint-candidate-keys-foreign-keys-and-constraint-design.md",
+      "id": "primary-key-vs-unique-constraint-candidate-keys-foreign-keys-and-constraint-design",
+      "seoDescription": "Learn Primary key vs unique constraint, candidate keys, foreign keys, and constraint design for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Primary key vs unique constraint, candidate keys, foreign keys, and constraint design Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Primary key vs unique constraint, candidate keys, foreign keys, and constraint design",
+      "title": "Primary key vs unique constraint, candidate keys, foreign keys, and constraint design",
+      "topic": "SQL practical interview comparisons and SQL Server-specific features"
+    },
+    {
+      "canonicalPath": "/content/primary-keys-foreign-keys-constraints/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/primary-keys-foreign-keys-constraints.md",
+      "id": "primary-keys-foreign-keys-constraints",
+      "seoDescription": "Learn Primary keys, foreign keys, and constraints for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Primary keys, foreign keys, and constraints Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Primary keys, foreign keys, and constraints",
+      "title": "Primary keys, foreign keys, and constraints",
+      "topic": "Core querying and data retrieval"
+    },
+    {
+      "canonicalPath": "/content/query-store-for-regression-detection-and-plan-history/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/query-store-for-regression-detection-and-plan-history.md",
+      "id": "query-store-for-regression-detection-and-plan-history",
+      "seoDescription": "Learn Query Store for regression detection and plan history for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Query Store for regression detection and plan history Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Query Store for regression detection and plan history",
+      "title": "Query Store for regression detection and plan history",
+      "topic": "Query tuning, Query Store, and plan stability"
+    },
+    {
+      "canonicalPath": "/content/replacing-brittle-subqueries-with-clearer-query-structure/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/replacing-brittle-subqueries-with-clearer-query-structure.md",
+      "id": "replacing-brittle-subqueries-with-clearer-query-structure",
+      "seoDescription": "Learn Replacing brittle subqueries with clearer query structure for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Replacing brittle subqueries with clearer query structure Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Replacing brittle subqueries with clearer query structure",
+      "title": "Replacing brittle subqueries with clearer query structure",
+      "topic": "Advanced querying with window functions and CTEs"
+    },
+    {
+      "canonicalPath": "/content/schema-migrations-source-control-reviewable-sql-scripts-and-release-safety/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/schema-migrations-source-control-reviewable-sql-scripts-and-release-safety.md",
+      "id": "schema-migrations-source-control-reviewable-sql-scripts-and-release-safety",
+      "seoDescription": "Learn Schema migrations, source control, reviewable SQL scripts, and release safety for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Schema migrations, source control, reviewable SQL scripts, and release safety Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Schema migrations, source control, reviewable SQL scripts, and release safety",
+      "title": "Schema migrations, source control, reviewable SQL scripts, and release safety",
+      "topic": "Database programmability and schema evolution"
+    },
+    {
+      "canonicalPath": "/content/select-where-order-by-top-offset-fetch/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/select-where-order-by-top-offset-fetch.md",
+      "id": "select-where-order-by-top-offset-fetch",
+      "seoDescription": "Learn SELECT, WHERE, ORDER BY, TOP/OFFSET-FETCH for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "SELECT, WHERE, ORDER BY, TOP/OFFSET-FETCH Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "SELECT, WHERE, ORDER BY, TOP/OFFSET-FETCH",
+      "title": "SELECT, WHERE, ORDER BY, TOP/OFFSET-FETCH",
+      "topic": "Relational modeling and normalization"
+    },
+    {
+      "canonicalPath": "/content/selectivity-covering-indexes-and-index-maintenance-trade-offs/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/selectivity-covering-indexes-and-index-maintenance-trade-offs.md",
+      "id": "selectivity-covering-indexes-and-index-maintenance-trade-offs",
+      "seoDescription": "Learn Selectivity, covering indexes, and index maintenance trade-offs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Selectivity, covering indexes, and index maintenance trade-offs Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Selectivity, covering indexes, and index maintenance trade-offs",
+      "title": "Selectivity, covering indexes, and index maintenance trade-offs",
+      "topic": "Indexes, statistics, and execution plans"
+    },
+    {
+      "canonicalPath": "/content/standard-and-recursive-ctes/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/standard-and-recursive-ctes.md",
+      "id": "standard-and-recursive-ctes",
+      "seoDescription": "Learn Standard and recursive CTEs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Standard and recursive CTEs Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Standard and recursive CTEs",
+      "title": "Standard and recursive CTEs",
+      "topic": "Advanced querying with window functions and CTEs"
+    },
+    {
+      "canonicalPath": "/content/statistics-and-how-the-optimizer-uses-them/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/statistics-and-how-the-optimizer-uses-them.md",
+      "id": "statistics-and-how-the-optimizer-uses-them",
+      "seoDescription": "Learn Statistics and how the optimizer uses them for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Statistics and how the optimizer uses them Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Statistics and how the optimizer uses them",
+      "title": "Statistics and how the optimizer uses them",
+      "topic": "Indexes, statistics, and execution plans"
+    },
+    {
+      "canonicalPath": "/content/stored-procedure-transaction-patterns-with-try-catch-output-parameters-and-error-handling/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/stored-procedure-transaction-patterns-with-try-catch-output-parameters-and-error-handling.md",
+      "id": "stored-procedure-transaction-patterns-with-try-catch-output-parameters-and-error-handling",
+      "seoDescription": "Learn Stored procedure transaction patterns with `TRY...CATCH`, output parameters, and error handling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Stored procedure transaction patterns with `TRY...CATCH`, output parameters, and error handling Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Stored procedure transaction patterns with `TRY...CATCH`, output parameters, and error handling",
+      "title": "Stored procedure transaction patterns with `TRY...CATCH`, output parameters, and error handling",
+      "topic": "SQL practical interview comparisons and SQL Server-specific features"
+    },
+    {
+      "canonicalPath": "/content/stored-procedures-output-parameters-and-encapsulated-database-logic/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/stored-procedures-output-parameters-and-encapsulated-database-logic.md",
+      "id": "stored-procedures-output-parameters-and-encapsulated-database-logic",
+      "seoDescription": "Learn Stored procedures, output parameters, and encapsulated database logic for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Stored procedures, output parameters, and encapsulated database logic Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Stored procedures, output parameters, and encapsulated database logic",
+      "title": "Stored procedures, output parameters, and encapsulated database logic",
+      "topic": "Database programmability and schema evolution"
+    },
+    {
+      "canonicalPath": "/content/temporal-or-reporting-style-query-patterns/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/temporal-or-reporting-style-query-patterns.md",
+      "id": "temporal-or-reporting-style-query-patterns",
+      "seoDescription": "Learn Temporal or reporting-style query patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Temporal or reporting-style query patterns Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Temporal or reporting-style query patterns",
+      "title": "Temporal or reporting-style query patterns",
+      "topic": "Advanced querying with window functions and CTEs"
+    },
+    {
+      "canonicalPath": "/content/temporal-tables-historical-retention-and-lifecycle-management/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/temporal-tables-historical-retention-and-lifecycle-management.md",
+      "id": "temporal-tables-historical-retention-and-lifecycle-management",
+      "seoDescription": "Learn Temporal tables, historical retention, and lifecycle management for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Temporal tables, historical retention, and lifecycle management Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Temporal tables, historical retention, and lifecycle management",
+      "title": "Temporal tables, historical retention, and lifecycle management",
+      "topic": "Backup, recovery, HA/DR, security, and temporal data"
+    },
+    {
+      "canonicalPath": "/content/triggers-and-their-trade-offs/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/triggers-and-their-trade-offs.md",
+      "id": "triggers-and-their-trade-offs",
+      "seoDescription": "Learn Triggers and their trade-offs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Triggers and their trade-offs Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Triggers and their trade-offs",
+      "title": "Triggers and their trade-offs",
+      "topic": "Database programmability and schema evolution"
+    },
+    {
+      "canonicalPath": "/content/union-vs-union-all-except-intersect-and-duplicate-handling/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/union-vs-union-all-except-intersect-and-duplicate-handling.md",
+      "id": "union-vs-union-all-except-intersect-and-duplicate-handling",
+      "seoDescription": "Learn UNION vs UNION ALL, EXCEPT, INTERSECT, and duplicate handling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "UNION vs UNION ALL, EXCEPT, INTERSECT, and duplicate handling Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "UNION vs UNION ALL, EXCEPT, INTERSECT, and duplicate handling",
+      "title": "UNION vs UNION ALL, EXCEPT, INTERSECT, and duplicate handling",
+      "topic": "SQL practical interview comparisons and SQL Server-specific features"
+    },
+    {
+      "canonicalPath": "/content/views-and-user-defined-functions/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/views-and-user-defined-functions.md",
+      "id": "views-and-user-defined-functions",
+      "seoDescription": "Learn Views and user-defined functions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "Views and user-defined functions Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "Views and user-defined functions",
+      "title": "Views and user-defined functions",
+      "topic": "Database programmability and schema evolution"
+    },
+    {
+      "canonicalPath": "/content/where-vs-having-and-filtering-before-vs-after-aggregation/",
+      "canonicalPathSource": "generated",
+      "category": "SQL",
+      "contentPath": "src/contents/v1/SQL/where-vs-having-and-filtering-before-vs-after-aggregation.md",
+      "id": "where-vs-having-and-filtering-before-vs-after-aggregation",
+      "seoDescription": "Learn WHERE vs HAVING and filtering before vs after aggregation for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+      "seoDescriptionSource": "fallback",
+      "seoTitle": "WHERE vs HAVING and filtering before vs after aggregation Interview Questions | DEV_NET_CORE",
+      "seoTitleSource": "fallback",
+      "subtopic": "WHERE vs HAVING and filtering before vs after aggregation",
+      "title": "WHERE vs HAVING and filtering before vs after aggregation",
+      "topic": "SQL practical interview comparisons and SQL Server-specific features"
+    }
+  ]
+}
diff --git a/shared/content/loadContentRouteData.d.mts b/shared/content/loadContentRouteData.d.mts
new file mode 100644
index 0000000..d3e3dd3
--- /dev/null
+++ b/shared/content/loadContentRouteData.d.mts
@@ -0,0 +1,4 @@
+import type { ContentRouteData } from "../../src/components/content/contentRouteData";
+
+export function loadContentRouteData(topicId?: string): ContentRouteData;
+export function resolveCurriculumContentPath(contentPath: string): string;
diff --git a/shared/content/loadContentRouteData.mjs b/shared/content/loadContentRouteData.mjs
new file mode 100644
index 0000000..f6c317c
--- /dev/null
+++ b/shared/content/loadContentRouteData.mjs
@@ -0,0 +1,124 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const moduleRepositoryRoot = fileURLToPath(new URL("../../", import.meta.url));
+const repositoryRoot = isRepositoryRoot(process.cwd())
+  ? process.cwd()
+  : moduleRepositoryRoot;
+const contentRoot = path.join(repositoryRoot, "src", "contents", "v1");
+const welcomePath = path.join(
+  repositoryRoot,
+  "src",
+  "contents",
+  "resources",
+  "welcome.md"
+);
+const manifestPath = path.join(
+  repositoryRoot,
+  "shared",
+  "content",
+  "curriculumSeoManifest.generated.json"
+);
+
+let cachedManifest;
+
+export function loadContentRouteData(topicId) {
+  if (topicId === undefined || topicId === "") {
+    return {
+      kind: "welcome",
+      markdown: fs.readFileSync(welcomePath, "utf8"),
+    };
+  }
+
+  if (!isTopicId(topicId)) {
+    return {
+      kind: "not-found",
+      topicId: String(topicId),
+    };
+  }
+
+  const entry = getManifest().entries.find(
+    (candidate) => candidate.id === topicId
+  );
+
+  if (!entry) {
+    return {
+      kind: "not-found",
+      topicId,
+    };
+  }
+
+  const contentPath = resolveCurriculumContentPath(entry.contentPath);
+
+  return {
+    kind: "topic",
+    markdown: fs.readFileSync(contentPath, "utf8"),
+    topic: {
+      canonicalPath: entry.canonicalPath,
+      category: entry.category,
+      contentPath: entry.contentPath,
+      id: entry.id,
+      seoDescription: entry.seoDescription,
+      seoTitle: entry.seoTitle,
+      subtopic: entry.subtopic,
+      title: entry.title,
+      topic: entry.topic,
+    },
+  };
+}
+
+export function resolveCurriculumContentPath(contentPath) {
+  if (typeof contentPath !== "string" || !contentPath.trim()) {
+    throw new TypeError("Curriculum contentPath must be a non-empty string.");
+  }
+
+  const resolvedPath = path.resolve(repositoryRoot, contentPath);
+  const relativePath = path.relative(contentRoot, resolvedPath);
+
+  if (
+    relativePath.startsWith("..") ||
+    path.isAbsolute(relativePath) ||
+    path.extname(resolvedPath).toLowerCase() !== ".md"
+  ) {
+    throw new Error(
+      `Curriculum content path must resolve to a Markdown file under ${contentRoot}.`
+    );
+  }
+
+  const realContentRoot = fs.realpathSync(contentRoot);
+  const realContentPath = fs.realpathSync(resolvedPath);
+  const realRelativePath = path.relative(realContentRoot, realContentPath);
+
+  if (
+    realRelativePath.startsWith("..") ||
+    path.isAbsolute(realRelativePath)
+  ) {
+    throw new Error("Curriculum content path resolves outside the content root.");
+  }
+
+  return realContentPath;
+}
+
+function getManifest() {
+  if (!cachedManifest) {
+    cachedManifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  }
+
+  return cachedManifest;
+}
+
+function isTopicId(value) {
+  return (
+    typeof value === "string" &&
+    /^[a-z0-9][a-z0-9-]*$/.test(value)
+  );
+}
+
+function isRepositoryRoot(candidatePath) {
+  return (
+    fs.existsSync(path.join(candidatePath, "package.json")) &&
+    fs.existsSync(path.join(candidatePath, "shared", "content")) &&
+    fs.existsSync(path.join(candidatePath, "src", "contents", "v1"))
+  );
+}
diff --git a/shared/content/loadContentRouteData.test.mjs b/shared/content/loadContentRouteData.test.mjs
new file mode 100644
index 0000000..275fb87
--- /dev/null
+++ b/shared/content/loadContentRouteData.test.mjs
@@ -0,0 +1,52 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import {
+  loadContentRouteData,
+  resolveCurriculumContentPath,
+} from "./loadContentRouteData.mjs";
+
+const manifestPath = fileURLToPath(
+  new URL("./curriculumSeoManifest.generated.json", import.meta.url)
+);
+const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+const firstEntry = manifest.entries[0];
+
+test("loads welcome Markdown without a topic id", () => {
+  const routeData = loadContentRouteData();
+
+  assert.equal(routeData.kind, "welcome");
+  assert.match(routeData.markdown, /# Welcome/);
+});
+
+test("loads topic Markdown and serializable metadata", () => {
+  const routeData = loadContentRouteData(firstEntry.id);
+
+  assert.equal(routeData.kind, "topic");
+  assert.equal(routeData.topic.id, firstEntry.id);
+  assert.equal(routeData.topic.canonicalPath, firstEntry.canonicalPath);
+  assert.match(routeData.markdown, /## Overview/);
+});
+
+test("returns not-found data for unknown or invalid topic ids", () => {
+  assert.deepEqual(loadContentRouteData("missing-topic"), {
+    kind: "not-found",
+    topicId: "missing-topic",
+  });
+  assert.deepEqual(loadContentRouteData("../outside"), {
+    kind: "not-found",
+    topicId: "../outside",
+  });
+});
+
+test("rejects content paths outside the curriculum root", () => {
+  assert.throws(
+    () => resolveCurriculumContentPath("src/contents/resources/welcome.md"),
+    /under/
+  );
+  assert.throws(
+    () => resolveCurriculumContentPath("../../package.json"),
+    /under/
+  );
+});
diff --git a/shared/seo/buildSeoMetadata.d.mts b/shared/seo/buildSeoMetadata.d.mts
new file mode 100644
index 0000000..12c2806
--- /dev/null
+++ b/shared/seo/buildSeoMetadata.d.mts
@@ -0,0 +1,74 @@
+export type SeoContentEntry = Readonly<{
+  canonicalPath: string;
+  id: string;
+  seoDescription: string;
+  seoTitle: string;
+  subtopic?: string;
+  title?: string;
+}>;
+
+export type OpenGraphMetadata = Readonly<{
+  description: string;
+  image: string;
+  imageAlt: string;
+  imageHeight: number;
+  imageWidth: number;
+  title: string;
+  type: "website";
+  url: string | null;
+}>;
+
+export type TwitterMetadata = Readonly<{
+  card: "summary_large_image";
+  description: string;
+  image: string;
+  title: string;
+}>;
+
+export type WebSiteStructuredData = Readonly<{
+  "@context": "https://schema.org";
+  "@type": "WebSite";
+  description: string;
+  name: string;
+  url: string;
+}>;
+
+export type ArticleStructuredData = Readonly<{
+  "@context": "https://schema.org";
+  "@type": "Article";
+  description: string;
+  headline: string;
+  url: string;
+}>;
+
+export type SeoStructuredData =
+  | ArticleStructuredData
+  | WebSiteStructuredData;
+
+export type SeoMetadata = Readonly<{
+  canonicalPath: string | null;
+  canonicalUrl: string | null;
+  description: string;
+  index: boolean;
+  openGraph: OpenGraphMetadata;
+  robots: "index,follow" | "noindex,follow";
+  structuredData: SeoStructuredData | null;
+  title: string;
+  twitter: TwitterMetadata;
+}>;
+
+export type BuildSeoMetadataInput = Readonly<{
+  contentEntry?: SeoContentEntry;
+  pathname: string;
+}>;
+
+export const SEO_SITE_NAME: "DEV_NET_CORE";
+export const SEO_SITE_ORIGIN: "https://www.dev-net-core.com";
+export const DEFAULT_OG_IMAGE_URL: string;
+export const DEFAULT_OG_IMAGE_WIDTH: 1200;
+export const DEFAULT_OG_IMAGE_HEIGHT: 630;
+export const DEFAULT_OG_IMAGE_ALT: string;
+
+export function buildSeoMetadata(
+  input: BuildSeoMetadataInput
+): SeoMetadata;
diff --git a/shared/seo/buildSeoMetadata.mjs b/shared/seo/buildSeoMetadata.mjs
new file mode 100644
index 0000000..4a950d4
--- /dev/null
+++ b/shared/seo/buildSeoMetadata.mjs
@@ -0,0 +1,255 @@
+import { getStaticSeoRoute } from "./seoRoutes.mjs";
+
+export const SEO_SITE_NAME = "DEV_NET_CORE";
+export const SEO_SITE_ORIGIN = "https://www.dev-net-core.com";
+export const DEFAULT_OG_IMAGE_URL =
+  `${SEO_SITE_ORIGIN}/og/default-og-image.png`;
+export const DEFAULT_OG_IMAGE_WIDTH = 1200;
+export const DEFAULT_OG_IMAGE_HEIGHT = 630;
+export const DEFAULT_OG_IMAGE_ALT =
+  "DEV_NET_CORE developer interview preparation";
+
+const NOT_FOUND_TITLE = `Page Not Found | ${SEO_SITE_NAME}`;
+const NOT_FOUND_DESCRIPTION =
+  "The requested DEV_NET_CORE page could not be found.";
+
+export function buildSeoMetadata(input = {}) {
+  const pathname =
+    input && typeof input === "object" ? input.pathname : undefined;
+  const contentEntry =
+    input && typeof input === "object" ? input.contentEntry : undefined;
+  const normalizedPath = normalizePathname(pathname);
+
+  if (!normalizedPath) {
+    return buildNotFoundMetadata();
+  }
+
+  const staticRoute = getStaticSeoRoute(normalizedPath);
+
+  if (staticRoute) {
+    return createMetadata({
+      canonicalPath: staticRoute.canonicalPath,
+      description: staticRoute.seoDescription,
+      index: staticRoute.index,
+      structuredDataType: normalizedPath === "/" ? "website" : null,
+      title: staticRoute.seoTitle,
+    });
+  }
+
+  const contentMatch = normalizedPath.match(
+    /^\/content\/([a-z0-9][a-z0-9-]*)\/$/
+  );
+
+  if (contentMatch) {
+    return buildContentMetadata(
+      normalizedPath,
+      contentMatch[1],
+      contentEntry
+    );
+  }
+
+  const practiceMatch = normalizedPath.match(
+    /^\/practice\/([a-z0-9][a-z0-9-]*)\/$/
+  );
+
+  if (practiceMatch) {
+    return buildPracticeMetadata(
+      normalizedPath,
+      practiceMatch[1],
+      contentEntry
+    );
+  }
+
+  if (
+    /^\/simulation\/session\/[a-z0-9-]+\/$/.test(normalizedPath)
+  ) {
+    return createMetadata({
+      canonicalPath: null,
+      description:
+        "Complete a private DEV_NET_CORE mock interview session one question at a time.",
+      index: false,
+      title: `Mock Interview Session | ${SEO_SITE_NAME}`,
+    });
+  }
+
+  if (/^\/simulation\/result\/[a-z0-9-]+\/$/.test(normalizedPath)) {
+    return createMetadata({
+      canonicalPath: null,
+      description:
+        "Review answers, expected responses, and self-evaluation results from a DEV_NET_CORE mock interview session.",
+      index: false,
+      title: `Mock Interview Results | ${SEO_SITE_NAME}`,
+    });
+  }
+
+  return buildNotFoundMetadata();
+}
+
+function buildContentMetadata(normalizedPath, topicId, contentEntry) {
+  if (
+    !isValidContentEntry(contentEntry) ||
+    (contentEntry.id !== topicId &&
+      contentEntry.canonicalPath !== normalizedPath)
+  ) {
+    return buildNotFoundMetadata();
+  }
+
+  return createMetadata({
+    canonicalPath: contentEntry.canonicalPath,
+    description: contentEntry.seoDescription,
+    index: true,
+    structuredDataType: "article",
+    title: contentEntry.seoTitle,
+  });
+}
+
+function buildPracticeMetadata(normalizedPath, topicId, contentEntry) {
+  if (!isValidContentEntry(contentEntry) || contentEntry.id !== topicId) {
+    return buildNotFoundMetadata();
+  }
+
+  const topicName =
+    nonEmptyString(contentEntry.subtopic) ||
+    nonEmptyString(contentEntry.title) ||
+    topicId;
+
+  return createMetadata({
+    canonicalPath: normalizedPath,
+    description:
+      `Practice ${topicName} interview questions with expected answers, ` +
+      "key points, and topic progress tracking.",
+    index: false,
+    title: `Practice ${topicName} Interview Questions | ${SEO_SITE_NAME}`,
+  });
+}
+
+function buildNotFoundMetadata() {
+  return createMetadata({
+    canonicalPath: null,
+    description: NOT_FOUND_DESCRIPTION,
+    index: false,
+    title: NOT_FOUND_TITLE,
+  });
+}
+
+function createMetadata({
+  canonicalPath,
+  description,
+  index,
+  structuredDataType,
+  title,
+}) {
+  const canonicalUrl = canonicalPath
+    ? `${SEO_SITE_ORIGIN}${canonicalPath}`
+    : null;
+  const openGraph = Object.freeze({
+    description,
+    image: DEFAULT_OG_IMAGE_URL,
+    imageAlt: DEFAULT_OG_IMAGE_ALT,
+    imageHeight: DEFAULT_OG_IMAGE_HEIGHT,
+    imageWidth: DEFAULT_OG_IMAGE_WIDTH,
+    title,
+    type: "website",
+    url: canonicalUrl,
+  });
+  const twitter = Object.freeze({
+    card: "summary_large_image",
+    description,
+    image: DEFAULT_OG_IMAGE_URL,
+    title,
+  });
+
+  return Object.freeze({
+    canonicalPath,
+    canonicalUrl,
+    description,
+    index,
+    openGraph,
+    robots: index ? "index,follow" : "noindex,follow",
+    structuredData: createStructuredData({
+      canonicalUrl,
+      description,
+      index,
+      title,
+      type: structuredDataType,
+    }),
+    title,
+    twitter,
+  });
+}
+
+function createStructuredData({
+  canonicalUrl,
+  description,
+  index,
+  title,
+  type,
+}) {
+  if (!index || !canonicalUrl) {
+    return null;
+  }
+
+  if (type === "website") {
+    return Object.freeze({
+      "@context": "https://schema.org",
+      "@type": "WebSite",
+      description,
+      name: SEO_SITE_NAME,
+      url: canonicalUrl,
+    });
+  }
+
+  if (type === "article") {
+    return Object.freeze({
+      "@context": "https://schema.org",
+      "@type": "Article",
+      description,
+      headline: title,
+      url: canonicalUrl,
+    });
+  }
+
+  return null;
+}
+
+function isValidContentEntry(contentEntry) {
+  return (
+    contentEntry &&
+    typeof contentEntry === "object" &&
+    Boolean(nonEmptyString(contentEntry.id)) &&
+    Boolean(nonEmptyString(contentEntry.seoTitle)) &&
+    Boolean(nonEmptyString(contentEntry.seoDescription)) &&
+    typeof contentEntry.canonicalPath === "string" &&
+    /^\/content\/[a-z0-9][a-z0-9-]*\/$/.test(
+      contentEntry.canonicalPath
+    )
+  );
+}
+
+function normalizePathname(pathname) {
+  if (typeof pathname !== "string") {
+    return undefined;
+  }
+
+  const trimmedPath = pathname.trim();
+
+  if (
+    !trimmedPath.startsWith("/") ||
+    trimmedPath.includes("?") ||
+    trimmedPath.includes("#") ||
+    trimmedPath.includes("\\") ||
+    trimmedPath.includes("//")
+  ) {
+    return undefined;
+  }
+
+  if (trimmedPath === "/") {
+    return "/";
+  }
+
+  return trimmedPath.endsWith("/") ? trimmedPath : `${trimmedPath}/`;
+}
+
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
diff --git a/shared/seo/buildSeoMetadata.test.mjs b/shared/seo/buildSeoMetadata.test.mjs
new file mode 100644
index 0000000..378457e
--- /dev/null
+++ b/shared/seo/buildSeoMetadata.test.mjs
@@ -0,0 +1,159 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import test from "node:test";
+
+import {
+  DEFAULT_OG_IMAGE_URL,
+  buildSeoMetadata,
+} from "./buildSeoMetadata.mjs";
+import {
+  staticSeoRoutes,
+  validateStaticSeoRoutes,
+} from "./seoRoutes.mjs";
+
+const seoManifest = JSON.parse(
+  fs.readFileSync(
+    new URL("../content/curriculumSeoManifest.generated.json", import.meta.url),
+    "utf8"
+  )
+);
+const asyncAwaitEntry = seoManifest.entries.find(
+  (entry) => entry.id === "async-and-await-semantics-in-csharp"
+);
+
+test("builds self-canonical metadata for an indexable static route", () => {
+  const metadata = buildSeoMetadata({ pathname: "/content/" });
+
+  assert.equal(metadata.index, true);
+  assert.equal(metadata.robots, "index,follow");
+  assert.equal(
+    metadata.canonicalUrl,
+    "https://www.dev-net-core.com/content/"
+  );
+  assert.equal(metadata.openGraph.url, metadata.canonicalUrl);
+  assert.equal(metadata.openGraph.image, DEFAULT_OG_IMAGE_URL);
+  assert.equal(metadata.twitter.image, DEFAULT_OG_IMAGE_URL);
+  assert.equal(metadata.structuredData, null);
+});
+
+test("builds WebSite structured data for the canonical homepage", () => {
+  const metadata = buildSeoMetadata({ pathname: "/" });
+
+  assert.deepEqual(metadata.structuredData, {
+    "@context": "https://schema.org",
+    "@type": "WebSite",
+    description: metadata.description,
+    name: "DEV_NET_CORE",
+    url: "https://www.dev-net-core.com/",
+  });
+});
+
+test("canonicalizes the home alias while keeping it out of the index", () => {
+  const metadata = buildSeoMetadata({ pathname: "/home" });
+
+  assert.equal(metadata.index, false);
+  assert.equal(metadata.robots, "noindex,follow");
+  assert.equal(metadata.canonicalUrl, "https://www.dev-net-core.com/");
+  assert.equal(
+    metadata.title,
+    "DEV_NET_CORE | Developer Interview Preparation"
+  );
+  assert.equal(metadata.structuredData, null);
+});
+
+test("uses curriculum metadata for a valid content route", () => {
+  assert.ok(asyncAwaitEntry);
+
+  const metadata = buildSeoMetadata({
+    contentEntry: asyncAwaitEntry,
+    pathname: "/content/async-and-await-semantics-in-csharp",
+  });
+
+  assert.equal(metadata.index, true);
+  assert.equal(metadata.title, asyncAwaitEntry.seoTitle);
+  assert.equal(metadata.description, asyncAwaitEntry.seoDescription);
+  assert.equal(
+    metadata.canonicalPath,
+    "/content/async-and-await-semantics-in-csharp/"
+  );
+  assert.deepEqual(metadata.structuredData, {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    description: asyncAwaitEntry.seoDescription,
+    headline: asyncAwaitEntry.seoTitle,
+    url:
+      "https://www.dev-net-core.com/content/" +
+      "async-and-await-semantics-in-csharp/",
+  });
+});
+
+test("keeps a valid practice topic noindex and self-canonical", () => {
+  assert.ok(asyncAwaitEntry);
+
+  const metadata = buildSeoMetadata({
+    contentEntry: asyncAwaitEntry,
+    pathname: "/practice/async-and-await-semantics-in-csharp/",
+  });
+
+  assert.equal(metadata.index, false);
+  assert.equal(metadata.robots, "noindex,follow");
+  assert.equal(
+    metadata.canonicalUrl,
+    "https://www.dev-net-core.com/practice/async-and-await-semantics-in-csharp/"
+  );
+  assert.match(metadata.title, /^Practice Async and Await Semantics/);
+  assert.equal(metadata.structuredData, null);
+});
+
+test("keeps session-specific simulation routes noindex without canonicals", () => {
+  const metadata = buildSeoMetadata({
+    pathname: "/simulation/session/01234567-89ab-cdef-0123-456789abcdef",
+  });
+
+  assert.equal(metadata.index, false);
+  assert.equal(metadata.canonicalPath, null);
+  assert.equal(metadata.canonicalUrl, null);
+  assert.equal(metadata.openGraph.url, null);
+  assert.equal(metadata.title, "Mock Interview Session | DEV_NET_CORE");
+});
+
+test("treats an invalid content topic as not found", () => {
+  const metadata = buildSeoMetadata({
+    pathname: "/content/not-a-real-topic/",
+  });
+
+  assert.equal(metadata.index, false);
+  assert.equal(metadata.canonicalPath, null);
+  assert.equal(metadata.canonicalUrl, null);
+  assert.equal(metadata.title, "Page Not Found | DEV_NET_CORE");
+  assert.equal(metadata.structuredData, null);
+});
+
+test("treats an invalid practice topic as not found", () => {
+  const metadata = buildSeoMetadata({
+    pathname: "/practice/not-a-real-topic/",
+  });
+
+  assert.equal(metadata.index, false);
+  assert.equal(metadata.canonicalPath, null);
+  assert.equal(metadata.canonicalUrl, null);
+  assert.equal(metadata.title, "Page Not Found | DEV_NET_CORE");
+});
+
+test("rejects malformed static route configurations", () => {
+  assert.throws(() =>
+    validateStaticSeoRoutes([
+      {
+        canonicalPath: "/unsafe/",
+        index: false,
+        path: "/unsafe/",
+        prerender: false,
+        seoDescription: "",
+        seoTitle: "Unsafe",
+        sitemap: true,
+      },
+    ])
+  );
+
+  assert.equal(staticSeoRoutes.length, 12);
+});
diff --git a/shared/seo/seoRoutes.d.mts b/shared/seo/seoRoutes.d.mts
new file mode 100644
index 0000000..9f90c18
--- /dev/null
+++ b/shared/seo/seoRoutes.d.mts
@@ -0,0 +1,17 @@
+export type StaticSeoRoute = Readonly<{
+  canonicalPath: string;
+  index: boolean;
+  path: string;
+  prerender: boolean;
+  seoDescription: string;
+  seoTitle: string;
+  sitemap: boolean;
+}>;
+
+export const staticSeoRoutes: readonly StaticSeoRoute[];
+
+export function getStaticSeoRoute(path: string): StaticSeoRoute | undefined;
+
+export function validateStaticSeoRoutes(
+  routes: readonly StaticSeoRoute[]
+): void;
diff --git a/shared/seo/seoRoutes.mjs b/shared/seo/seoRoutes.mjs
new file mode 100644
index 0000000..8eefd5f
--- /dev/null
+++ b/shared/seo/seoRoutes.mjs
@@ -0,0 +1,222 @@
+const routeDefinitions = [
+  {
+    path: "/",
+    canonicalPath: "/",
+    index: true,
+    sitemap: true,
+    prerender: true,
+    seoDescription:
+      "Structured interview preparation for .NET, React, SQL, Azure, architecture, and modern software engineering topics.",
+    seoTitle: "DEV_NET_CORE | Developer Interview Preparation",
+  },
+  {
+    path: "/home/",
+    canonicalPath: "/",
+    index: false,
+    sitemap: false,
+    prerender: false,
+    seoDescription:
+      "Structured interview preparation for .NET, React, SQL, Azure, architecture, and modern software engineering topics.",
+    seoTitle: "DEV_NET_CORE | Developer Interview Preparation",
+  },
+  {
+    path: "/content/",
+    canonicalPath: "/content/",
+    index: true,
+    sitemap: true,
+    prerender: true,
+    seoDescription:
+      "Explore structured interview preparation across .NET, architecture, SQL, React, Azure, and modern software engineering topics.",
+    seoTitle: "Software Engineering Interview Curriculum | DEV_NET_CORE",
+  },
+  {
+    path: "/practice/",
+    canonicalPath: "/practice/",
+    index: false,
+    sitemap: false,
+    prerender: false,
+    seoDescription:
+      "Practice topic-based software engineering interview questions with expected answers, key points, and progress tracking.",
+    seoTitle: "Technical Interview Practice | DEV_NET_CORE",
+  },
+  {
+    path: "/simulation/",
+    canonicalPath: "/simulation/",
+    index: false,
+    sitemap: false,
+    prerender: false,
+    seoDescription:
+      "Practice a realistic technical interview session by selecting focus topics, difficulty level, and question count.",
+    seoTitle: "Mock Interview Simulation | DEV_NET_CORE",
+  },
+  {
+    path: "/simulation/setup/",
+    canonicalPath: "/simulation/setup/",
+    index: false,
+    sitemap: false,
+    prerender: false,
+    seoDescription:
+      "Configure focus topics, difficulty, and question count for a DEV_NET_CORE mock interview session.",
+    seoTitle: "Set Up a Mock Interview | DEV_NET_CORE",
+  },
+  {
+    path: "/roadmap/",
+    canonicalPath: "/roadmap/",
+    index: true,
+    sitemap: true,
+    prerender: true,
+    seoDescription:
+      "Explore the DEV_NET_CORE roadmap for structured technical learning, interview practice, and simulation improvements.",
+    seoTitle: "Developer Interview Preparation Roadmap | DEV_NET_CORE",
+  },
+  {
+    path: "/about-us/",
+    canonicalPath: "/about-us/",
+    index: true,
+    sitemap: true,
+    prerender: true,
+    seoDescription:
+      "Learn how DEV_NET_CORE helps software engineers prepare for technical interviews with structured content and realistic practice.",
+    seoTitle: "About DEV_NET_CORE | Developer Interview Preparation",
+  },
+  {
+    path: "/changelog/",
+    canonicalPath: "/changelog/",
+    index: false,
+    sitemap: false,
+    prerender: false,
+    seoDescription:
+      "Review updates and improvements to DEV_NET_CORE interview preparation content, practice, and simulations.",
+    seoTitle: "DEV_NET_CORE Changelog",
+  },
+  {
+    path: "/bug-report/",
+    canonicalPath: "/bug-report/",
+    index: false,
+    sitemap: false,
+    prerender: false,
+    seoDescription:
+      "Report a problem with DEV_NET_CORE content, navigation, interview practice, or simulation workflows.",
+    seoTitle: "Report a Bug | DEV_NET_CORE",
+  },
+  {
+    path: "/privacy/",
+    canonicalPath: "/privacy/",
+    index: true,
+    sitemap: true,
+    prerender: true,
+    seoDescription:
+      "Review the DEV_NET_CORE privacy policy for the developer interview preparation website.",
+    seoTitle: "Privacy Policy | DEV_NET_CORE",
+  },
+  {
+    path: "/terms/",
+    canonicalPath: "/terms/",
+    index: true,
+    sitemap: true,
+    prerender: true,
+    seoDescription:
+      "Review the terms of use for the DEV_NET_CORE developer interview preparation website.",
+    seoTitle: "Terms of Use | DEV_NET_CORE",
+  },
+];
+
+export function validateStaticSeoRoutes(routes) {
+  if (!Array.isArray(routes)) {
+    throw new TypeError("Static SEO routes must be an array.");
+  }
+
+  const seenPaths = new Set();
+  const seenIndexableDescriptions = new Set();
+  const seenIndexableTitles = new Set();
+
+  routes.forEach((route, index) => {
+    const label = route?.path || `entry ${index}`;
+
+    if (!route || typeof route !== "object" || Array.isArray(route)) {
+      throw new TypeError(`Static SEO route ${label} must be an object.`);
+    }
+
+    if (!isCanonicalPath(route.path)) {
+      throw new Error(
+        `Static SEO route path "${route.path}" must be "/" or a lowercase trailing-slash path.`
+      );
+    }
+
+    if (seenPaths.has(route.path)) {
+      throw new Error(`Duplicate static SEO route path "${route.path}".`);
+    }
+
+    seenPaths.add(route.path);
+
+    if (!isCanonicalPath(route.canonicalPath)) {
+      throw new Error(
+        `Canonical path "${route.canonicalPath}" for ${label} must be "/" or a lowercase trailing-slash path.`
+      );
+    }
+
+    for (const flag of ["index", "sitemap", "prerender"]) {
+      if (typeof route[flag] !== "boolean") {
+        throw new TypeError(`Static SEO route ${label} must define boolean ${flag}.`);
+      }
+    }
+
+    for (const field of ["seoTitle", "seoDescription"]) {
+      if (typeof route[field] !== "string" || !route[field].trim()) {
+        throw new TypeError(
+          `Static SEO route ${label} must define non-empty ${field}.`
+        );
+      }
+    }
+
+    if (route.index && route.canonicalPath !== route.path) {
+      throw new Error(`Indexable static SEO route ${label} must be self-canonical.`);
+    }
+
+    if (route.index) {
+      if (seenIndexableTitles.has(route.seoTitle)) {
+        throw new Error(
+          `Indexable static SEO route ${label} must have a unique seoTitle.`
+        );
+      }
+
+      if (seenIndexableDescriptions.has(route.seoDescription)) {
+        throw new Error(
+          `Indexable static SEO route ${label} must have a unique seoDescription.`
+        );
+      }
+
+      seenIndexableTitles.add(route.seoTitle);
+      seenIndexableDescriptions.add(route.seoDescription);
+    }
+
+    if (
+      route.sitemap &&
+      (!route.index ||
+        !route.prerender ||
+        route.canonicalPath !== route.path)
+    ) {
+      throw new Error(
+        `Sitemap route ${label} must be indexable, pre-rendered, and self-canonical.`
+      );
+    }
+  });
+}
+
+function isCanonicalPath(value) {
+  return (
+    value === "/" ||
+    (typeof value === "string" &&
+      /^\/(?:[a-z0-9]+(?:-[a-z0-9]+)*\/)+$/.test(value))
+  );
+}
+
+validateStaticSeoRoutes(routeDefinitions);
+
+export const staticSeoRoutes = Object.freeze(
+  routeDefinitions.map((route) => Object.freeze({ ...route }))
+);
+
+export function getStaticSeoRoute(path) {
+  return staticSeoRoutes.find((route) => route.path === path);
+}
diff --git a/spikes/react-router-7-ssg/README.md b/spikes/react-router-7-ssg/README.md
new file mode 100644
index 0000000..a392b30
--- /dev/null
+++ b/spikes/react-router-7-ssg/README.md
@@ -0,0 +1,30 @@
+# React Router 7 SSG Spike
+
+This isolated proof tests React Router framework-mode pre-rendering without
+changing the production Vite SPA.
+
+The findings and implementation recommendation are recorded in
+[`docs/spikes/react-router-7-ssg-spike.md`](../../docs/spikes/react-router-7-ssg-spike.md).
+
+Run it from the repository root:
+
+```bash
+npm run spike:ssg:build
+```
+
+The spike intentionally proves only the architecture boundaries:
+
+- `ssr: false` static-file output
+- initial route discovery without a runtime `/__manifest` endpoint
+- dynamic pre-render paths read from the Node-readable curriculum SEO manifest
+- Markdown and metadata loaded before rendering
+- trailing-slash static output
+- hydration data emitted alongside HTML
+- production providers and content rendered from initial route data
+
+React Router requires `react-router.config.ts` at the framework project root.
+The repository-level config points back to this isolated app directory; the
+normal Vite build does not use it.
+
+The generated output is written to `build/client` inside this directory and is
+ignored by Git.
diff --git a/spikes/react-router-7-ssg/app/entry.server.tsx b/spikes/react-router-7-ssg/app/entry.server.tsx
new file mode 100644
index 0000000..95df630
--- /dev/null
+++ b/spikes/react-router-7-ssg/app/entry.server.tsx
@@ -0,0 +1,36 @@
+import { PassThrough } from "node:stream";
+import { createReadableStreamFromReadable } from "@react-router/node";
+import type { EntryContext } from "react-router";
+import { ServerRouter } from "react-router";
+import { renderToPipeableStream } from "react-dom/server";
+
+export default function handleRequest(
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  routerContext: EntryContext
+) {
+  return new Promise<Response>((resolve, reject) => {
+    const { pipe } = renderToPipeableStream(
+      <ServerRouter context={routerContext} url={request.url} />,
+      {
+        onAllReady() {
+          const body = new PassThrough();
+          const stream = createReadableStreamFromReadable(body);
+
+          responseHeaders.set("Content-Type", "text/html");
+          pipe(body);
+          resolve(
+            new Response(stream, {
+              headers: responseHeaders,
+              status: responseStatusCode,
+            })
+          );
+        },
+        onShellError(error) {
+          reject(error);
+        },
+      }
+    );
+  });
+}
diff --git a/spikes/react-router-7-ssg/app/lib/content.server.ts b/spikes/react-router-7-ssg/app/lib/content.server.ts
new file mode 100644
index 0000000..0473465
--- /dev/null
+++ b/spikes/react-router-7-ssg/app/lib/content.server.ts
@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildSeoMetadata } from "../../../../shared/seo/buildSeoMetadata.mjs";
+
+type SeoEntry = {
+  canonicalPath: string;
+  category: string;
+  contentPath: string;
+  id: string;
+  seoDescription: string;
+  seoTitle: string;
+  subtopic: string;
+  title: string;
+  topic: string;
+};
+
+type SeoManifest = {
+  entries: SeoEntry[];
+};
+
+const repositoryRoot = fileURLToPath(new URL("../../../../", import.meta.url));
+const manifestPath = path.join(
+  repositoryRoot,
+  "shared/content/curriculumSeoManifest.generated.json"
+);
+const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")) as SeoManifest;
+
+export function loadTopic(topicId: string) {
+  const entry = manifest.entries.find((item) => item.id === topicId);
+
+  if (!entry) {
+    throw new Response("Not Found", { status: 404 });
+  }
+
+  const source = fs.readFileSync(
+    path.join(repositoryRoot, entry.contentPath),
+    "utf8"
+  );
+
+  return {
+    entry,
+    markdown: stripFrontmatter(source),
+    metadata: buildSeoMetadata({
+      contentEntry: entry,
+      pathname: entry.canonicalPath,
+    }),
+  };
+}
+
+export function getFirstTopicPath() {
+  const canonicalPath = manifest.entries[0]?.canonicalPath;
+
+  if (!canonicalPath) {
+    throw new Error("The curriculum SEO manifest must contain at least one topic.");
+  }
+
+  return canonicalPath;
+}
+
+function stripFrontmatter(markdown: string) {
+  return markdown.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "").trim();
+}
diff --git a/spikes/react-router-7-ssg/app/root.tsx b/spikes/react-router-7-ssg/app/root.tsx
new file mode 100644
index 0000000..bc07e4b
--- /dev/null
+++ b/spikes/react-router-7-ssg/app/root.tsx
@@ -0,0 +1,30 @@
+import {
+  Links,
+  Meta,
+  Outlet,
+  Scripts,
+  ScrollRestoration,
+} from "react-router";
+
+export function Layout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <head>
+        <meta charSet="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <link rel="icon" href="/icon.png" />
+        <Meta />
+        <Links />
+      </head>
+      <body>
+        {children}
+        <ScrollRestoration />
+        <Scripts />
+      </body>
+    </html>
+  );
+}
+
+export default function Root() {
+  return <Outlet />;
+}
diff --git a/spikes/react-router-7-ssg/app/routes.ts b/spikes/react-router-7-ssg/app/routes.ts
new file mode 100644
index 0000000..fc71db8
--- /dev/null
+++ b/spikes/react-router-7-ssg/app/routes.ts
@@ -0,0 +1,11 @@
+import { index, route, type RouteConfig } from "@react-router/dev/routes";
+
+export default [
+  index("./routes/home.tsx"),
+  route("content/", "./routes/content.tsx"),
+  route("content/:topicId/", "./routes/content-topic.tsx"),
+  route(
+    "readiness/content/:topicId/",
+    "./routes/readiness-content.tsx"
+  ),
+] satisfies RouteConfig;
diff --git a/spikes/react-router-7-ssg/app/routes/content-topic.tsx b/spikes/react-router-7-ssg/app/routes/content-topic.tsx
new file mode 100644
index 0000000..1242ac1
--- /dev/null
+++ b/spikes/react-router-7-ssg/app/routes/content-topic.tsx
@@ -0,0 +1,44 @@
+import type { LoaderFunctionArgs, MetaFunction } from "react-router";
+import { Link, useLoaderData } from "react-router";
+import { loadTopic } from "../lib/content.server";
+
+export function loader({ params }: LoaderFunctionArgs) {
+  return loadTopic(params.topicId ?? "");
+}
+
+export const meta: MetaFunction<typeof loader> = ({ data }) => {
+  if (!data) {
+    return [{ title: "Page Not Found | DEV_NET_CORE" }];
+  }
+
+  return [
+    { title: data.metadata.title },
+    { name: "description", content: data.metadata.description },
+    { tagName: "link", rel: "canonical", href: data.metadata.canonicalUrl },
+    { property: "og:title", content: data.metadata.openGraph.title },
+    {
+      property: "og:description",
+      content: data.metadata.openGraph.description,
+    },
+    { property: "og:url", content: data.metadata.openGraph.url },
+    { property: "og:image", content: data.metadata.openGraph.image },
+  ];
+};
+
+export default function ContentTopic() {
+  const { entry, markdown, metadata } = useLoaderData<typeof loader>();
+
+  return (
+    <main>
+      <Link to="/content/">Curriculum</Link>
+      <h1>{entry.subtopic}</h1>
+      <pre data-route-markdown>{markdown}</pre>
+      <script
+        dangerouslySetInnerHTML={{
+          __html: JSON.stringify(metadata.structuredData),
+        }}
+        type="application/ld+json"
+      />
+    </main>
+  );
+}
diff --git a/spikes/react-router-7-ssg/app/routes/content.tsx b/spikes/react-router-7-ssg/app/routes/content.tsx
new file mode 100644
index 0000000..8190956
--- /dev/null
+++ b/spikes/react-router-7-ssg/app/routes/content.tsx
@@ -0,0 +1,27 @@
+import type { MetaFunction } from "react-router";
+import { Link, useLoaderData } from "react-router";
+import { getFirstTopicPath } from "../lib/content.server";
+
+export function loader() {
+  return { firstTopicPath: getFirstTopicPath() };
+}
+
+export const meta: MetaFunction = () => [
+  { title: "Software Engineering Interview Curriculum | DEV_NET_CORE" },
+  {
+    name: "description",
+    content: "Explore the DEV_NET_CORE interview preparation curriculum.",
+  },
+];
+
+export default function ContentIndex() {
+  const { firstTopicPath } = useLoaderData<typeof loader>();
+
+  return (
+    <main>
+      <h1>Software Engineering Interview Curriculum</h1>
+      <p>This route proves static output for the curriculum landing page.</p>
+      <Link to={firstTopicPath}>Open pre-rendered topic</Link>
+    </main>
+  );
+}
diff --git a/spikes/react-router-7-ssg/app/routes/home.tsx b/spikes/react-router-7-ssg/app/routes/home.tsx
new file mode 100644
index 0000000..2725021
--- /dev/null
+++ b/spikes/react-router-7-ssg/app/routes/home.tsx
@@ -0,0 +1,18 @@
+import type { MetaFunction } from "react-router";
+
+export const meta: MetaFunction = () => [
+  { title: "DEV_NET_CORE SSG Spike" },
+  {
+    name: "description",
+    content: "React Router framework-mode static generation proof.",
+  },
+];
+
+export default function Home() {
+  return (
+    <main>
+      <h1>DEV_NET_CORE SSG Spike</h1>
+      <p>This content was rendered into the initial HTML at build time.</p>
+    </main>
+  );
+}
diff --git a/spikes/react-router-7-ssg/app/routes/readiness-content.tsx b/spikes/react-router-7-ssg/app/routes/readiness-content.tsx
new file mode 100644
index 0000000..b9682cb
--- /dev/null
+++ b/spikes/react-router-7-ssg/app/routes/readiness-content.tsx
@@ -0,0 +1,25 @@
+import type { LoaderFunctionArgs } from "react-router";
+import { useLoaderData } from "react-router";
+import { AppProviders } from "../../../../src/AppProviders";
+import Content from "../../../../src/pages/Content";
+import { loadTopic } from "../lib/content.server";
+
+export function loader({ params }: LoaderFunctionArgs) {
+  return loadTopic(params.topicId ?? "");
+}
+
+export default function ReadinessContent() {
+  const { entry, markdown } = useLoaderData<typeof loader>();
+
+  return (
+    <AppProviders>
+      <Content
+        initialRouteData={{
+          kind: "topic",
+          markdown,
+          topic: entry,
+        }}
+      />
+    </AppProviders>
+  );
+}
diff --git a/spikes/react-router-7-ssg/package.json b/spikes/react-router-7-ssg/package.json
new file mode 100644
index 0000000..1363096
--- /dev/null
+++ b/spikes/react-router-7-ssg/package.json
@@ -0,0 +1,5 @@
+{
+  "name": "dev-net-core-react-router-ssg-spike",
+  "private": true,
+  "type": "module"
+}
diff --git a/spikes/react-router-7-ssg/vite.config.ts b/spikes/react-router-7-ssg/vite.config.ts
new file mode 100644
index 0000000..e78f586
--- /dev/null
+++ b/spikes/react-router-7-ssg/vite.config.ts
@@ -0,0 +1,8 @@
+import { fileURLToPath } from "node:url";
+import { reactRouter } from "@react-router/dev/vite";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  plugins: [reactRouter()],
+  root: fileURLToPath(new URL("../..", import.meta.url)),
+});
diff --git a/src/App.tsx b/src/App.tsx
index 2c82343..389be6e 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,5 +1,11 @@
-import { Route, Routes } from "react-router-dom";
+import {
+  Navigate,
+  Route,
+  Routes,
+  useLocation,
+} from "react-router-dom";
 import "./App.css";
+import { Seo } from "./components/seo/Seo";
 import AboutUs from "./pages/AboutUs";
 import BugReport from "./pages/BugReport";
 import Changelog from "./pages/Changelog";
@@ -14,35 +20,63 @@ import SimulationResult from "./pages/SimulationResult";
 import SimulationSession from "./pages/SimulationSession";
 import Terms from "./pages/Terms";
 import { MainLayout } from "./layouts/MainLayout";
+import { getCanonicalPathname } from "./routing/canonicalPath";
 
 function App() {
   return (
     <>
-      <Routes>
-        <Route element={<MainLayout />}>
-          <Route path="/" element={<Home />} />
-          <Route path="/home" element={<Home />} />
-          <Route path="/content" element={<Content />} />
-          <Route path="/content/:topicId" element={<Content />} />
-          <Route path="/content/:topicId/" element={<Content />} />
-          <Route path="/about-us" element={<AboutUs />} />
-          <Route path="/bug-report" element={<BugReport />} />
-          <Route path="/changelog" element={<Changelog />} />
-          <Route path="/privacy" element={<Privacy />} />
-          <Route path="/roadmap" element={<Roadmap />} />
-          <Route path="/terms" element={<Terms />} />
-          <Route path="/practice" element={<Practice />} />
-          <Route path="/practice/:topicId" element={<Practice />} />
-          <Route path="/practice/:topicId/" element={<Practice />} />
-          <Route path="/simulation" element={<Simulation />} />
-          <Route path="/simulation/setup" element={<Simulation />} />
-          <Route path="/simulation/session/:sessionId" element={<SimulationSession />} />
-          <Route path="/simulation/result/:sessionId" element={<SimulationResult />} />
-          <Route path="*" element={<NotFound />} />
-        </Route>
-      </Routes>
+      <Seo />
+      <AppRoutes />
     </>
   );
 }
 
+function AppRoutes() {
+  const location = useLocation();
+  const canonicalPathname = getCanonicalPathname(location.pathname);
+
+  if (canonicalPathname) {
+    return (
+      <Navigate
+        replace
+        state={location.state}
+        to={{
+          hash: location.hash,
+          pathname: canonicalPathname,
+          search: location.search,
+        }}
+      />
+    );
+  }
+
+  return (
+    <Routes>
+      <Route element={<MainLayout />}>
+        <Route path="/" element={<Home />} />
+        <Route path="/content/" element={<Content />} />
+        <Route path="/content/:topicId/" element={<Content />} />
+        <Route path="/about-us/" element={<AboutUs />} />
+        <Route path="/bug-report/" element={<BugReport />} />
+        <Route path="/changelog/" element={<Changelog />} />
+        <Route path="/privacy/" element={<Privacy />} />
+        <Route path="/roadmap/" element={<Roadmap />} />
+        <Route path="/terms/" element={<Terms />} />
+        <Route path="/practice/" element={<Practice />} />
+        <Route path="/practice/:topicId/" element={<Practice />} />
+        <Route path="/simulation/" element={<Simulation />} />
+        <Route path="/simulation/setup/" element={<Simulation />} />
+        <Route
+          path="/simulation/session/:sessionId"
+          element={<SimulationSession />}
+        />
+        <Route
+          path="/simulation/result/:sessionId"
+          element={<SimulationResult />}
+        />
+        <Route path="*" element={<NotFound />} />
+      </Route>
+    </Routes>
+  );
+}
+
 export default App;
diff --git a/src/AppProviders.tsx b/src/AppProviders.tsx
new file mode 100644
index 0000000..89ab8e6
--- /dev/null
+++ b/src/AppProviders.tsx
@@ -0,0 +1,44 @@
+import { useEffect, useState, type ReactNode } from "react";
+import { Provider } from "react-redux";
+import {
+  createAppStore,
+  type AppPreloadedState,
+  type AppStore,
+} from "./lib/redux/createAppStore";
+import { AppThemeModeProvider } from "./theme/ThemeModeProvider";
+import type { AppThemeMode } from "./theme/themeMode";
+import { hydrateBrowserStoreFromPersistence } from "./lib/redux/persistence";
+
+type AppProvidersProps = {
+  children: ReactNode;
+  hydrateBrowserPersistence?: boolean;
+  initialThemeMode?: AppThemeMode;
+  preloadedState?: AppPreloadedState;
+  store?: AppStore;
+};
+
+export function AppProviders({
+  children,
+  hydrateBrowserPersistence = false,
+  initialThemeMode = "dark",
+  preloadedState,
+  store,
+}: AppProvidersProps) {
+  const [appStore] = useState(() => store ?? createAppStore(preloadedState));
+
+  useEffect(() => {
+    if (!hydrateBrowserPersistence) {
+      return;
+    }
+
+    return hydrateBrowserStoreFromPersistence(appStore);
+  }, [appStore, hydrateBrowserPersistence]);
+
+  return (
+    <Provider store={appStore}>
+      <AppThemeModeProvider initialMode={initialThemeMode}>
+        {children}
+      </AppThemeModeProvider>
+    </Provider>
+  );
+}
diff --git a/src/components/AppFooter.tsx b/src/components/AppFooter.tsx
index 14b189f..425d97c 100644
--- a/src/components/AppFooter.tsx
+++ b/src/components/AppFooter.tsx
@@ -20,10 +20,10 @@ const FOOTER_LINKS: FooterLink[] = [
     href: "https://github.com/CircleQMinh/dev-net-core",
     external: true,
   },
-  { label: "Changelog", to: "/changelog", external: false },
-  { label: "Bug report", to: "/bug-report", external: false },
-  { label: "Terms", to: "/terms", external: false },
-  { label: "Privacy", to: "/privacy", external: false },
+  { label: "Changelog", to: "/changelog/", external: false },
+  { label: "Bug report", to: "/bug-report/", external: false },
+  { label: "Terms", to: "/terms/", external: false },
+  { label: "Privacy", to: "/privacy/", external: false },
 ];
 
 function scrollToPageTop() {
diff --git a/src/components/AppHeader.tsx b/src/components/AppHeader.tsx
index 3ddb670..b18bf28 100644
--- a/src/components/AppHeader.tsx
+++ b/src/components/AppHeader.tsx
@@ -4,19 +4,18 @@ import MenuIcon from "@mui/icons-material/Menu";
 import { Box, Button, IconButton, Menu, MenuItem, Tooltip } from "@mui/material";
 import { useState } from "react";
 import type { MouseEvent } from "react";
-import { useNavigate } from "react-router-dom";
+import { Link as RouterLink } from "react-router-dom";
 import { useAppThemeMode } from "../theme/themeMode";
 
 const NAV_ITEMS = {
-  "Learning": "/content#dotnet",
-  "Practice": "/practice",
-  "Simulation": "/simulation",
-  "Roadmap": "/roadmap",
-  "About Us": "/about-us",
+  "Learning": "/content/#dotnet",
+  "Practice": "/practice/",
+  "Simulation": "/simulation/",
+  "Roadmap": "/roadmap/",
+  "About Us": "/about-us/",
 };
 
 export function AppHeader() {
-  const navigate = useNavigate();
   const { mode, tokens, toggleMode } = useAppThemeMode();
   const [menuAnchor, setMenuAnchor] = useState<HTMLElement | null>(null);
 
@@ -35,16 +34,11 @@ export function AppHeader() {
     });
   };
 
-  const navigateFromHeader = (path: string) => {
+  const handleMenuNavigation = () => {
     closeMenu();
-    navigate(path);
     scrollToPageTop();
   };
 
-  const goHome = () => {
-    navigateFromHeader("/");
-  };
-
   return (
     <Box
       component="header"
@@ -72,8 +66,9 @@ export function AppHeader() {
       }}
     >
       <Button
+        component={RouterLink}
         disableRipple
-        onClick={goHome}
+        onClick={scrollToPageTop}
         sx={{
           color: tokens.onSurface,
           fontFamily: '"Space Grotesk", "Inter", sans-serif',
@@ -90,6 +85,7 @@ export function AppHeader() {
             color: tokens.primaryContainer,
           },
         }}
+        to="/"
       >
         DEV_NET_CORE
       </Button>
@@ -104,9 +100,10 @@ export function AppHeader() {
       >
         {Object.entries(NAV_ITEMS).map(([label, path]) => (
           <Button
+            component={RouterLink}
             disableRipple
             key={label}
-            onClick={() => navigateFromHeader(path)}
+            onClick={scrollToPageTop}
             sx={{
               color: tokens.onSurfaceVariant,
               fontFamily: '"Space Grotesk", "Inter", sans-serif',
@@ -123,7 +120,7 @@ export function AppHeader() {
                 transform: "translateY(-1px)",
               },
             }}
-            type="button"
+            to={path}
           >
             {label}
           </Button>
@@ -158,8 +155,9 @@ export function AppHeader() {
         </Tooltip>
 
         <Button
+          component={RouterLink}
           disableElevation
-          onClick={() => navigateFromHeader("/content")}
+          onClick={scrollToPageTop}
           sx={{
             backgroundColor: tokens.primaryContainer,
             borderRadius: "2px",
@@ -182,7 +180,7 @@ export function AppHeader() {
               transform: "scale(0.95)",
             },
           }}
-          type="button"
+          to="/content/"
         >
           GET_STARTED
         </Button>
@@ -219,8 +217,9 @@ export function AppHeader() {
         >
           {Object.entries(NAV_ITEMS).map(([label, path]) => (
             <MenuItem
+              component={RouterLink}
               key={label}
-              onClick={() => navigateFromHeader(path)}
+              onClick={handleMenuNavigation}
               sx={{
                 color: tokens.onSurfaceVariant,
                 fontFamily: '"Space Grotesk", "Inter", sans-serif',
@@ -232,12 +231,14 @@ export function AppHeader() {
                   color: tokens.onSurface,
                 },
               }}
+              to={path}
             >
               {label}
             </MenuItem>
           ))}
           <MenuItem
-            onClick={() => navigateFromHeader("/content")}
+            component={RouterLink}
+            onClick={handleMenuNavigation}
             sx={{
               color: tokens.primaryContainer,
               display: { xs: "flex", sm: "none" },
@@ -247,6 +248,7 @@ export function AppHeader() {
               letterSpacing: "0.05em",
               textTransform: "uppercase",
             }}
+            to="/content/"
           >
             GET_STARTED
           </MenuItem>
diff --git a/src/components/content/CurriculumTreeView.tsx b/src/components/content/CurriculumTreeView.tsx
index 0ab3411..091935d 100644
--- a/src/components/content/CurriculumTreeView.tsx
+++ b/src/components/content/CurriculumTreeView.tsx
@@ -7,6 +7,7 @@ import FolderOpenOutlinedIcon from "@mui/icons-material/FolderOpenOutlined";
 import FolderOutlinedIcon from "@mui/icons-material/FolderOutlined";
 import RestartAltOutlinedIcon from "@mui/icons-material/RestartAltOutlined";
 import { useEffect, useMemo, useState } from "react";
+import { Link as RouterLink } from "react-router-dom";
 import { useAppDispatch, useAppSelector } from "../../lib/redux/hooks/hooks";
 import { selectContentProgress } from "../../lib/redux/selectors/contentSelectors";
 import {
@@ -587,8 +588,9 @@ function TreeNodeRow({
     const isActive = activeTopicId === node.id;
 
     return (
-      <button
-        className={`flex w-full cursor-pointer items-start justify-between gap-2 border-r-2 py-1 pr-2 text-left transition-colors ${
+      <RouterLink
+        aria-current={isActive ? "page" : undefined}
+        className={`flex w-full cursor-pointer items-start justify-between gap-2 border-r-2 py-1 pr-2 text-left no-underline transition-colors ${
           isActive
             ? "theme-ide-active"
             : "border-transparent theme-muted theme-ide-hover"
@@ -596,7 +598,7 @@ function TreeNodeRow({
         onClick={() => onSelectTopic(node)}
         style={{ paddingLeft: `${depth * 12 + 8}px` }}
         title={node.contentPath}
-        type="button"
+        to={`/content/${node.id}/`}
       >
         <span className="flex min-w-0 flex-1 items-start gap-1.5">
           <InsertDriveFileOutlinedIcon
@@ -622,7 +624,7 @@ function TreeNodeRow({
             </span>
           )
         ) : null}
-      </button>
+      </RouterLink>
     );
   }
 
diff --git a/src/components/content/contentRouteData.ts b/src/components/content/contentRouteData.ts
new file mode 100644
index 0000000..4a1dd6b
--- /dev/null
+++ b/src/components/content/contentRouteData.ts
@@ -0,0 +1,50 @@
+export type ContentRouteTopicData = {
+  canonicalPath: string;
+  category: string;
+  contentPath: string;
+  id: string;
+  questionCount?: number;
+  seoDescription: string;
+  seoTitle: string;
+  subtopic: string;
+  title: string;
+  topic: string;
+};
+
+export type ContentRouteData =
+  | {
+      kind: "not-found";
+      topicId: string;
+    }
+  | {
+      kind: "topic";
+      markdown: string;
+      topic: ContentRouteTopicData;
+    }
+  | {
+      kind: "welcome";
+      markdown: string;
+    };
+
+export function getMatchingContentRouteData(
+  routeData: ContentRouteData | undefined,
+  topicId: string | undefined
+) {
+  if (!routeData) {
+    return undefined;
+  }
+
+  if (!topicId) {
+    return routeData.kind === "welcome" ? routeData : undefined;
+  }
+
+  if (routeData.kind === "topic" && routeData.topic.id === topicId) {
+    return routeData;
+  }
+
+  if (routeData.kind === "not-found" && routeData.topicId === topicId) {
+    return routeData;
+  }
+
+  return undefined;
+}
diff --git a/src/components/content/loadClientContentRouteData.ts b/src/components/content/loadClientContentRouteData.ts
new file mode 100644
index 0000000..103c3b0
--- /dev/null
+++ b/src/components/content/loadClientContentRouteData.ts
@@ -0,0 +1,46 @@
+import { curriculumManifest } from "../../contents/curriculumManifest.generated";
+import welcomeMarkdown from "../../contents/resources/welcome.md?raw";
+import { findCurriculumSubTopicById } from "./CurriculumTreeView";
+import type { ContentRouteData } from "./contentRouteData";
+
+const curriculumEntriesById = new Map(
+  curriculumManifest.map((entry) => [entry.id, entry])
+);
+
+export async function loadClientContentRouteData(
+  topicId?: string
+): Promise<ContentRouteData> {
+  if (!topicId) {
+    return {
+      kind: "welcome",
+      markdown: welcomeMarkdown,
+    };
+  }
+
+  const entry = curriculumEntriesById.get(topicId);
+  const topic = findCurriculumSubTopicById(topicId);
+
+  if (!entry || !topic) {
+    return {
+      kind: "not-found",
+      topicId,
+    };
+  }
+
+  return {
+    kind: "topic",
+    markdown: await topic.loadContent(),
+    topic: {
+      canonicalPath: entry.canonicalPath,
+      category: entry.category,
+      contentPath: entry.contentPath,
+      id: entry.id,
+      questionCount: entry.questionCount,
+      seoDescription: entry.seoDescription,
+      seoTitle: entry.seoTitle,
+      subtopic: entry.subtopic,
+      title: entry.title,
+      topic: entry.topic,
+    },
+  };
+}
diff --git a/src/components/seo/Seo.tsx b/src/components/seo/Seo.tsx
new file mode 100644
index 0000000..0bfa4e4
--- /dev/null
+++ b/src/components/seo/Seo.tsx
@@ -0,0 +1,146 @@
+import { useEffect, useMemo } from "react";
+import { useLocation } from "react-router-dom";
+import {
+  buildSeoMetadata,
+  type SeoMetadata,
+  type SeoStructuredData,
+} from "../../../shared/seo/buildSeoMetadata.mjs";
+import { curriculumManifest } from "../../contents/curriculumManifest.generated";
+
+const STRUCTURED_DATA_SELECTOR =
+  'script[type="application/ld+json"][data-dev-net-core-seo="structured-data"]';
+
+const curriculumEntriesById = new Map(
+  curriculumManifest.map((entry) => [entry.id, entry])
+);
+
+export function Seo() {
+  const { pathname } = useLocation();
+  const metadata = useMemo(
+    () =>
+      buildSeoMetadata({
+        contentEntry: findCurriculumEntry(pathname),
+        pathname,
+      }),
+    [pathname]
+  );
+
+  useEffect(() => {
+    applySeoMetadata(metadata);
+  }, [metadata]);
+
+  return null;
+}
+
+function findCurriculumEntry(pathname: string) {
+  const topicId = pathname.match(
+    /^\/(?:content|practice)\/([a-z0-9][a-z0-9-]*)\/?$/
+  )?.[1];
+
+  return topicId ? curriculumEntriesById.get(topicId) : undefined;
+}
+
+function applySeoMetadata(metadata: SeoMetadata) {
+  document.title = metadata.title;
+
+  upsertMetaByName("description", metadata.description);
+  upsertMetaByName("robots", metadata.robots);
+
+  upsertMetaByProperty("og:title", metadata.openGraph.title);
+  upsertMetaByProperty("og:description", metadata.openGraph.description);
+  upsertMetaByProperty("og:type", metadata.openGraph.type);
+  upsertMetaByProperty("og:image", metadata.openGraph.image);
+  upsertMetaByProperty(
+    "og:image:width",
+    String(metadata.openGraph.imageWidth)
+  );
+  upsertMetaByProperty(
+    "og:image:height",
+    String(metadata.openGraph.imageHeight)
+  );
+  upsertMetaByProperty("og:image:alt", metadata.openGraph.imageAlt);
+
+  upsertMetaByName("twitter:card", metadata.twitter.card);
+  upsertMetaByName("twitter:title", metadata.twitter.title);
+  upsertMetaByName("twitter:description", metadata.twitter.description);
+  upsertMetaByName("twitter:image", metadata.twitter.image);
+
+  if (metadata.canonicalUrl) {
+    upsertCanonical(metadata.canonicalUrl);
+  } else {
+    removeHeadElements('link[rel="canonical"]');
+  }
+
+  if (metadata.openGraph.url) {
+    upsertMetaByProperty("og:url", metadata.openGraph.url);
+  } else {
+    removeHeadElements('meta[property="og:url"]');
+  }
+
+  if (metadata.structuredData) {
+    upsertStructuredData(metadata.structuredData);
+  } else {
+    removeHeadElements(STRUCTURED_DATA_SELECTOR);
+  }
+}
+
+function upsertMetaByName(name: string, content: string) {
+  upsertHeadElement("meta", `meta[name="${name}"]`, {
+    content,
+    name,
+  });
+}
+
+function upsertMetaByProperty(property: string, content: string) {
+  upsertHeadElement("meta", `meta[property="${property}"]`, {
+    content,
+    property,
+  });
+}
+
+function upsertCanonical(href: string) {
+  upsertHeadElement("link", 'link[rel="canonical"]', {
+    href,
+    rel: "canonical",
+  });
+}
+
+function upsertStructuredData(structuredData: SeoStructuredData) {
+  const existingElement =
+    document.head.querySelector<HTMLScriptElement>(
+      STRUCTURED_DATA_SELECTOR
+    );
+  const element = existingElement ?? document.createElement("script");
+
+  element.type = "application/ld+json";
+  element.dataset.devNetCoreSeo = "structured-data";
+  element.textContent = JSON.stringify(structuredData);
+
+  if (!existingElement) {
+    document.head.append(element);
+  }
+}
+
+function upsertHeadElement(
+  tagName: "link" | "meta",
+  selector: string,
+  attributes: Record<string, string>
+) {
+  const existingElement = document.head.querySelector<HTMLElement>(selector);
+  const element = existingElement ?? document.createElement(tagName);
+
+  Object.entries(attributes).forEach(([name, value]) => {
+    element.setAttribute(name, value);
+  });
+  element.setAttribute("data-dev-net-core-seo", "true");
+
+  if (!existingElement) {
+    document.head.append(element);
+  }
+}
+
+function removeHeadElements(selector: string) {
+  document.head.querySelectorAll(selector).forEach((element) => {
+    element.remove();
+  });
+}
diff --git a/src/contents/curriculumManifest.generated.ts b/src/contents/curriculumManifest.generated.ts
index 785c079..9152ba4 100644
--- a/src/contents/curriculumManifest.generated.ts
+++ b/src/contents/curriculumManifest.generated.ts
@@ -1,6 +1,12 @@
 // This file is generated by scripts/generate-curriculum-manifest.mjs.
 // Do not edit it by hand.
 
+export type CurriculumManifestCanonicalPathSource =
+  | "frontmatter"
+  | "generated";
+
+export type CurriculumManifestSeoTextSource = "fallback" | "frontmatter";
+
 export type CurriculumManifestFolder = {
   path: string;
   title: string;
@@ -20,6 +26,8 @@ export type CurriculumManifestSampleQuestion = {
 };
 
 export type CurriculumManifestEntry = {
+  canonicalPath: string;
+  canonicalPathSource: CurriculumManifestCanonicalPathSource;
   category: string;
   contentPath: string;
   folders: CurriculumManifestFolder[];
@@ -28,6 +36,10 @@ export type CurriculumManifestEntry = {
   questionCount: number;
   questionLevelCounts: CurriculumManifestQuestionLevelCount[];
   sampleQuestions: CurriculumManifestSampleQuestion[];
+  seoDescription: string;
+  seoDescriptionSource: CurriculumManifestSeoTextSource;
+  seoTitle: string;
+  seoTitleSource: CurriculumManifestSeoTextSource;
   subtopic: string;
   title: string;
   topic: string;
@@ -36,6 +48,8 @@ export type CurriculumManifestEntry = {
 
 export const curriculumManifest: CurriculumManifestEntry[] = [
   {
+    "canonicalPath": "/content/alert-rules-action-groups-and-incident-response-workflows/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/alert-rules-action-groups-and-incident-response-workflows.md",
     "folders": [
@@ -70,12 +84,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you design an actionable alert?"
       }
     ],
+    "seoDescription": "Learn Alert rules, action groups, and incident response workflows for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Alert rules, action groups, and incident response workflows Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Alert rules, action groups, and incident response workflows",
     "title": "Alert rules, action groups, and incident response workflows",
     "topic": "Monitoring, tracing, and incident response on Azure",
     "topicFolderPath": "Azure/monitoring-tracing-and-incident-response-on-azure"
   },
   {
+    "canonicalPath": "/content/app-service-plans-paas-web-hosting-fit/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/app-service-plans-paas-web-hosting-fit.md",
     "folders": [
@@ -110,12 +130,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When is Azure App Service the right hosting choice?"
       }
     ],
+    "seoDescription": "Learn App Service plans and PaaS web hosting fit for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "App Service plans and PaaS web hosting fit Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "App Service plans and PaaS web hosting fit",
     "title": "App Service plans and PaaS web hosting fit",
     "topic": "Azure compute choices and hosting models",
     "topicFolderPath": "Azure/azure-compute-choices-and-hosting-models"
   },
   {
+    "canonicalPath": "/content/application-gateway-and-waf-concepts/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/application-gateway-and-waf-concepts.md",
     "folders": [
@@ -150,12 +176,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you configure TLS from the client through Application Gateway to the backend?"
       }
     ],
+    "seoDescription": "Learn Application Gateway and WAF concepts for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Application Gateway and WAF concepts Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Application Gateway and WAF concepts",
     "title": "Application Gateway and WAF concepts",
     "topic": "Networking, API edge, and secure connectivity",
     "topicFolderPath": "Azure/networking-api-edge-and-secure-connectivity"
   },
   {
+    "canonicalPath": "/content/application-insights-and-opentelemetry-aligned-observability/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/application-insights-and-opentelemetry-aligned-observability.md",
     "folders": [
@@ -190,12 +222,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What should be automatically instrumented versus manually instrumented?"
       }
     ],
+    "seoDescription": "Learn Application Insights and OpenTelemetry-aligned observability for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Application Insights and OpenTelemetry-aligned observability Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Application Insights and OpenTelemetry-aligned observability",
     "title": "Application Insights and OpenTelemetry-aligned observability",
     "topic": "Monitoring, tracing, and incident response on Azure",
     "topicFolderPath": "Azure/monitoring-tracing-and-incident-response-on-azure"
   },
   {
+    "canonicalPath": "/content/azure-api-management-and-policy-based-gateways/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/azure-api-management-and-policy-based-gateways.md",
     "folders": [
@@ -230,12 +268,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do APIM policy scopes and the base element work?"
       }
     ],
+    "seoDescription": "Learn Azure API Management and policy-based gateways for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Azure API Management and policy-based gateways Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Azure API Management and policy-based gateways",
     "title": "Azure API Management and policy-based gateways",
     "topic": "Networking, API edge, and secure connectivity",
     "topicFolderPath": "Azure/networking-api-edge-and-secure-connectivity"
   },
   {
+    "canonicalPath": "/content/azure-cache-for-redis-low-latency-reads-and-session-state-scenarios/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/azure-cache-for-redis-low-latency-reads-and-session-state-scenarios.md",
     "folders": [
@@ -270,12 +314,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you prevent a cache stampede on a popular key?"
       }
     ],
+    "seoDescription": "Learn Azure Cache for Redis for low-latency reads and session/state scenarios for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Azure Cache for Redis for low-latency reads and session/state scenarios Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Azure Cache for Redis for low-latency reads and session/state scenarios",
     "title": "Azure Cache for Redis for low-latency reads and session/state scenarios",
     "topic": "Azure data, storage, and caching services",
     "topicFolderPath": "Azure/azure-data-storage-and-caching-services"
   },
   {
+    "canonicalPath": "/content/azure-container-apps-for-containerized-apis-and-background-workloads/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/azure-container-apps-for-containerized-apis-and-background-workloads.md",
     "folders": [
@@ -310,12 +360,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you host an API and a queue worker in Azure Container Apps?"
       }
     ],
+    "seoDescription": "Learn Azure Container Apps for containerized APIs and background workloads for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Azure Container Apps for containerized APIs and background workloads Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Azure Container Apps for containerized APIs and background workloads",
     "title": "Azure Container Apps for containerized APIs and background workloads",
     "topic": "Azure compute choices and hosting models",
     "topicFolderPath": "Azure/azure-compute-choices-and-hosting-models"
   },
   {
+    "canonicalPath": "/content/azure-functions-hosting-options-and-current-scale-guidance/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/azure-functions-hosting-options-and-current-scale-guidance.md",
     "folders": [
@@ -350,12 +406,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does Azure Functions scale?"
       }
     ],
+    "seoDescription": "Learn Azure Functions Hosting Options and Current Scale Guidance for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Azure Functions Hosting Options and Current Scale Guidance Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Azure Functions Hosting Options and Current Scale Guidance",
     "title": "Azure Functions Hosting Options and Current Scale Guidance",
     "topic": "Azure compute choices and hosting models",
     "topicFolderPath": "Azure/azure-compute-choices-and-hosting-models"
   },
   {
+    "canonicalPath": "/content/azure-key-vault-for-secrets-certificates-and-connection-settings/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/azure-key-vault-for-secrets-certificates-and-connection-settings.md",
     "folders": [
@@ -390,12 +452,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the difference between Key Vault control-plane and data-plane access?"
       }
     ],
+    "seoDescription": "Learn Azure Key Vault for secrets, certificates, and connection settings for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Azure Key Vault for secrets, certificates, and connection settings Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Azure Key Vault for secrets, certificates, and connection settings",
     "title": "Azure Key Vault for secrets, certificates, and connection settings",
     "topic": "Identity, secrets, and access control",
     "topicFolderPath": "Azure/identity-secrets-and-access-control"
   },
   {
+    "canonicalPath": "/content/azure-sql-database-tiers-scaling-serverless-options-and-failover-groups/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/azure-sql-database-tiers-scaling-serverless-options-and-failover-groups.md",
     "folders": [
@@ -430,12 +498,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What happens to application connections when an Azure SQL database is scaled?"
       }
     ],
+    "seoDescription": "Learn Azure SQL Database tiers, scaling, serverless options, and failover groups for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Azure SQL Database tiers, scaling, serverless options, and failover groups Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Azure SQL Database tiers, scaling, serverless options, and failover groups",
     "title": "Azure SQL Database tiers, scaling, serverless options, and failover groups",
     "topic": "Azure data, storage, and caching services",
     "topicFolderPath": "Azure/azure-data-storage-and-caching-services"
   },
   {
+    "canonicalPath": "/content/bicep-fundamentals-modules-and-reusable-environment-definitions/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/bicep-fundamentals-modules-and-reusable-environment-definitions.md",
     "folders": [
@@ -470,12 +544,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you structure Bicep for dev, test, and production environments?"
       }
     ],
+    "seoDescription": "Learn Bicep fundamentals, modules, and reusable environment definitions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Bicep fundamentals, modules, and reusable environment definitions Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Bicep fundamentals, modules, and reusable environment definitions",
     "title": "Bicep fundamentals, modules, and reusable environment definitions",
     "topic": "Delivery, infrastructure as code, scaling, and cost control",
     "topicFolderPath": "Azure/delivery-infrastructure-as-code-scaling-and-cost-control"
   },
   {
+    "canonicalPath": "/content/bindings-connection-configuration-dependency-injection-logging-and-local-development/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/bindings-connection-configuration-dependency-injection-logging-and-local-development.md",
     "folders": [
@@ -510,12 +590,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does an identity-based binding connection work?"
       }
     ],
+    "seoDescription": "Learn Bindings, connection configuration, dependency injection, logging, and local development for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Bindings, connection configuration, dependency injection, logging, and local development Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Bindings, connection configuration, dependency injection, logging, and local development",
     "title": "Bindings, connection configuration, dependency injection, logging, and local development",
     "topic": "Azure Functions and Durable Functions",
     "topicFolderPath": "Azure/azure-functions-and-durable-functions"
   },
   {
+    "canonicalPath": "/content/blob-storage-access-tiers-lifecycle-management-and-immutability/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/blob-storage-access-tiers-lifecycle-management-and-immutability.md",
     "folders": [
@@ -550,12 +636,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you select an access tier using total cost rather than storage price alone?"
       }
     ],
+    "seoDescription": "Learn Blob Storage, access tiers, lifecycle management, and immutability for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Blob Storage, access tiers, lifecycle management, and immutability Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Blob Storage, access tiers, lifecycle management, and immutability",
     "title": "Blob Storage, access tiers, lifecycle management, and immutability",
     "topic": "Azure data, storage, and caching services",
     "topicFolderPath": "Azure/azure-data-storage-and-caching-services"
   },
   {
+    "canonicalPath": "/content/block-blobs-append-blobs-and-page-blobs/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/block-blobs-append-blobs-and-page-blobs.md",
     "folders": [
@@ -590,12 +682,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you make a large block blob upload resumable?"
       }
     ],
+    "seoDescription": "Learn Block blobs, append blobs, and page blobs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Block blobs, append blobs, and page blobs Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Block blobs, append blobs, and page blobs",
     "title": "Block blobs, append blobs, and page blobs",
     "topic": "Azure Blob Storage and file handling",
     "topicFolderPath": "Azure/azure-blob-storage-and-file-handling"
   },
   {
+    "canonicalPath": "/content/choosing-queues-vs-topics-vs-event-notifications/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/choosing-queues-vs-topics-vs-event-notifications.md",
     "folders": [
@@ -630,12 +728,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why is one queue wrong for multiple independent subscribers?"
       }
     ],
+    "seoDescription": "Learn Choosing queues vs topics vs event notifications for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Choosing queues vs topics vs event notifications Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Choosing queues vs topics vs event notifications",
     "title": "Choosing queues vs topics vs event notifications",
     "topic": "Messaging and event-driven Azure integration",
     "topicFolderPath": "Azure/messaging-and-event-driven-azure-integration"
   },
   {
+    "canonicalPath": "/content/cold-starts-hosting-plan-choices-timeout-configuration-and-scaling-behavior/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/cold-starts-hosting-plan-choices-timeout-configuration-and-scaling-behavior.md",
     "folders": [
@@ -670,12 +774,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you reduce cold-start latency for a .NET isolated Function app?"
       }
     ],
+    "seoDescription": "Learn Cold starts, hosting plan choices, timeout configuration, and scaling behavior for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Cold starts, hosting plan choices, timeout configuration, and scaling behavior Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Cold starts, hosting plan choices, timeout configuration, and scaling behavior",
     "title": "Cold starts, hosting plan choices, timeout configuration, and scaling behavior",
     "topic": "Azure Functions and Durable Functions",
     "topicFolderPath": "Azure/azure-functions-and-durable-functions"
   },
   {
+    "canonicalPath": "/content/deployment-slots-rollout-safety-autoscaling-availability-zones-and-cost-aware-tiering/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/deployment-slots-rollout-safety-autoscaling-availability-zones-and-cost-aware-tiering.md",
     "folders": [
@@ -710,12 +820,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What settings should be slot-specific?"
       }
     ],
+    "seoDescription": "Learn Deployment slots, rollout safety, autoscaling, availability zones, and cost-aware tiering for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Deployment slots, rollout safety, autoscaling, availability zones, and cost-aware tiering Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Deployment slots, rollout safety, autoscaling, availability zones, and cost-aware tiering",
     "title": "Deployment slots, rollout safety, autoscaling, availability zones, and cost-aware tiering",
     "topic": "Delivery, infrastructure as code, scaling, and cost control",
     "topicFolderPath": "Azure/delivery-infrastructure-as-code-scaling-and-cost-control"
   },
   {
+    "canonicalPath": "/content/dotnet-blob-clients-direct-browser-upload-and-separating-metadata-from-binary-content/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/dotnet-blob-clients-direct-browser-upload-and-separating-metadata-from-binary-content.md",
     "folders": [
@@ -750,12 +866,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How should Azure Blob SDK clients be registered in dependency injection?"
       }
     ],
+    "seoDescription": "Learn .NET Blob clients, direct browser upload patterns, and storing metadata separately from binary content for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": ".NET Blob clients, direct browser upload patterns, and storing metadata separately from binary content Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": ".NET Blob clients, direct browser upload patterns, and storing metadata separately from binary content",
     "title": ".NET Blob clients, direct browser upload patterns, and storing metadata separately from binary content",
     "topic": "Azure Blob Storage and file handling",
     "topicFolderPath": "Azure/azure-blob-storage-and-file-handling"
   },
   {
+    "canonicalPath": "/content/duplicate-detection-retries-and-poison-message-handling/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/duplicate-detection-retries-and-poison-message-handling.md",
     "folders": [
@@ -790,12 +912,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you choose a duplicate detection window?"
       }
     ],
+    "seoDescription": "Learn Duplicate detection, retries, and poison-message handling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Duplicate detection, retries, and poison-message handling Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Duplicate detection, retries, and poison-message handling",
     "title": "Duplicate detection, retries, and poison-message handling",
     "topic": "Messaging and event-driven Azure integration",
     "topicFolderPath": "Azure/messaging-and-event-driven-azure-integration"
   },
   {
+    "canonicalPath": "/content/durable-functions-orchestrators-activities-timers-external-events-and-entities/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/durable-functions-orchestrators-activities-timers-external-events-and-entities.md",
     "folders": [
@@ -830,12 +958,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why must orchestrator code be deterministic?"
       }
     ],
+    "seoDescription": "Learn Durable Functions orchestrators, activity functions, durable timers, external events, and durable entities for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Durable Functions orchestrators, activity functions, durable timers, external events, and durable entities Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Durable Functions orchestrators, activity functions, durable timers, external events, and durable entities",
     "title": "Durable Functions orchestrators, activity functions, durable timers, external events, and durable entities",
     "topic": "Azure Functions and Durable Functions",
     "topicFolderPath": "Azure/azure-functions-and-durable-functions"
   },
   {
+    "canonicalPath": "/content/event-grid-for-event-publication-and-fan-out/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/event-grid-for-event-publication-and-fan-out.md",
     "folders": [
@@ -870,12 +1004,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How should you design Event Grid event payloads?"
       }
     ],
+    "seoDescription": "Learn Event Grid for event publication and fan-out for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Event Grid for event publication and fan-out Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Event Grid for event publication and fan-out",
     "title": "Event Grid for event publication and fan-out",
     "topic": "Messaging and event-driven Azure integration",
     "topicFolderPath": "Azure/messaging-and-event-driven-azure-integration"
   },
   {
+    "canonicalPath": "/content/function-chaining-fan-out-fan-in-async-workflow-state-replay-and-compensation/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/function-chaining-fan-out-fan-in-async-workflow-state-replay-and-compensation.md",
     "folders": [
@@ -910,12 +1050,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you limit a fan-out that processes thousands of items?"
       }
     ],
+    "seoDescription": "Learn Function chaining, fan-out/fan-in, async workflow state, replay-safe orchestrator code, and compensation for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Function chaining, fan-out/fan-in, async workflow state, replay-safe orchestrator code, and compensation Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Function chaining, fan-out/fan-in, async workflow state, replay-safe orchestrator code, and compensation",
     "title": "Function chaining, fan-out/fan-in, async workflow state, replay-safe orchestrator code, and compensation",
     "topic": "Azure Functions and Durable Functions",
     "topicFolderPath": "Azure/azure-functions-and-durable-functions"
   },
   {
+    "canonicalPath": "/content/github-actions-or-azure-devops-for-build-test-deploy-and-infrastructure-steps/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/github-actions-or-azure-devops-for-build-test-deploy-and-infrastructure-steps.md",
     "folders": [
@@ -950,12 +1096,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How should infrastructure deployment fit into a CI/CD pipeline?"
       }
     ],
+    "seoDescription": "Learn GitHub Actions or Azure DevOps for build, test, deploy, and infrastructure steps for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "GitHub Actions or Azure DevOps for build, test, deploy, and infrastructure steps Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "GitHub Actions or Azure DevOps for build, test, deploy, and infrastructure steps",
     "title": "GitHub Actions or Azure DevOps for build, test, deploy, and infrastructure steps",
     "topic": "Delivery, infrastructure as code, scaling, and cost control",
     "topicFolderPath": "Azure/delivery-infrastructure-as-code-scaling-and-cost-control"
   },
   {
+    "canonicalPath": "/content/http-timer-queue-service-bus-event-grid-and-blob-triggers/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/http-timer-queue-service-bus-event-grid-and-blob-triggers.md",
     "folders": [
@@ -990,12 +1142,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How should a queue-triggered function handle duplicate messages?"
       }
     ],
+    "seoDescription": "Learn HTTP, timer, queue, Service Bus, Event Grid, and Blob triggers for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "HTTP, timer, queue, Service Bus, Event Grid, and Blob triggers Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "HTTP, timer, queue, Service Bus, Event Grid, and Blob triggers",
     "title": "HTTP, timer, queue, Service Bus, Event Grid, and Blob triggers",
     "topic": "Azure Functions and Durable Functions",
     "topicFolderPath": "Azure/azure-functions-and-durable-functions"
   },
   {
+    "canonicalPath": "/content/in-process-vs-isolated-worker-model-for-dotnet-functions/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/in-process-vs-isolated-worker-model-for-dotnet-functions.md",
     "folders": [
@@ -1030,12 +1188,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What package and attribute changes are required during migration?"
       }
     ],
+    "seoDescription": "Learn In-process vs isolated worker model for .NET Functions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "In-process vs isolated worker model for .NET Functions Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "In-process vs isolated worker model for .NET Functions",
     "title": "In-process vs isolated worker model for .NET Functions",
     "topic": "Azure Functions and Durable Functions",
     "topicFolderPath": "Azure/azure-functions-and-durable-functions"
   },
   {
+    "canonicalPath": "/content/large-file-uploads-block-upload-retries-checksums-and-resumable-patterns/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/large-file-uploads-block-upload-retries-checksums-and-resumable-patterns.md",
     "folders": [
@@ -1070,12 +1234,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you select block size and concurrency?"
       }
     ],
+    "seoDescription": "Learn Large file uploads, block upload, retry behavior, checksums, and resumable upload patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Large file uploads, block upload, retry behavior, checksums, and resumable upload patterns Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Large file uploads, block upload, retry behavior, checksums, and resumable upload patterns",
     "title": "Large file uploads, block upload, retry behavior, checksums, and resumable upload patterns",
     "topic": "Azure Blob Storage and file handling",
     "topicFolderPath": "Azure/azure-blob-storage-and-file-handling"
   },
   {
+    "canonicalPath": "/content/lifecycle-management-soft-delete-versioning-immutability-encryption-and-retention/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/lifecycle-management-soft-delete-versioning-immutability-encryption-and-retention.md",
     "folders": [
@@ -1110,12 +1280,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you control the cost of Blob Storage versioning and snapshots?"
       }
     ],
+    "seoDescription": "Learn Lifecycle management, soft delete, versioning, immutability, encryption, and retention for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Lifecycle management, soft delete, versioning, immutability, encryption, and retention Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Lifecycle management, soft delete, versioning, immutability, encryption, and retention",
     "title": "Lifecycle management, soft delete, versioning, immutability, encryption, and retention",
     "topic": "Azure Blob Storage and file handling",
     "topicFolderPath": "Azure/azure-blob-storage-and-file-handling"
   },
   {
+    "canonicalPath": "/content/log-analytics-queries-dashboards-and-availability-tests/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/log-analytics-queries-dashboards-and-availability-tests.md",
     "folders": [
@@ -1150,12 +1326,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you write a KQL query to find failing API routes?"
       }
     ],
+    "seoDescription": "Learn Log Analytics queries, dashboards, and availability tests for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Log Analytics queries, dashboards, and availability tests Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Log Analytics queries, dashboards, and availability tests",
     "title": "Log Analytics queries, dashboards, and availability tests",
     "topic": "Monitoring, tracing, and incident response on Azure",
     "topicFolderPath": "Azure/monitoring-tracing-and-incident-response-on-azure"
   },
   {
+    "canonicalPath": "/content/matching-storage-choices-to-relational-object-and-cache-workloads/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/matching-storage-choices-to-relational-object-and-cache-workloads.md",
     "folders": [
@@ -1190,12 +1372,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you store uploaded documents and their metadata?"
       }
     ],
+    "seoDescription": "Learn Matching storage choices to relational, object, and cache workloads for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Matching storage choices to relational, object, and cache workloads Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Matching storage choices to relational, object, and cache workloads",
     "title": "Matching storage choices to relational, object, and cache workloads",
     "topic": "Azure data, storage, and caching services",
     "topicFolderPath": "Azure/azure-data-storage-and-caching-services"
   },
   {
+    "canonicalPath": "/content/metrics-vs-logs-vs-traces/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/metrics-vs-logs-vs-traces.md",
     "folders": [
@@ -1230,12 +1418,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do metric dimensions differ from log fields?"
       }
     ],
+    "seoDescription": "Learn Metrics vs logs vs traces for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Metrics vs logs vs traces Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Metrics vs logs vs traces",
     "title": "Metrics vs logs vs traces",
     "topic": "Monitoring, tracing, and incident response on Azure",
     "topicFolderPath": "Azure/monitoring-tracing-and-incident-response-on-azure"
   },
   {
+    "canonicalPath": "/content/microsoft-entra-app-registrations-scopes-and-auth-code-flow-basics/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/microsoft-entra-app-registrations-scopes-and-auth-code-flow-basics.md",
     "folders": [
@@ -1270,12 +1464,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do PKCE, state, and nonce differ?"
       }
     ],
+    "seoDescription": "Learn Microsoft Entra app registrations, scopes, and auth-code flow basics for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Microsoft Entra app registrations, scopes, and auth-code flow basics Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Microsoft Entra app registrations, scopes, and auth-code flow basics",
     "title": "Microsoft Entra app registrations, scopes, and auth-code flow basics",
     "topic": "Identity, secrets, and access control",
     "topicFolderPath": "Azure/identity-secrets-and-access-control"
   },
   {
+    "canonicalPath": "/content/oidc-based-azure-authentication-in-pipelines/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/oidc-based-azure-authentication-in-pipelines.md",
     "folders": [
@@ -1310,12 +1510,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does the OIDC token exchange flow work?"
       }
     ],
+    "seoDescription": "Learn OIDC-based Azure authentication in pipelines for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "OIDC-based Azure authentication in pipelines Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "OIDC-based Azure authentication in pipelines",
     "title": "OIDC-based Azure authentication in pipelines",
     "topic": "Delivery, infrastructure as code, scaling, and cost control",
     "topicFolderPath": "Azure/delivery-infrastructure-as-code-scaling-and-cost-control"
   },
   {
+    "canonicalPath": "/content/rate-limiting-quotas-auth-offload-and-request-transformation-at-the-edge/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/rate-limiting-quotas-auth-offload-and-request-transformation-at-the-edge.md",
     "folders": [
@@ -1350,12 +1556,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How should you choose a rate-limit counter key?"
       }
     ],
+    "seoDescription": "Learn Rate limiting, quotas, auth offload, and request transformation at the edge for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Rate limiting, quotas, auth offload, and request transformation at the edge Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Rate limiting, quotas, auth offload, and request transformation at the edge",
     "title": "Rate limiting, quotas, auth offload, and request transformation at the edge",
     "topic": "Networking, API edge, and secure connectivity",
     "topicFolderPath": "Azure/networking-api-edge-and-secure-connectivity"
   },
   {
+    "canonicalPath": "/content/rbac-least-privilege-and-separating-human-vs-workload-identities/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/rbac-least-privilege-and-separating-human-vs-workload-identities.md",
     "folders": [
@@ -1390,12 +1602,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why should privileged human roles use PIM?"
       }
     ],
+    "seoDescription": "Learn RBAC, least privilege, and separating human vs workload identities for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "RBAC, least privilege, and separating human vs workload identities Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "RBAC, least privilege, and separating human vs workload identities",
     "title": "RBAC, least privilege, and separating human vs workload identities",
     "topic": "Identity, secrets, and access control",
     "topicFolderPath": "Azure/identity-secrets-and-access-control"
   },
   {
+    "canonicalPath": "/content/service-bus-queues-topics-subscriptions-and-dead-letter-queues/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/service-bus-queues-topics-subscriptions-and-dead-letter-queues.md",
     "folders": [
@@ -1430,12 +1648,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does peek-lock processing work?"
       }
     ],
+    "seoDescription": "Learn Service Bus queues, topics, subscriptions, and dead-letter queues for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Service Bus queues, topics, subscriptions, and dead-letter queues Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Service Bus queues, topics, subscriptions, and dead-letter queues",
     "title": "Service Bus queues, topics, subscriptions, and dead-letter queues",
     "topic": "Messaging and event-driven Azure integration",
     "topicFolderPath": "Azure/messaging-and-event-driven-azure-integration"
   },
   {
+    "canonicalPath": "/content/service-tags-private-networking-and-reducing-public-attack-surface/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/service-tags-private-networking-and-reducing-public-attack-surface.md",
     "folders": [
@@ -1470,12 +1694,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Compare private endpoints and virtual network service endpoints."
       }
     ],
+    "seoDescription": "Learn Service tags, private networking, and reducing public attack surface for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Service tags, private networking, and reducing public attack surface Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Service tags, private networking, and reducing public attack surface",
     "title": "Service tags, private networking, and reducing public attack surface",
     "topic": "Networking, API edge, and secure connectivity",
     "topicFolderPath": "Azure/networking-api-edge-and-secure-connectivity"
   },
   {
+    "canonicalPath": "/content/shared-access-signatures-managed-identity-rbac-stored-access-policies-and-public-access-risks/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/shared-access-signatures-managed-identity-rbac-stored-access-policies-and-public-access-risks.md",
     "folders": [
@@ -1510,12 +1740,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Compare user delegation, service, and account SAS."
       }
     ],
+    "seoDescription": "Learn Shared access signatures, managed identity, RBAC, stored access policies, and public access risks for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Shared access signatures, managed identity, RBAC, stored access policies, and public access risks Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Shared access signatures, managed identity, RBAC, stored access policies, and public access risks",
     "title": "Shared access signatures, managed identity, RBAC, stored access policies, and public access risks",
     "topic": "Azure Blob Storage and file handling",
     "topicFolderPath": "Azure/azure-blob-storage-and-file-handling"
   },
   {
+    "canonicalPath": "/content/storage-accounts-containers-blobs-virtual-folders-metadata-and-access-tiers/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/storage-accounts-containers-blobs-virtual-folders-metadata-and-access-tiers.md",
     "folders": [
@@ -1550,12 +1786,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you design blob names for a multi-tenant document system?"
       }
     ],
+    "seoDescription": "Learn Storage accounts, containers, blobs, virtual folders, metadata, and access tiers for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Storage accounts, containers, blobs, virtual folders, metadata, and access tiers Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Storage accounts, containers, blobs, virtual folders, metadata, and access tiers",
     "title": "Storage accounts, containers, blobs, virtual folders, metadata, and access tiers",
     "topic": "Azure Blob Storage and file handling",
     "topicFolderPath": "Azure/azure-blob-storage-and-file-handling"
   },
   {
+    "canonicalPath": "/content/system-assigned-and-user-assigned-managed-identities/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/system-assigned-and-user-assigned-managed-identities.md",
     "folders": [
@@ -1590,12 +1832,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When would you choose a user-assigned identity over a system-assigned identity?"
       }
     ],
+    "seoDescription": "Learn System-assigned and user-assigned managed identities for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "System-assigned and user-assigned managed identities Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "System-assigned and user-assigned managed identities",
     "title": "System-assigned and user-assigned managed identities",
     "topic": "Identity, secrets, and access control",
     "topicFolderPath": "Azure/identity-secrets-and-access-control"
   },
   {
+    "canonicalPath": "/content/trade-offs-among-simplicity-portability-autoscaling-and-operational-control/",
+    "canonicalPathSource": "generated",
     "category": "Azure",
     "contentPath": "/src/contents/v1/Azure/trade-offs-among-simplicity-portability-autoscaling-and-operational-control.md",
     "folders": [
@@ -1630,12 +1878,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you choose between Azure Container Apps and AKS?"
       }
     ],
+    "seoDescription": "Learn Trade-offs among simplicity, portability, autoscaling, and operational control for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Trade-offs among simplicity, portability, autoscaling, and operational control Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Trade-offs among simplicity, portability, autoscaling, and operational control",
     "title": "Trade-offs among simplicity, portability, autoscaling, and operational control",
     "topic": "Azure compute choices and hosting models",
     "topicFolderPath": "Azure/azure-compute-choices-and-hosting-models"
   },
   {
+    "canonicalPath": "/content/adrs-coding-conventions-and-team-level-design-communication/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/adrs-coding-conventions-and-team-level-design-communication.md",
     "folders": [
@@ -1670,12 +1924,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What should happen when an accepted ADR is no longer appropriate?"
       }
     ],
+    "seoDescription": "Learn ADRs, coding conventions, and team-level design communication for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "ADRs, coding conventions, and team-level design communication Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "ADRs, coding conventions, and team-level design communication",
     "title": "ADRs, coding conventions, and team-level design communication",
     "topic": "Testing strategy, maintainability, and technical leadership",
     "topicFolderPath": "Design & Architecture/testing-strategy-maintainability-and-technical-leadership"
   },
   {
+    "canonicalPath": "/content/api-gateway-and-bff-decisions-for-web-clients-and-microservices/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/api-gateway-and-bff-decisions-for-web-clients-and-microservices.md",
     "folders": [
@@ -1710,12 +1970,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Which responsibilities should remain out of an API gateway?"
       }
     ],
+    "seoDescription": "Learn API gateway and BFF decisions for web clients and microservices for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "API gateway and BFF decisions for web clients and microservices Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "API gateway and BFF decisions for web clients and microservices",
     "title": "API gateway and BFF decisions for web clients and microservices",
     "topic": "API design and integration contracts",
     "topicFolderPath": "Design & Architecture/api-design-and-integration-contracts"
   },
   {
+    "canonicalPath": "/content/assumptions-constraints-risks-failure-modes/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/assumptions-constraints-risks-failure-modes.md",
     "folders": [
@@ -1750,12 +2016,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you identify risks in a proposed architecture?"
       }
     ],
+    "seoDescription": "Learn Assumptions, constraints, risks, and failure modes for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Assumptions, constraints, risks, and failure modes Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Assumptions, constraints, risks, and failure modes",
     "title": "Assumptions, constraints, risks, and failure modes",
     "topic": "Requirements decomposition and system trade-offs",
     "topicFolderPath": "Design & Architecture/requirements-decomposition-and-system-trade-offs"
   },
   {
+    "canonicalPath": "/content/cache-aside-read-caching-and-invalidation-trade-offs/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/cache-aside-read-caching-and-invalidation-trade-offs.md",
     "folders": [
@@ -1790,12 +2062,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you choose a cache TTL?"
       }
     ],
+    "seoDescription": "Learn Cache-aside, read caching, and invalidation trade-offs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Cache-aside, read caching, and invalidation trade-offs Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Cache-aside, read caching, and invalidation trade-offs",
     "title": "Cache-aside, read caching, and invalidation trade-offs",
     "topic": "Scalability, resilience, caching, and observability design",
     "topicFolderPath": "Design & Architecture/scalability-resilience-caching-and-observability-design"
   },
   {
+    "canonicalPath": "/content/capacity-planning-and-identifying-likely-bottlenecks/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/capacity-planning-and-identifying-likely-bottlenecks.md",
     "folders": [
@@ -1830,12 +2108,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you estimate how many API instances are needed?"
       }
     ],
+    "seoDescription": "Learn Capacity Planning and Identifying Likely Bottlenecks for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Capacity Planning and Identifying Likely Bottlenecks Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Capacity Planning and Identifying Likely Bottlenecks",
     "title": "Capacity Planning and Identifying Likely Bottlenecks",
     "topic": "Requirements decomposition and system trade-offs",
     "topicFolderPath": "Design & Architecture/requirements-decomposition-and-system-trade-offs"
   },
   {
+    "canonicalPath": "/content/command-injection-file-upload-risks-path-traversal-secrets-exposure-and-dos-ddos-basics/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/command-injection-file-upload-risks-path-traversal-secrets-exposure-and-dos-ddos-basics.md",
     "folders": [
@@ -1870,12 +2154,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you design a secure file-upload service?"
       }
     ],
+    "seoDescription": "Learn Command injection, file upload risks, path traversal, secrets exposure, and DoS/DDoS basics for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Command injection, file upload risks, path traversal, secrets exposure, and DoS/DDoS basics Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Command injection, file upload risks, path traversal, secrets exposure, and DoS/DDoS basics",
     "title": "Command injection, file upload risks, path traversal, secrets exposure, and DoS/DDoS basics",
     "topic": "Web application security threat modeling and attack patterns",
     "topicFolderPath": "Design & Architecture/web-application-security-threat-modeling-and-attack-patterns"
   },
   {
+    "canonicalPath": "/content/correlation-ids-traces-health-checks-and-alertable-telemetry/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/correlation-ids-traces-health-checks-and-alertable-telemetry.md",
     "folders": [
@@ -1910,12 +2200,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you correlate logs, metrics, and traces?"
       }
     ],
+    "seoDescription": "Learn Correlation IDs, traces, health checks, and alertable telemetry for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Correlation IDs, traces, health checks, and alertable telemetry Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Correlation IDs, traces, health checks, and alertable telemetry",
     "title": "Correlation IDs, traces, health checks, and alertable telemetry",
     "topic": "Scalability, resilience, caching, and observability design",
     "topicFolderPath": "Design & Architecture/scalability-resilience-caching-and-observability-design"
   },
   {
+    "canonicalPath": "/content/cqrs-and-when-separate-read-and-write-models-make-sense/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/cqrs-and-when-separate-read-and-write-models-make-sense.md",
     "folders": [
@@ -1950,12 +2246,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What changes when CQRS uses separate read and write databases?"
       }
     ],
+    "seoDescription": "Learn CQRS and when separate read and write models make sense for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "CQRS and when separate read and write models make sense Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "CQRS and when separate read and write models make sense",
     "title": "CQRS and when separate read and write models make sense",
     "topic": "Distributed systems patterns",
     "topicFolderPath": "Design & Architecture/distributed-systems-patterns"
   },
   {
+    "canonicalPath": "/content/cross-site-request-forgery-and-cookie-based-authentication/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/cross-site-request-forgery-and-cookie-based-authentication.md",
     "folders": [
@@ -1990,12 +2292,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What are the limitations of SameSite cookies as a CSRF defense?"
       }
     ],
+    "seoDescription": "Learn Cross-Site Request Forgery and how cookie-based authentication changes the risk model for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Cross-Site Request Forgery and how cookie-based authentication changes the risk model Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Cross-Site Request Forgery and how cookie-based authentication changes the risk model",
     "title": "Cross-Site Request Forgery and how cookie-based authentication changes the risk model",
     "topic": "Web application security threat modeling and attack patterns",
     "topicFolderPath": "Design & Architecture/web-application-security-threat-modeling-and-attack-patterns"
   },
   {
+    "canonicalPath": "/content/cross-site-scripting-output-encoding-dangerous-html-rendering-and-content-security/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/cross-site-scripting-output-encoding-dangerous-html-rendering-and-content-security.md",
     "folders": [
@@ -2030,12 +2338,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why must output encoding match the browser context?"
       }
     ],
+    "seoDescription": "Learn Cross-Site Scripting, output encoding, dangerous HTML rendering, and content security controls for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Cross-Site Scripting, output encoding, dangerous HTML rendering, and content security controls Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Cross-Site Scripting, output encoding, dangerous HTML rendering, and content security controls",
     "title": "Cross-Site Scripting, output encoding, dangerous HTML rendering, and content security controls",
     "topic": "Web application security threat modeling and attack patterns",
     "topicFolderPath": "Design & Architecture/web-application-security-threat-modeling-and-attack-patterns"
   },
   {
+    "canonicalPath": "/content/dependency-inversion-and-inward-facing-dependencies/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/dependency-inversion-and-inward-facing-dependencies.md",
     "folders": [
@@ -2070,12 +2384,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Who should own an interface used to invert a dependency?"
       }
     ],
+    "seoDescription": "Learn Dependency inversion and inward-facing dependencies for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Dependency inversion and inward-facing dependencies Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Dependency inversion and inward-facing dependencies",
     "title": "Dependency inversion and inward-facing dependencies",
     "topic": "Clean Architecture and modular boundaries",
     "topicFolderPath": "Design & Architecture/clean-architecture-and-modular-boundaries"
   },
   {
+    "canonicalPath": "/content/domain-services-and-domain-events/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/domain-services-and-domain-events.md",
     "folders": [
@@ -2110,12 +2430,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When should behavior remain on an entity instead of moving to a domain service?"
       }
     ],
+    "seoDescription": "Learn Domain services and domain events for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Domain services and domain events Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Domain services and domain events",
     "title": "Domain services and domain events",
     "topic": "Domain modeling and Domain-Driven Design",
     "topicFolderPath": "Design & Architecture/domain-modeling-and-domain-driven-design"
   },
   {
+    "canonicalPath": "/content/entities-value-objects-aggregates-and-invariants/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/entities-value-objects-aggregates-and-invariants.md",
     "folders": [
@@ -2150,12 +2476,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you choose an aggregate boundary?"
       }
     ],
+    "seoDescription": "Learn Entities, value objects, aggregates, and invariants for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Entities, value objects, aggregates, and invariants Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Entities, value objects, aggregates, and invariants",
     "title": "Entities, value objects, aggregates, and invariants",
     "topic": "Domain modeling and Domain-Driven Design",
     "topicFolderPath": "Design & Architecture/domain-modeling-and-domain-driven-design"
   },
   {
+    "canonicalPath": "/content/event-driven-communication-and-asynchronous-request-reply/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/event-driven-communication-and-asynchronous-request-reply.md",
     "folders": [
@@ -2190,12 +2522,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How should an HTTP API represent a long-running operation?"
       }
     ],
+    "seoDescription": "Learn Event-driven communication and asynchronous request-reply for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Event-driven communication and asynchronous request-reply Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Event-driven communication and asynchronous request-reply",
     "title": "Event-driven communication and asynchronous request-reply",
     "topic": "Distributed systems patterns",
     "topicFolderPath": "Design & Architecture/distributed-systems-patterns"
   },
   {
+    "canonicalPath": "/content/factory-builder-strategy-adapter-decorator-facade-proxy-and-chain-of-responsibility/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/factory-builder-strategy-adapter-decorator-facade-proxy-and-chain-of-responsibility.md",
     "folders": [
@@ -2230,12 +2568,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do Factory and Strategy work together?"
       }
     ],
+    "seoDescription": "Learn Factory, Builder, Strategy, Adapter, Decorator, Facade, Proxy, and Chain of Responsibility for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Factory, Builder, Strategy, Adapter, Decorator, Facade, Proxy, and Chain of Responsibility Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Factory, Builder, Strategy, Adapter, Decorator, Facade, Proxy, and Chain of Responsibility",
     "title": "Factory, Builder, Strategy, Adapter, Decorator, Facade, Proxy, and Chain of Responsibility",
     "topic": "Software design principles and common .NET patterns",
     "topicFolderPath": "Design & Architecture/software-design-principles-and-common-net-patterns"
   },
   {
+    "canonicalPath": "/content/functional-requirements-vs-nonfunctional-requirements/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/functional-requirements-vs-nonfunctional-requirements.md",
     "folders": [
@@ -2270,12 +2614,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do nonfunctional requirements influence architecture?"
       }
     ],
+    "seoDescription": "Learn Functional Requirements vs Nonfunctional Requirements for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Functional Requirements vs Nonfunctional Requirements Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Functional Requirements vs Nonfunctional Requirements",
     "title": "Functional Requirements vs Nonfunctional Requirements",
     "topic": "Requirements decomposition and system trade-offs",
     "topicFolderPath": "Design & Architecture/requirements-decomposition-and-system-trade-offs"
   },
   {
+    "canonicalPath": "/content/horizontal-scaling-stateless-services-and-backpressure/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/horizontal-scaling-stateless-services-and-backpressure.md",
     "folders": [
@@ -2310,12 +2660,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you choose autoscaling signals?"
       }
     ],
+    "seoDescription": "Learn Horizontal scaling, stateless services, and backpressure for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Horizontal scaling, stateless services, and backpressure Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Horizontal scaling, stateless services, and backpressure",
     "title": "Horizontal scaling, stateless services, and backpressure",
     "topic": "Scalability, resilience, caching, and observability design",
     "topicFolderPath": "Design & Architecture/scalability-resilience-caching-and-observability-design"
   },
   {
+    "canonicalPath": "/content/idempotent-consumers-and-duplicate-message-handling/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/idempotent-consumers-and-duplicate-message-handling.md",
     "folders": [
@@ -2350,12 +2706,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does an inbox table prevent duplicate processing?"
       }
     ],
+    "seoDescription": "Learn Idempotent consumers and duplicate-message handling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Idempotent consumers and duplicate-message handling Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Idempotent consumers and duplicate-message handling",
     "title": "Idempotent consumers and duplicate-message handling",
     "topic": "Distributed systems patterns",
     "topicFolderPath": "Design & Architecture/distributed-systems-patterns"
   },
   {
+    "canonicalPath": "/content/insecure-direct-object-reference-broken-access-control-and-object-level-authorization/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/insecure-direct-object-reference-broken-access-control-and-object-level-authorization.md",
     "folders": [
@@ -2390,12 +2752,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you fix an endpoint that retrieves an order by ID?"
       }
     ],
+    "seoDescription": "Learn Insecure Direct Object Reference, broken access control, and object-level authorization for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Insecure Direct Object Reference, broken access control, and object-level authorization Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Insecure Direct Object Reference, broken access control, and object-level authorization",
     "title": "Insecure Direct Object Reference, broken access control, and object-level authorization",
     "topic": "Web application security threat modeling and attack patterns",
     "topicFolderPath": "Design & Architecture/web-application-security-threat-modeling-and-attack-patterns"
   },
   {
+    "canonicalPath": "/content/kiss-dry-yagni-separation-of-concerns-cohesion-and-coupling/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/kiss-dry-yagni-separation-of-concerns-cohesion-and-coupling.md",
     "folders": [
@@ -2430,12 +2798,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How can DRY be harmful when applied incorrectly?"
       }
     ],
+    "seoDescription": "Learn KISS, DRY, YAGNI, Separation of Concerns, Cohesion, and Coupling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "KISS, DRY, YAGNI, Separation of Concerns, Cohesion, and Coupling Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "KISS, DRY, YAGNI, Separation of Concerns, Cohesion, and Coupling",
     "title": "KISS, DRY, YAGNI, Separation of Concerns, Cohesion, and Coupling",
     "topic": "Software design principles and common .NET patterns",
     "topicFolderPath": "Design & Architecture/software-design-principles-and-common-net-patterns"
   },
   {
+    "canonicalPath": "/content/layered-architecture-vs-clean-architecture-vs-ports-and-adapters/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/layered-architecture-vs-clean-architecture-vs-ports-and-adapters.md",
     "folders": [
@@ -2470,12 +2844,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the main difference between traditional layering and Clean Architecture?"
       }
     ],
+    "seoDescription": "Learn Layered architecture vs Clean Architecture vs ports-and-adapters for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Layered architecture vs Clean Architecture vs ports-and-adapters Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Layered architecture vs Clean Architecture vs ports-and-adapters",
     "title": "Layered architecture vs Clean Architecture vs ports-and-adapters",
     "topic": "Clean Architecture and modular boundaries",
     "topicFolderPath": "Design & Architecture/clean-architecture-and-modular-boundaries"
   },
   {
+    "canonicalPath": "/content/mapping-domain-models-to-persistence-without-corrupting-the-model/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/mapping-domain-models-to-persistence-without-corrupting-the-model.md",
     "folders": [
@@ -2510,12 +2890,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When should you use a separate persistence model instead of directly mapping domain entities?"
       }
     ],
+    "seoDescription": "Learn Mapping domain models to persistence without corrupting the model for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Mapping domain models to persistence without corrupting the model Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Mapping domain models to persistence without corrupting the model",
     "title": "Mapping domain models to persistence without corrupting the model",
     "topic": "Domain modeling and Domain-Driven Design",
     "topicFolderPath": "Design & Architecture/domain-modeling-and-domain-driven-design"
   },
   {
+    "canonicalPath": "/content/mentoring-ownership-and-incremental-modernization/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/mentoring-ownership-and-incremental-modernization.md",
     "folders": [
@@ -2550,12 +2936,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you mentor an engineer without becoming a bottleneck?"
       }
     ],
+    "seoDescription": "Learn Mentoring, ownership, and incremental modernization for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Mentoring, ownership, and incremental modernization Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Mentoring, ownership, and incremental modernization",
     "title": "Mentoring, ownership, and incremental modernization",
     "topic": "Testing strategy, maintainability, and technical leadership",
     "topicFolderPath": "Design & Architecture/testing-strategy-maintainability-and-technical-leadership"
   },
   {
+    "canonicalPath": "/content/modular-monolith-structure-and-feature-based-organization/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/modular-monolith-structure-and-feature-based-organization.md",
     "folders": [
@@ -2590,12 +2982,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How should modules communicate inside a modular monolith?"
       }
     ],
+    "seoDescription": "Learn Modular monolith structure and feature-based organization for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Modular monolith structure and feature-based organization Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Modular monolith structure and feature-based organization",
     "title": "Modular monolith structure and feature-based organization",
     "topic": "Clean Architecture and modular boundaries",
     "topicFolderPath": "Design & Architecture/clean-architecture-and-modular-boundaries"
   },
   {
+    "canonicalPath": "/content/openapi-contracts-and-consumer-facing-documentation/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/openapi-contracts-and-consumer-facing-documentation.md",
     "folders": [
@@ -2630,12 +3028,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What are the trade-offs between contract-first and code-first OpenAPI workflows?"
       }
     ],
+    "seoDescription": "Learn OpenAPI contracts and consumer-facing documentation for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "OpenAPI contracts and consumer-facing documentation Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "OpenAPI contracts and consumer-facing documentation",
     "title": "OpenAPI contracts and consumer-facing documentation",
     "topic": "API design and integration contracts",
     "topicFolderPath": "Design & Architecture/api-design-and-integration-contracts"
   },
   {
+    "canonicalPath": "/content/recognizing-when-a-pattern-improves-maintainability-vs-when-it-adds-unnecessary-complexity/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/recognizing-when-a-pattern-improves-maintainability-vs-when-it-adds-unnecessary-complexity.md",
     "folders": [
@@ -2670,12 +3074,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When would you replace a switch statement with the Strategy pattern?"
       }
     ],
+    "seoDescription": "Learn Recognizing when a pattern improves maintainability vs when it adds unnecessary complexity for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Recognizing when a pattern improves maintainability vs when it adds unnecessary complexity Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Recognizing when a pattern improves maintainability vs when it adds unnecessary complexity",
     "title": "Recognizing when a pattern improves maintainability vs when it adds unnecessary complexity",
     "topic": "Software design principles and common .NET patterns",
     "topicFolderPath": "Design & Architecture/software-design-principles-and-common-net-patterns"
   },
   {
+    "canonicalPath": "/content/refactoring-strategy-code-review-standards-and-technical-debt-management/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/refactoring-strategy-code-review-standards-and-technical-debt-management.md",
     "folders": [
@@ -2710,12 +3120,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you safely refactor legacy code with few tests?"
       }
     ],
+    "seoDescription": "Learn Refactoring strategy, code review standards, and technical debt management for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Refactoring strategy, code review standards, and technical debt management Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Refactoring strategy, code review standards, and technical debt management",
     "title": "Refactoring strategy, code review standards, and technical debt management",
     "topic": "Testing strategy, maintainability, and technical leadership",
     "topicFolderPath": "Design & Architecture/testing-strategy-maintainability-and-technical-leadership"
   },
   {
+    "canonicalPath": "/content/repository-unit-of-work-mediator-specification-dotnet-patterns/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/repository-unit-of-work-mediator-specification-dotnet-patterns.md",
     "folders": [
@@ -2750,12 +3166,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Is Repository still needed when using EF Core?"
       }
     ],
+    "seoDescription": "Learn Repository, Unit of Work, Mediator, and Specification Patterns in .NET for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Repository, Unit of Work, Mediator, and Specification Patterns in .NET Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Repository, Unit of Work, Mediator, and Specification Patterns in .NET",
     "title": "Repository, Unit of Work, Mediator, and Specification Patterns in .NET",
     "topic": "Software design principles and common .NET patterns",
     "topicFolderPath": "Design & Architecture/software-design-principles-and-common-net-patterns"
   },
   {
+    "canonicalPath": "/content/resource-modeling-rest-semantics-and-rpc-style-endpoints/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/resource-modeling-rest-semantics-and-rpc-style-endpoints.md",
     "folders": [
@@ -2790,12 +3212,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When is an RPC-style action endpoint acceptable?"
       }
     ],
+    "seoDescription": "Learn Resource modeling, REST semantics, and when RPC-style endpoints are acceptable for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Resource modeling, REST semantics, and when RPC-style endpoints are acceptable Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Resource modeling, REST semantics, and when RPC-style endpoints are acceptable",
     "title": "Resource modeling, REST semantics, and when RPC-style endpoints are acceptable",
     "topic": "API design and integration contracts",
     "topicFolderPath": "Design & Architecture/api-design-and-integration-contracts"
   },
   {
+    "canonicalPath": "/content/retry-circuit-breaker-bulkhead-and-queue-based-load-leveling/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/retry-circuit-breaker-bulkhead-and-queue-based-load-leveling.md",
     "folders": [
@@ -2830,12 +3258,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you configure retries for an HTTP dependency?"
       }
     ],
+    "seoDescription": "Learn Retry, circuit breaker, bulkhead, and queue-based load leveling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Retry, circuit breaker, bulkhead, and queue-based load leveling Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Retry, circuit breaker, bulkhead, and queue-based load leveling",
     "title": "Retry, circuit breaker, bulkhead, and queue-based load leveling",
     "topic": "Scalability, resilience, caching, and observability design",
     "topicFolderPath": "Design & Architecture/scalability-resilience-caching-and-observability-design"
   },
   {
+    "canonicalPath": "/content/saga-and-compensating-transaction-patterns/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/saga-and-compensating-transaction-patterns.md",
     "folders": [
@@ -2870,12 +3304,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How should saga steps be classified and ordered?"
       }
     ],
+    "seoDescription": "Learn Saga and compensating transaction patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Saga and compensating transaction patterns Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Saga and compensating transaction patterns",
     "title": "Saga and compensating transaction patterns",
     "topic": "Distributed systems patterns",
     "topicFolderPath": "Design & Architecture/distributed-systems-patterns"
   },
   {
+    "canonicalPath": "/content/session-hijacking-credential-stuffing-brute-force-protection-lockout-and-multi-factor-authentication/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/session-hijacking-credential-stuffing-brute-force-protection-lockout-and-multi-factor-authentication.md",
     "folders": [
@@ -2910,12 +3350,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you design rate limiting for a public login endpoint?"
       }
     ],
+    "seoDescription": "Learn Session hijacking, credential stuffing, brute-force protection, lockout, and multi-factor authentication for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Session hijacking, credential stuffing, brute-force protection, lockout, and multi-factor authentication Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Session hijacking, credential stuffing, brute-force protection, lockout, and multi-factor authentication",
     "title": "Session hijacking, credential stuffing, brute-force protection, lockout, and multi-factor authentication",
     "topic": "Web application security threat modeling and attack patterns",
     "topicFolderPath": "Design & Architecture/web-application-security-threat-modeling-and-attack-patterns"
   },
   {
+    "canonicalPath": "/content/solid-principles-in-dotnet-design/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/solid-principles-in-dotnet-design.md",
     "folders": [
@@ -2950,12 +3396,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How are dependency inversion and dependency injection different?"
       }
     ],
+    "seoDescription": "Learn SOLID Principles in .NET Design for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "SOLID Principles in .NET Design Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "SOLID Principles in .NET Design",
     "title": "SOLID Principles in .NET Design",
     "topic": "Software design principles and common .NET patterns",
     "topicFolderPath": "Design & Architecture/software-design-principles-and-common-net-patterns"
   },
   {
+    "canonicalPath": "/content/sql-injection-parameterized-queries-orm-safety-and-unsafe-dynamic-sql/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/sql-injection-parameterized-queries-orm-safety-and-unsafe-dynamic-sql.md",
     "folders": [
@@ -2990,12 +3442,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you safely implement a user-selected sort column?"
       }
     ],
+    "seoDescription": "Learn SQL Injection, parameterized queries, ORM safety, and unsafe dynamic SQL for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "SQL Injection, parameterized queries, ORM safety, and unsafe dynamic SQL Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "SQL Injection, parameterized queries, ORM safety, and unsafe dynamic SQL",
     "title": "SQL Injection, parameterized queries, ORM safety, and unsafe dynamic SQL",
     "topic": "Web application security threat modeling and attack patterns",
     "topicFolderPath": "Design & Architecture/web-application-security-threat-modeling-and-attack-patterns"
   },
   {
+    "canonicalPath": "/content/test-pyramid-contract-tests-and-architecture-fitness-checks/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/test-pyramid-contract-tests-and-architecture-fitness-checks.md",
     "folders": [
@@ -3030,12 +3488,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you test an ASP.NET Core API effectively?"
       }
     ],
+    "seoDescription": "Learn Test pyramid, contract tests, and architecture fitness checks for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Test pyramid, contract tests, and architecture fitness checks Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Test pyramid, contract tests, and architecture fitness checks",
     "title": "Test pyramid, contract tests, and architecture fitness checks",
     "topic": "Testing strategy, maintainability, and technical leadership",
     "topicFolderPath": "Design & Architecture/testing-strategy-maintainability-and-technical-leadership"
   },
   {
+    "canonicalPath": "/content/threat-modeling-user-input-trust-boundaries-authentication-flows-and-admin-only-operations/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/threat-modeling-user-input-trust-boundaries-authentication-flows-and-admin-only-operations.md",
     "folders": [
@@ -3070,12 +3534,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you threat-model an authentication flow?"
       }
     ],
+    "seoDescription": "Learn Threat modeling user input, trust boundaries, authentication flows, and admin-only operations for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Threat modeling user input, trust boundaries, authentication flows, and admin-only operations Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Threat modeling user input, trust boundaries, authentication flows, and admin-only operations",
     "title": "Threat modeling user input, trust boundaries, authentication flows, and admin-only operations",
     "topic": "Web application security threat modeling and attack patterns",
     "topicFolderPath": "Design & Architecture/web-application-security-threat-modeling-and-attack-patterns"
   },
   {
+    "canonicalPath": "/content/throughput-latency-concurrency-availability-consistency-cost-targets/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/throughput-latency-concurrency-availability-consistency-cost-targets.md",
     "folders": [
@@ -3110,12 +3580,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you decompose a vague requirement like \"the system must handle one million users\"?"
       }
     ],
+    "seoDescription": "Learn Throughput, latency, concurrency, availability, consistency, and cost targets for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Throughput, latency, concurrency, availability, consistency, and cost targets Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Throughput, latency, concurrency, availability, consistency, and cost targets",
     "title": "Throughput, latency, concurrency, availability, consistency, and cost targets",
     "topic": "Requirements decomposition and system trade-offs",
     "topicFolderPath": "Design & Architecture/requirements-decomposition-and-system-trade-offs"
   },
   {
+    "canonicalPath": "/content/ubiquitous-language-and-bounded-contexts/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/ubiquitous-language-and-bounded-contexts.md",
     "folders": [
@@ -3150,12 +3626,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you discover a Ubiquitous Language with domain experts?"
       }
     ],
+    "seoDescription": "Learn Ubiquitous language and bounded contexts for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Ubiquitous language and bounded contexts Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Ubiquitous language and bounded contexts",
     "title": "Ubiquitous language and bounded contexts",
     "topic": "Domain modeling and Domain-Driven Design",
     "topicFolderPath": "Design & Architecture/domain-modeling-and-domain-driven-design"
   },
   {
+    "canonicalPath": "/content/versioning-idempotency-pagination-filtering-and-sorting/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/versioning-idempotency-pagination-filtering-and-sorting.md",
     "folders": [
@@ -3190,12 +3672,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What are the trade-offs among path, query, header, and media-type versioning?"
       }
     ],
+    "seoDescription": "Learn Versioning, idempotency, pagination, filtering, and sorting for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Versioning, idempotency, pagination, filtering, and sorting Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Versioning, idempotency, pagination, filtering, and sorting",
     "title": "Versioning, idempotency, pagination, filtering, and sorting",
     "topic": "API design and integration contracts",
     "topicFolderPath": "Design & Architecture/api-design-and-integration-contracts"
   },
   {
+    "canonicalPath": "/content/when-not-to-over-architect-a-simple-application/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/Design & Architecture/when-not-to-over-architect-a-simple-application.md",
     "folders": [
@@ -3230,12 +3718,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you decide whether an abstraction is justified?"
       }
     ],
+    "seoDescription": "Learn When not to over-architect a simple application for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "When not to over-architect a simple application Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "When not to over-architect a simple application",
     "title": "When not to over-architect a simple application",
     "topic": "Clean Architecture and modular boundaries",
     "topicFolderPath": "Design & Architecture/clean-architecture-and-modular-boundaries"
   },
   {
+    "canonicalPath": "/content/api-controller-behavior-automatic-model-validation-binding-source-inference-and-validation-responses/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/api-controller-behavior-automatic-model-validation-binding-source-inference-and-validation-responses.md",
     "folders": [
@@ -3270,12 +3764,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Explain binding-source inference with [ApiController]."
       }
     ],
+    "seoDescription": "Learn [ApiController] Behavior for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "[ApiController] Behavior Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "[ApiController] Behavior",
     "title": "[ApiController] Behavior",
     "topic": "API design and implementation",
     "topicFolderPath": "NET/api-design-and-implementation"
   },
   {
+    "canonicalPath": "/content/aspnet-core-filters-and-middleware-boundaries/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/aspnet-core-filters-and-middleware-boundaries.md",
     "folders": [
@@ -3310,12 +3810,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When would you use a resource filter instead of an action filter?"
       }
     ],
+    "seoDescription": "Learn ASP.NET Core filters and middleware boundaries for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "ASP.NET Core filters and middleware boundaries Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "ASP.NET Core filters and middleware boundaries",
     "title": "ASP.NET Core filters and middleware boundaries",
     "topic": "API design and implementation",
     "topicFolderPath": "NET/api-design-and-implementation"
   },
   {
+    "canonicalPath": "/content/async-and-await-semantics-in-csharp/",
+    "canonicalPathSource": "frontmatter",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/async-and-await-semantics-in-csharp.md",
     "folders": [
@@ -3350,12 +3856,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the difference between .Result, .Wait(), and await?"
       }
     ],
+    "seoDescription": "Learn async and await in C# for technical interviews, including Task, cancellation, exception handling, and common deadlock risks.",
+    "seoDescriptionSource": "frontmatter",
+    "seoTitle": "Async and Await in C# Interview Questions",
+    "seoTitleSource": "frontmatter",
     "subtopic": "Async and Await Semantics",
     "title": "Async and Await Semantics",
     "topic": "Async programming, tasks, cancellation, and concurrency",
     "topicFolderPath": "NET/async-programming-tasks-cancellation-and-concurrency"
   },
   {
+    "canonicalPath": "/content/authentication-vs-authorization-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/authentication-vs-authorization-in-csharp.md",
     "folders": [
@@ -3390,12 +3902,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is an authentication scheme?"
       }
     ],
+    "seoDescription": "Learn Authentication vs Authorization in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Authentication vs Authorization in C# Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Authentication vs Authorization in C#",
     "title": "Authentication vs Authorization in C#",
     "topic": "Authentication, authorization, and web security",
     "topicFolderPath": "NET/authentication-authorization-and-web-security"
   },
   {
+    "canonicalPath": "/content/cancellationtoken-propagation-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/cancellationtoken-propagation-in-csharp.md",
     "folders": [
@@ -3430,12 +3948,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you use CancellationToken in an ASP.NET Core API?"
       }
     ],
+    "seoDescription": "Learn CancellationToken Propagation for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "CancellationToken Propagation Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "CancellationToken Propagation",
     "title": "CancellationToken Propagation",
     "topic": "Async programming, tasks, cancellation, and concurrency",
     "topicFolderPath": "NET/async-programming-tasks-cancellation-and-concurrency"
   },
   {
+    "canonicalPath": "/content/classes-structs-records/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/classes-structs-records-object-oriented-fundamentals.md",
     "folders": [
@@ -3470,12 +3994,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why are mutable structs considered dangerous?"
       }
     ],
+    "seoDescription": "Learn Classes, structs, records for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Classes, structs, records Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Classes, structs, records",
     "title": "Classes, structs, records",
     "topic": "C# Language Foundations",
     "topicFolderPath": "NET/c-language-foundations"
   },
   {
+    "canonicalPath": "/content/code-coverage-useful-assertions-flaky-test-prevention-and-ci-test-execution/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/code-coverage-useful-assertions-flaky-test-prevention-and-ci-test-execution.md",
     "folders": [
@@ -3510,12 +4040,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the difference between line coverage and branch coverage?"
       }
     ],
+    "seoDescription": "Learn Code Coverage, Useful Assertions, Flaky Test Prevention, and CI Test Execution for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Code Coverage, Useful Assertions, Flaky Test Prevention, and CI Test Execution Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Code Coverage, Useful Assertions, Flaky Test Prevention, and CI Test Execution",
     "title": "Code Coverage, Useful Assertions, Flaky Test Prevention, and CI Test Execution",
     "topic": "Testing strategy and integration testing",
     "topicFolderPath": "NET/testing-strategy-and-integration-testing"
   },
   {
+    "canonicalPath": "/content/collection-choices-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/collection-choices-in-csharp.md",
     "folders": [
@@ -3550,12 +4086,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you choose between List and HashSet?"
       }
     ],
+    "seoDescription": "Learn Collection Choices in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Collection Choices in C# Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Collection Choices in C#",
     "title": "Collection Choices in C#",
     "topic": "C# Language Foundations",
     "topicFolderPath": "NET/c-language-foundations"
   },
   {
+    "canonicalPath": "/content/common-bcl-types-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/common-bcl-types-in-csharp.md",
     "folders": [
@@ -3590,12 +4132,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When should you use decimal instead of double?"
       }
     ],
+    "seoDescription": "Learn Common BCL Types in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Common BCL Types in C# Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Common BCL Types in C#",
     "title": "Common BCL Types in C#",
     "topic": "C# Language Foundations",
     "topicFolderPath": "NET/c-language-foundations"
   },
   {
+    "canonicalPath": "/content/configuration-sources-and-the-options-pattern/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/configuration-sources-and-the-options-pattern.md",
     "folders": [
@@ -3630,12 +4178,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does configuration provider ordering work?"
       }
     ],
+    "seoDescription": "Learn Configuration Sources and the Options Pattern for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Configuration Sources and the Options Pattern Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Configuration Sources and the Options Pattern",
     "title": "Configuration Sources and the Options Pattern",
     "topic": "Dependency injection, configuration, middleware, and logging",
     "topicFolderPath": "NET/dependency-injection-configuration-middleware-and-logging"
   },
   {
+    "canonicalPath": "/content/content-negotiation-status-codes-dtos-request-response-contracts/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/content-negotiation-status-codes-dtos-request-response-contracts.md",
     "folders": [
@@ -3670,12 +4224,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why should APIs avoid returning EF Core entities directly?"
       }
     ],
+    "seoDescription": "Learn Content negotiation, status codes and request/response contracts for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Content negotiation, status codes and request/response contracts Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Content negotiation, status codes and request/response contracts",
     "title": "Content negotiation, status codes and request/response contracts",
     "topic": "API design and implementation",
     "topicFolderPath": "NET/api-design-and-implementation"
   },
   {
+    "canonicalPath": "/content/controllers-vs-minimal-apis-when-to-choose-each/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/controllers-vs-minimal-apis-when-to-choose-each.md",
     "folders": [
@@ -3710,12 +4270,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When would you choose Minimal APIs over controllers?"
       }
     ],
+    "seoDescription": "Learn Controllers vs Minimal APIs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Controllers vs Minimal APIs Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Controllers vs Minimal APIs",
     "title": "Controllers vs Minimal APIs",
     "topic": "API design and implementation",
     "topicFolderPath": "NET/api-design-and-implementation"
   },
   {
+    "canonicalPath": "/content/conventions-fluent-api-owned-complex-data-and-relationship-mapping/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/conventions-fluent-api-owned-complex-data-and-relationship-mapping.md",
     "folders": [
@@ -3750,12 +4316,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When should you use Fluent API instead of conventions or data annotations?"
       }
     ],
+    "seoDescription": "Learn Conventions, Fluent API, Owned/Complex Data, and Relationship Mapping for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Conventions, Fluent API, Owned/Complex Data, and Relationship Mapping Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Conventions, Fluent API, Owned/Complex Data, and Relationship Mapping",
     "title": "Conventions, Fluent API, Owned/Complex Data, and Relationship Mapping",
     "topic": "Entity Framework",
     "topicFolderPath": "NET/entity-framework"
   },
   {
+    "canonicalPath": "/content/cookie-behavior-csrf-browser-security-concerns/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/cookie-behavior-csrf-browser-security-concerns.md",
     "folders": [
@@ -3790,12 +4362,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do anti-forgery tokens prevent CSRF?"
       }
     ],
+    "seoDescription": "Learn Cookie behavior, CSRF, and browser-based security concerns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Cookie behavior, CSRF, and browser-based security concerns Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Cookie behavior, CSRF, and browser-based security concerns",
     "title": "Cookie behavior, CSRF, and browser-based security concerns",
     "topic": "Authentication, authorization, and web security",
     "topicFolderPath": "NET/authentication-authorization-and-web-security"
   },
   {
+    "canonicalPath": "/content/coordinating-multiple-tasks-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/coordinating-multiple-tasks-in-csharp.md",
     "folders": [
@@ -3830,12 +4408,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do exceptions behave with Task.WhenAll?"
       }
     ],
+    "seoDescription": "Learn Coordinating Multiple Tasks in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Coordinating Multiple Tasks in C# Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Coordinating Multiple Tasks in C#",
     "title": "Coordinating Multiple Tasks in C#",
     "topic": "Async programming, tasks, cancellation, and concurrency",
     "topicFolderPath": "NET/async-programming-tasks-cancellation-and-concurrency"
   },
   {
+    "canonicalPath": "/content/cors-secure-headers-secret-handling-and-least-privilege/",
+    "canonicalPathSource": "generated",
     "category": "Design & Architecture",
     "contentPath": "/src/contents/v1/NET/cors-secure-headers-secret-handling-least-privilege.md",
     "folders": [
@@ -3870,12 +4454,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why is AllowAnyOrigin dangerous for authenticated APIs?"
       }
     ],
+    "seoDescription": "Learn CORS, secure headers, secret handling, and least privilege for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "CORS, secure headers, secret handling, and least privilege Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "CORS, secure headers, secret handling, and least privilege",
     "title": "CORS, secure headers, secret handling, and least privilege",
     "topic": "Authentication, authorization, and web security",
     "topicFolderPath": "NET/authentication-authorization-and-web-security"
   },
   {
+    "canonicalPath": "/content/cpu-bound-vs-io-bound-work-and-task-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/cpu-bound-vs-io-bound-work-and-task-in-csharp.md",
     "folders": [
@@ -3910,12 +4500,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why should you not usually wrap I/O-bound work in Task.Run?"
       }
     ],
+    "seoDescription": "Learn CPU-bound vs I/O-bound Work and Task for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "CPU-bound vs I/O-bound Work and Task Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "CPU-bound vs I/O-bound Work and Task",
     "title": "CPU-bound vs I/O-bound Work and Task",
     "topic": "Async programming, tasks, cancellation, and concurrency",
     "topicFolderPath": "NET/async-programming-tasks-cancellation-and-concurrency"
   },
   {
+    "canonicalPath": "/content/data-seeding-choices-including-hasdata-vs-runtime-seed-logic/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/data-seeding-choices-including-hasdata-vs-runtime-seed-logic.md",
     "folders": [
@@ -3950,12 +4546,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the difference between HasData and runtime seed logic?"
       }
     ],
+    "seoDescription": "Learn Data Seeding Choices, Including HasData vs Runtime Seed Logic for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Data Seeding Choices, Including HasData vs Runtime Seed Logic Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Data Seeding Choices, Including HasData vs Runtime Seed Logic",
     "title": "Data Seeding Choices, Including HasData vs Runtime Seed Logic",
     "topic": "Entity Framework",
     "topicFolderPath": "NET/entity-framework"
   },
   {
+    "canonicalPath": "/content/dbcontext-change-tracking-and-entity-state-management-in-ef-core/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/dbcontext-change-tracking-and-entity-state-management-in-ef-core.md",
     "folders": [
@@ -3990,12 +4592,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the difference between Add, Attach, and Update?"
       }
     ],
+    "seoDescription": "Learn DbContext change tracking and entity state management in EF Core for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "DbContext change tracking and entity state management in EF Core Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "DbContext change tracking and entity state management in EF Core",
     "title": "DbContext change tracking and entity state management in EF Core",
     "topic": "Entity Framework",
     "topicFolderPath": "NET/entity-framework"
   },
   {
+    "canonicalPath": "/content/dbcontext-lifetime-thread-safety-connection-usage-and-when-to-avoid-sharing-a-context/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/dbcontext-lifetime-thread-safety-connection-usage-and-when-to-avoid-sharing-a-context.md",
     "folders": [
@@ -4030,12 +4638,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When should you use IDbContextFactory?"
       }
     ],
+    "seoDescription": "Learn DbContext Lifetime, Thread Safety, Connection Usage, and When to Avoid Sharing a Context for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "DbContext Lifetime, Thread Safety, Connection Usage, and When to Avoid Sharing a Context Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "DbContext Lifetime, Thread Safety, Connection Usage, and When to Avoid Sharing a Context",
     "title": "DbContext Lifetime, Thread Safety, Connection Usage, and When to Avoid Sharing a Context",
     "topic": "Entity Framework",
     "topicFolderPath": "NET/entity-framework"
   },
   {
+    "canonicalPath": "/content/deferred-execution-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/deferred-execution-in-csharp.md",
     "folders": [
@@ -4070,12 +4684,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why can multiple enumeration be a problem?"
       }
     ],
+    "seoDescription": "Learn Deferred Execution in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Deferred Execution in C# Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Deferred Execution in C#",
     "title": "Deferred Execution in C#",
     "topic": "Modern C# patterns",
     "topicFolderPath": "NET/modern-c-patterns"
   },
   {
+    "canonicalPath": "/content/delegates-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/delegates-in-csharp.md",
     "folders": [
@@ -4110,12 +4730,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is a multicast delegate?"
       }
     ],
+    "seoDescription": "Learn Delegates for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Delegates Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Delegates",
     "title": "Delegates",
     "topic": "Modern C# patterns",
     "topicFolderPath": "NET/modern-c-patterns"
   },
   {
+    "canonicalPath": "/content/di-di-container-basics-lifetimes-and-constructor-selection-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/di-di-container-basics-lifetimes-and-constructor-selection-in-csharp.md",
     "folders": [
@@ -4150,12 +4776,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the difference between transient, scoped, and singleton services?"
       }
     ],
+    "seoDescription": "Learn DI, DI Container Basics for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "DI, DI Container Basics Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "DI, DI Container Basics",
     "title": "DI, DI Container Basics",
     "topic": "Dependency injection, configuration, middleware, and logging",
     "topicFolderPath": "NET/dependency-injection-configuration-middleware-and-logging"
   },
   {
+    "canonicalPath": "/content/eager-explicit-and-lazy-loading-including-the-n-plus-one-query-problem/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/eager-explicit-and-lazy-loading-including-the-n-plus-one-query-problem.md",
     "folders": [
@@ -4190,12 +4822,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When would you use eager loading instead of explicit or lazy loading?"
       }
     ],
+    "seoDescription": "Learn Eager, Explicit, and Lazy Loading, Including the N+1 Query Problem for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Eager, Explicit, and Lazy Loading, Including the N+1 Query Problem Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Eager, Explicit, and Lazy Loading, Including the N+1 Query Problem",
     "title": "Eager, Explicit, and Lazy Loading, Including the N+1 Query Problem",
     "topic": "Entity Framework",
     "topicFolderPath": "NET/entity-framework"
   },
   {
+    "canonicalPath": "/content/ef-core-inmemory-provider-caveats-and-when-sqlite-docker-databases-or-testcontainers-are-safer/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/ef-core-inmemory-provider-caveats-and-when-sqlite-docker-databases-or-testcontainers-are-safer.md",
     "folders": [
@@ -4230,12 +4868,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What database behaviors can InMemory fail to catch?"
       }
     ],
+    "seoDescription": "Learn EF Core InMemory Provider Caveats and When SQLite, Docker Databases, or Testcontainers Are Safer for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "EF Core InMemory Provider Caveats and When SQLite, Docker Databases, or Testcontainers Are Safer Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "EF Core InMemory Provider Caveats and When SQLite, Docker Databases, or Testcontainers Are Safer",
     "title": "EF Core InMemory Provider Caveats and When SQLite, Docker Databases, or Testcontainers Are Safer",
     "topic": "Testing strategy and integration testing",
     "topicFolderPath": "NET/testing-strategy-and-integration-testing"
   },
   {
+    "canonicalPath": "/content/ef-core-migrations-and-production-migration-safety/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/ef-core-migrations-and-production-migration-safety.md",
     "folders": [
@@ -4270,12 +4914,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why should production migrations usually use reviewed SQL scripts?"
       }
     ],
+    "seoDescription": "Learn EF Core migrations and production migration safety for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "EF Core migrations and production migration safety Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "EF Core migrations and production migration safety",
     "title": "EF Core migrations and production migration safety",
     "topic": "Entity Framework",
     "topicFolderPath": "NET/entity-framework"
   },
   {
+    "canonicalPath": "/content/endpoint-routing-and-route-matching-in-aspnet-core/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/endpoint-routing-and-route-matching-in-aspnet-core.md",
     "folders": [
@@ -4310,12 +4960,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does ASP.NET Core choose between multiple matching routes?"
       }
     ],
+    "seoDescription": "Learn Endpoint routing and route matching for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Endpoint routing and route matching Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Endpoint routing and route matching",
     "title": "Endpoint routing and route matching",
     "topic": "API design and implementation",
     "topicFolderPath": "NET/api-design-and-implementation"
   },
   {
+    "canonicalPath": "/content/exception-handling-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/exception-handling-in-csharp.md",
     "folders": [
@@ -4350,12 +5006,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How should exceptions be handled in async methods?"
       }
     ],
+    "seoDescription": "Learn Exception Handling in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Exception Handling in C# Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Exception Handling in C#",
     "title": "Exception Handling in C#",
     "topic": "Async programming, tasks, cancellation, and concurrency",
     "topicFolderPath": "NET/async-programming-tasks-cancellation-and-concurrency"
   },
   {
+    "canonicalPath": "/content/exceptions-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/exceptions-in-csharp.md",
     "folders": [
@@ -4390,12 +5052,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you choose which exception type to throw?"
       }
     ],
+    "seoDescription": "Learn Exceptions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Exceptions Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Exceptions",
     "title": "Exceptions",
     "topic": "C# Language Foundations",
     "topicFolderPath": "NET/c-language-foundations"
   },
   {
+    "canonicalPath": "/content/generic-type-constraints-and-reusable-components-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/generic-type-constraints-and-reusable-components-csharp.md",
     "folders": [
@@ -4430,12 +5098,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the difference between class, class?, and notnull constraints?"
       }
     ],
+    "seoDescription": "Learn Generic Type Constraints and Reusable Components for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Generic Type Constraints and Reusable Components Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Generic Type Constraints and Reusable Components",
     "title": "Generic Type Constraints and Reusable Components",
     "topic": "Modern C# patterns",
     "topicFolderPath": "NET/modern-c-patterns"
   },
   {
+    "canonicalPath": "/content/ienumerable-vs-iqueryable-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/ienumerable-vs-iqueryable-in-csharp.md",
     "folders": [
@@ -4470,12 +5144,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why can using IEnumerable with EF Core cause performance problems?"
       }
     ],
+    "seoDescription": "Learn IEnumerable vs IQueryable in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "IEnumerable vs IQueryable in C# Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "IEnumerable vs IQueryable in C#",
     "title": "IEnumerable vs IQueryable in C#",
     "topic": "Modern C# patterns",
     "topicFolderPath": "NET/modern-c-patterns"
   },
   {
+    "canonicalPath": "/content/ihttpclientfactory-and-resilient-outbound-http/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/ihttpclientfactory-and-resilient-outbound-http.md",
     "folders": [
@@ -4510,12 +5190,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does IHttpClientFactory help with socket exhaustion and DNS changes?"
       }
     ],
+    "seoDescription": "Learn IHttpClientFactory and Resilient Outbound HTTP for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "IHttpClientFactory and Resilient Outbound HTTP Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "IHttpClientFactory and Resilient Outbound HTTP",
     "title": "IHttpClientFactory and Resilient Outbound HTTP",
     "topic": "Performance, scalability, and caching",
     "topicFolderPath": "NET/performance-scalability-and-caching"
   },
   {
+    "canonicalPath": "/content/in-memory-distributed-hybrid-output-caching/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/in-memory-distributed-hybrid-output-caching.md",
     "folders": [
@@ -4550,12 +5236,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you choose between in-memory, distributed, hybrid, and output caching?"
       }
     ],
+    "seoDescription": "Learn In-memory, distributed, hybrid, and output caching for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "In-memory, distributed, hybrid, and output caching Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "In-memory, distributed, hybrid, and output caching",
     "title": "In-memory, distributed, hybrid, and output caching",
     "topic": "Performance, scalability, and caching",
     "topicFolderPath": "NET/performance-scalability-and-caching"
   },
   {
+    "canonicalPath": "/content/jwt-bearer-auth-claims-scopes-and-policy-based-authorization/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/jwt-bearer-auth-claims-scopes-and-policy-based-authorization.md",
     "folders": [
@@ -4590,12 +5282,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the difference between scopes and roles?"
       }
     ],
+    "seoDescription": "Learn JWT Bearer Auth, Claims, Scopes, and Policy-Based Authorization for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "JWT Bearer Auth, Claims, Scopes, and Policy-Based Authorization Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "JWT Bearer Auth, Claims, Scopes, and Policy-Based Authorization",
     "title": "JWT Bearer Auth, Claims, Scopes, and Policy-Based Authorization",
     "topic": "Authentication, authorization, and web security",
     "topicFolderPath": "NET/authentication-authorization-and-web-security"
   },
   {
+    "canonicalPath": "/content/linq-querying-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/linq-querying-in-csharp.md",
     "folders": [
@@ -4630,12 +5328,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the difference between IEnumerable and IQueryable?"
       }
     ],
+    "seoDescription": "Learn LINQ Querying for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "LINQ Querying Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "LINQ Querying",
     "title": "LINQ Querying",
     "topic": "Modern C# patterns",
     "topicFolderPath": "NET/modern-c-patterns"
   },
   {
+    "canonicalPath": "/content/middleware-ordering-and-cross-cutting-behavior/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/middleware-ordering-and-cross-cutting-behavior.md",
     "folders": [
@@ -4670,12 +5374,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the correct order for authentication and authorization middleware?"
       }
     ],
+    "seoDescription": "Learn Middleware Ordering and Cross-Cutting Behavior for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Middleware Ordering and Cross-Cutting Behavior Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Middleware Ordering and Cross-Cutting Behavior",
     "title": "Middleware Ordering and Cross-Cutting Behavior",
     "topic": "Dependency injection, configuration, middleware, and logging",
     "topicFolderPath": "NET/dependency-injection-configuration-middleware-and-logging"
   },
   {
+    "canonicalPath": "/content/nullable-reference-types-and-null-safety-habits-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/nullable-reference-types-and-null-safety-habits-in-csharp.md",
     "folders": [
@@ -4710,12 +5420,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does C# null-state analysis work?"
       }
     ],
+    "seoDescription": "Learn Nullable reference  C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Nullable reference  C# Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Nullable reference  C#",
     "title": "Nullable reference  C#",
     "topic": "C# Language Foundations",
     "topicFolderPath": "NET/c-language-foundations"
   },
   {
+    "canonicalPath": "/content/observer-style-communication-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/observer-style-communication-in-csharp.md",
     "folders": [
@@ -4750,12 +5466,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What problem does the observer pattern solve?"
       }
     ],
+    "seoDescription": "Learn Observer-Style Communication in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Observer-Style Communication in C# Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Observer-Style Communication in C#",
     "title": "Observer-Style Communication in C#",
     "topic": "Modern C# patterns",
     "topicFolderPath": "NET/modern-c-patterns"
   },
   {
+    "canonicalPath": "/content/object-oriented-fundamentals/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/oop.md",
     "folders": [
@@ -4790,12 +5512,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is abstraction in C#?"
       }
     ],
+    "seoDescription": "Learn Object-Oriented Programming for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Object-Oriented Programming Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Object-Oriented Programming",
     "title": "Object-Oriented Programming",
     "topic": "C# Language Foundations",
     "topicFolderPath": "NET/c-language-foundations"
   },
   {
+    "canonicalPath": "/content/openapi-generation-endpoint-metadata-api-discoverability/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/openapi-generation-endpoint-metadata-api-discoverability.md",
     "folders": [
@@ -4830,12 +5558,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do Minimal APIs provide metadata for OpenAPI generation?"
       }
     ],
+    "seoDescription": "Learn OpenAPI generation and API discoverability for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "OpenAPI generation and API discoverability Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "OpenAPI generation and API discoverability",
     "title": "OpenAPI generation and API discoverability",
     "topic": "API design and implementation",
     "topicFolderPath": "NET/api-design-and-implementation"
   },
   {
+    "canonicalPath": "/content/optimistic-concurrency-transactions-savepoints-conflict-handling/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/optimistic-concurrency-transactions-savepoints-conflict-handling.md",
     "folders": [
@@ -4870,12 +5604,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does EF Core use a rowversion column to detect concurrency conflicts?"
       }
     ],
+    "seoDescription": "Learn Optimistic concurrency, transactions, savepoints, and conflict handling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Optimistic concurrency, transactions, savepoints, and conflict handling Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Optimistic concurrency, transactions, savepoints, and conflict handling",
     "title": "Optimistic concurrency, transactions, savepoints, and conflict handling",
     "topic": "Entity Framework",
     "topicFolderPath": "NET/entity-framework"
   },
   {
+    "canonicalPath": "/content/overriding-services-and-configuration-for-tests/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/overriding-services-and-configuration-for-tests.md",
     "folders": [
@@ -4910,12 +5650,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the difference between ConfigureServices and ConfigureTestServices?"
       }
     ],
+    "seoDescription": "Learn Overriding services and configuration in .NET tests for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Overriding services and configuration in .NET tests Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Overriding services and configuration in .NET tests",
     "title": "Overriding services and configuration in .NET tests",
     "topic": "Testing strategy and integration testing",
     "topicFolderPath": "NET/testing-strategy-and-integration-testing"
   },
   {
+    "canonicalPath": "/content/parameter-binding-from-route-query-string-body-form-header-and-services/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/parameter-binding-from-route-query-string-body-form-header-and-services.md",
     "folders": [
@@ -4950,12 +5696,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does [ApiController] affect parameter binding in controller APIs?"
       }
     ],
+    "seoDescription": "Learn Parameter Binding for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Parameter Binding Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Parameter Binding",
     "title": "Parameter Binding",
     "topic": "API design and implementation",
     "topicFolderPath": "NET/api-design-and-implementation"
   },
   {
+    "canonicalPath": "/content/pattern-matching-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/pattern-matching-in-csharp.md",
     "folders": [
@@ -4990,12 +5742,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What are property patterns and when would you use them?"
       }
     ],
+    "seoDescription": "Learn Pattern Matching in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Pattern Matching in C# Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Pattern Matching in C#",
     "title": "Pattern Matching in C#",
     "topic": "Modern C# patterns",
     "topicFolderPath": "NET/modern-c-patterns"
   },
   {
+    "canonicalPath": "/content/rate-limiting-memory-gc-awareness-runtime-diagnostics/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/rate-limiting-memory-gc-awareness-runtime-diagnostics.md",
     "folders": [
@@ -5030,12 +5788,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you configure rate limiting in ASP.NET Core?"
       }
     ],
+    "seoDescription": "Learn Rate limiting, memory/GC awareness, and runtime diagnostics for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Rate limiting, memory/GC awareness, and runtime diagnostics Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Rate limiting, memory/GC awareness, and runtime diagnostics",
     "title": "Rate limiting, memory/GC awareness, and runtime diagnostics",
     "topic": "Performance, scalability, and caching",
     "topicFolderPath": "NET/performance-scalability-and-caching"
   },
   {
+    "canonicalPath": "/content/records-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/records-in-csharp.md",
     "folders": [
@@ -5070,12 +5834,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When should you use a record instead of a class?"
       }
     ],
+    "seoDescription": "Learn Records in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Records in C# Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Records in C#",
     "title": "Records in C#",
     "topic": "Modern C# patterns",
     "topicFolderPath": "NET/modern-c-patterns"
   },
   {
+    "canonicalPath": "/content/structured-logging-and-correlation/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/structured-logging-and-correlation.md",
     "folders": [
@@ -5110,12 +5880,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is ILogger.BeginScope and when would you use it?"
       }
     ],
+    "seoDescription": "Learn Structured Logging and Correlation for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Structured Logging and Correlation Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Structured Logging and Correlation",
     "title": "Structured Logging and Correlation",
     "topic": "Dependency injection, configuration, middleware, and logging",
     "topicFolderPath": "NET/dependency-injection-configuration-middleware-and-logging"
   },
   {
+    "canonicalPath": "/content/switch-expressions-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/switch-expressions-in-csharp.md",
     "folders": [
@@ -5150,12 +5926,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does arm ordering affect a switch expression?"
       }
     ],
+    "seoDescription": "Learn Switch Expressions in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Switch Expressions in C# Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Switch Expressions in C#",
     "title": "Switch Expressions in C#",
     "topic": "Modern C# patterns",
     "topicFolderPath": "NET/modern-c-patterns"
   },
   {
+    "canonicalPath": "/content/test-doubles-mocks-stubs-fakes-mocking-integration-problems/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/test-doubles-mocks-stubs-fakes-mocking-integration-problems.md",
     "folders": [
@@ -5190,12 +5972,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When should you use a mock instead of a fake?"
       }
     ],
+    "seoDescription": "Learn Test doubles, mocking boundaries, and integration risks in .NET for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Test doubles, mocking boundaries, and integration risks in .NET Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Test doubles, mocking boundaries, and integration risks in .NET",
     "title": "Test doubles, mocking boundaries, and integration risks in .NET",
     "topic": "Testing strategy and integration testing",
     "topicFolderPath": "NET/testing-strategy-and-integration-testing"
   },
   {
+    "canonicalPath": "/content/testing-authentication-authorization-middleware-filters-validation-error-responses/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/testing-authentication-authorization-middleware-filters-validation-error-responses.md",
     "folders": [
@@ -5230,12 +6018,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How can you test a protected endpoint without calling a real identity provider?"
       }
     ],
+    "seoDescription": "Learn Testing ASP.NET Core security, pipeline behavior, validation, and error responses for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Testing ASP.NET Core security, pipeline behavior, validation, and error responses Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Testing ASP.NET Core security, pipeline behavior, validation, and error responses",
     "title": "Testing ASP.NET Core security, pipeline behavior, validation, and error responses",
     "topic": "Testing strategy and integration testing",
     "topicFolderPath": "NET/testing-strategy-and-integration-testing"
   },
   {
+    "canonicalPath": "/content/timeouts-in-csharp/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/timeouts-in-csharp.md",
     "folders": [
@@ -5270,12 +6064,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the difference between Task.WaitAsync and CancellationTokenSource.CancelAfter?"
       }
     ],
+    "seoDescription": "Learn Timeouts in C# for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Timeouts in C# Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Timeouts in C#",
     "title": "Timeouts in C#",
     "topic": "Async programming, tasks, cancellation, and concurrency",
     "topicFolderPath": "NET/async-programming-tasks-cancellation-and-concurrency"
   },
   {
+    "canonicalPath": "/content/tracking-vs-no-tracking-queries-and-identity-resolution/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/tracking-vs-no-tracking-queries-and-identity-resolution.md",
     "folders": [
@@ -5310,12 +6110,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is identity resolution in EF Core?"
       }
     ],
+    "seoDescription": "Learn Tracking vs no-tracking queries and identity resolution for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Tracking vs no-tracking queries and identity resolution Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Tracking vs no-tracking queries and identity resolution",
     "title": "Tracking vs no-tracking queries and identity resolution",
     "topic": "Entity Framework",
     "topicFolderPath": "NET/entity-framework"
   },
   {
+    "canonicalPath": "/content/unit-tests-integration-tests-and-hosted-services-for-background-jobs/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/unit-tests-integration-tests-and-hosted-services-for-background-jobs.md",
     "folders": [
@@ -5350,12 +6156,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you test a BackgroundService without testing an infinite loop?"
       }
     ],
+    "seoDescription": "Learn Unit Tests, Integration Tests, and Hosted Services for Background Jobs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Unit Tests, Integration Tests, and Hosted Services for Background Jobs Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Unit Tests, Integration Tests, and Hosted Services for Background Jobs",
     "title": "Unit Tests, Integration Tests, and Hosted Services for Background Jobs",
     "topic": "Performance, scalability, and caching",
     "topicFolderPath": "NET/performance-scalability-and-caching"
   },
   {
+    "canonicalPath": "/content/unit-tests-vs-integration-tests-vs-end-to-end-tests/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/unit-tests-vs-integration-tests-vs-end-to-end-tests.md",
     "folders": [
@@ -5390,12 +6202,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the testing pyramid?"
       }
     ],
+    "seoDescription": "Learn Unit Tests vs Integration Tests vs End-to-End Tests for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Unit Tests vs Integration Tests vs End-to-End Tests Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Unit Tests vs Integration Tests vs End-to-End Tests",
     "title": "Unit Tests vs Integration Tests vs End-to-End Tests",
     "topic": "Testing strategy and integration testing",
     "topicFolderPath": "NET/testing-strategy-and-integration-testing"
   },
   {
+    "canonicalPath": "/content/value-types-vs-reference-types/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/value-types-vs-reference-types.md",
     "folders": [
@@ -5430,12 +6248,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is boxing and unboxing?"
       }
     ],
+    "seoDescription": "Learn Value Types vs Reference Types for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Value Types vs Reference Types Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Value Types vs Reference Types",
     "title": "Value Types vs Reference Types",
     "topic": "C# Language Foundations",
     "topicFolderPath": "NET/c-language-foundations"
   },
   {
+    "canonicalPath": "/content/webapplicationfactory-testserver-httpclient-and-full-aspnet-core-pipeline-testing/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/webapplicationfactory-testserver-httpclient-and-full-aspnet-core-pipeline-testing.md",
     "folders": [
@@ -5470,12 +6294,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you customize WebApplicationFactory for integration tests?"
       }
     ],
+    "seoDescription": "Learn WebApplicationFactory, TestServer, HttpClient, and Full ASP.NET Core Pipeline Testing for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "WebApplicationFactory, TestServer, HttpClient, and Full ASP.NET Core Pipeline Testing Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "WebApplicationFactory, TestServer, HttpClient, and Full ASP.NET Core Pipeline Testing",
     "title": "WebApplicationFactory, TestServer, HttpClient, and Full ASP.NET Core Pipeline Testing",
     "topic": "Testing strategy and integration testing",
     "topicFolderPath": "NET/testing-strategy-and-integration-testing"
   },
   {
+    "canonicalPath": "/content/xunit-nunit-mstest-test-naming-aaa-test-data-setup/",
+    "canonicalPathSource": "generated",
     "category": ".NET",
     "contentPath": "/src/contents/v1/NET/xunit-nunit-mstest-test-naming-aaa-test-data-setup.md",
     "folders": [
@@ -5510,12 +6340,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do setup and teardown differ between xUnit, NUnit, and MSTest?"
       }
     ],
+    "seoDescription": "Learn Unit testing frameworks, naming, AAA, and test data setup in .NET for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Unit testing frameworks, naming, AAA, and test data setup in .NET Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Unit testing frameworks, naming, AAA, and test data setup in .NET",
     "title": "Unit testing frameworks, naming, AAA, and test data setup in .NET",
     "topic": "Testing strategy and integration testing",
     "topicFolderPath": "NET/testing-strategy-and-integration-testing"
   },
   {
+    "canonicalPath": "/content/access-tokens-refresh-tokens-expiration-handling-retrying-original-requests-and-refresh-token-queue-patterns/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/access-tokens-refresh-tokens-expiration-handling-retrying-original-requests-and-refresh-token-queue-patterns.md",
     "folders": [
@@ -5550,12 +6386,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you retry the original request after refreshing a token?"
       }
     ],
+    "seoDescription": "Learn Access tokens, refresh tokens, expiration handling, retrying original requests, and refresh-token queue patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Access tokens, refresh tokens, expiration handling, retrying original requests, and refresh-token queue patterns Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Access tokens, refresh tokens, expiration handling, retrying original requests, and refresh-token queue patterns",
     "title": "Access tokens, refresh tokens, expiration handling, retrying original requests, and refresh-token queue patterns",
     "topic": "Production data access, API clients, and frontend auth",
     "topicFolderPath": "React/production-data-access-api-clients-and-frontend-auth"
   },
   {
+    "canonicalPath": "/content/axios-request-and-response-interceptors-for-auth-headers-global-errors-logging-and-retry-behavior/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/axios-request-and-response-interceptors-for-auth-headers-global-errors-logging-and-retry-behavior.md",
     "folders": [
@@ -5590,12 +6432,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you add an auth header with an Axios request interceptor?"
       }
     ],
+    "seoDescription": "Learn Axios request and response interceptors for auth headers, global errors, logging, and retry behavior for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Axios request and response interceptors for auth headers, global errors, logging, and retry behavior Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Axios request and response interceptors for auth headers, global errors, logging, and retry behavior",
     "title": "Axios request and response interceptors for auth headers, global errors, logging, and retry behavior",
     "topic": "Production data access, API clients, and frontend auth",
     "topicFolderPath": "React/production-data-access-api-clients-and-frontend-auth"
   },
   {
+    "canonicalPath": "/content/browser-storage-trade-offs-localstorage-sessionstorage-memory-storage-and-cookies/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/browser-storage-trade-offs-localstorage-sessionstorage-memory-storage-and-cookies.md",
     "folders": [
@@ -5630,12 +6478,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why is storing tokens in localStorage risky?"
       }
     ],
+    "seoDescription": "Learn Browser storage trade-offs: localStorage, sessionStorage, memory storage, and cookies for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Browser storage trade-offs: localStorage, sessionStorage, memory storage, and cookies Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Browser storage trade-offs: localStorage, sessionStorage, memory storage, and cookies",
     "title": "Browser storage trade-offs: localStorage, sessionStorage, memory storage, and cookies",
     "topic": "Production data access, API clients, and frontend auth",
     "topicFolderPath": "React/production-data-access-api-clients-and-frontend-auth"
   },
   {
+    "canonicalPath": "/content/built-in-validation-async-validation-and-schema-resolvers-with-yup-or-zod/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/built-in-validation-async-validation-and-schema-resolvers-with-yup-or-zod.md",
     "folders": [
@@ -5670,12 +6524,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When would you use built-in rules instead of a schema resolver?"
       }
     ],
+    "seoDescription": "Learn Built-in validation, async validation, and schema resolvers with Yup or Zod for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Built-in validation, async validation, and schema resolvers with Yup or Zod Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Built-in validation, async validation, and schema resolvers with Yup or Zod",
     "title": "Built-in validation, async validation, and schema resolvers with Yup or Zod",
     "topic": "Forms, validation, and frontend performance in production",
     "topicFolderPath": "React/forms-validation-and-frontend-performance-in-production"
   },
   {
+    "canonicalPath": "/content/centralized-api-clients-with-fetch-axios-rtk-query-or-tanstack-query/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/centralized-api-clients-with-fetch-axios-rtk-query-or-tanstack-query.md",
     "folders": [
@@ -5710,12 +6570,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When would you choose a simple fetch wrapper instead of TanStack Query or RTK Query?"
       }
     ],
+    "seoDescription": "Learn Centralized API clients with `fetch`, Axios, RTK Query, or TanStack Query for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Centralized API clients with `fetch`, Axios, RTK Query, or TanStack Query Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Centralized API clients with `fetch`, Axios, RTK Query, or TanStack Query",
     "title": "Centralized API clients with `fetch`, Axios, RTK Query, or TanStack Query",
     "topic": "Production data access, API clients, and frontend auth",
     "topicFolderPath": "React/production-data-access-api-clients-and-frontend-auth"
   },
   {
+    "canonicalPath": "/content/closures-lexical-scope/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/closures-lexical-scope.md",
     "folders": [
@@ -5750,12 +6616,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is a stale closure?"
       }
     ],
+    "seoDescription": "Learn Closures and lexical scope for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Closures and lexical scope Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Closures and lexical scope",
     "title": "Closures and lexical scope",
     "topic": "JavaScript fundamentals",
     "topicFolderPath": "React/javascript-fundamentals"
   },
   {
+    "canonicalPath": "/content/code-splitting-lazy-loading-bundle-analysis-and-route-level-loading/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/code-splitting-lazy-loading-bundle-analysis-and-route-level-loading.md",
     "folders": [
@@ -5790,12 +6662,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How should Suspense boundaries be placed for route loading?"
       }
     ],
+    "seoDescription": "Learn Code splitting, lazy loading, bundle analysis, and route-level loading for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Code splitting, lazy loading, bundle analysis, and route-level loading Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Code splitting, lazy loading, bundle analysis, and route-level loading",
     "title": "Code splitting, lazy loading, bundle analysis, and route-level loading",
     "topic": "Forms, validation, and frontend performance in production",
     "topicFolderPath": "React/forms-validation-and-frontend-performance-in-production"
   },
   {
+    "canonicalPath": "/content/context-plus-reducer-vs-external-stores/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/context-plus-reducer-vs-external-stores.md",
     "folders": [
@@ -5830,12 +6708,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When would you use context plus reducer?"
       }
     ],
+    "seoDescription": "Learn Context plus reducer vs external stores for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Context plus reducer vs external stores Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Context plus reducer vs external stores",
     "title": "Context plus reducer vs external stores",
     "topic": "State management, performance, and rendering optimization",
     "topicFolderPath": "React/state-management-performance-and-rendering-optimization"
   },
   {
+    "canonicalPath": "/content/controlled-inputs-and-event-handling/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/controlled-inputs-and-event-handling.md",
     "folders": [
@@ -5870,12 +6754,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why should form submission usually be handled with onSubmit?"
       }
     ],
+    "seoDescription": "Learn Controlled inputs and event handling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Controlled inputs and event handling Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Controlled inputs and event handling",
     "title": "Controlled inputs and event handling",
     "topic": "Components, props, state, and rendering behavior",
     "topicFolderPath": "React/components-props-state-and-rendering-behavior"
   },
   {
+    "canonicalPath": "/content/debounce-and-throttle-for-search-filtering-autosave-and-expensive-ui-updates/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/debounce-and-throttle-for-search-filtering-autosave-and-expensive-ui-updates.md",
     "folders": [
@@ -5910,12 +6800,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you avoid stale search results with debounced requests?"
       }
     ],
+    "seoDescription": "Learn Debounce and throttle for search, filtering, autosave, and expensive UI updates for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Debounce and throttle for search, filtering, autosave, and expensive UI updates Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Debounce and throttle for search, filtering, autosave, and expensive UI updates",
     "title": "Debounce and throttle for search, filtering, autosave, and expensive UI updates",
     "topic": "Forms, validation, and frontend performance in production",
     "topicFolderPath": "React/forms-validation-and-frontend-performance-in-production"
   },
   {
+    "canonicalPath": "/content/debugging-rendering-hydration-and-interaction-issues/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/debugging-rendering-hydration-and-interaction-issues.md",
     "folders": [
@@ -5950,12 +6846,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you debug a component that loses input state after sorting a list?"
       }
     ],
+    "seoDescription": "Learn Debugging rendering, hydration, and interaction issues for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Debugging rendering, hydration, and interaction issues Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Debugging rendering, hydration, and interaction issues",
     "title": "Debugging rendering, hydration, and interaction issues",
     "topic": "Testing, accessibility, and frontend debugging",
     "topicFolderPath": "React/testing-accessibility-and-frontend-debugging"
   },
   {
+    "canonicalPath": "/content/error-states-and-retry-ux-for-failed-requests/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/error-states-and-retry-ux-for-failed-requests.md",
     "folders": [
@@ -5990,12 +6892,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How should route error boundaries be used for failed requests?"
       }
     ],
+    "seoDescription": "Learn Error states and retry UX for failed requests for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Error states and retry UX for failed requests Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Error states and retry UX for failed requests",
     "title": "Error states and retry UX for failed requests",
     "topic": "Routing, forms, and server communication",
     "topicFolderPath": "React/routing-forms-and-server-communication"
   },
   {
+    "canonicalPath": "/content/forms-validation-optimistic-updates-and-mutation-states/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/forms-validation-optimistic-updates-and-mutation-states.md",
     "folders": [
@@ -6030,12 +6938,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How should expected validation errors be returned and displayed?"
       }
     ],
+    "seoDescription": "Learn Forms, validation, optimistic updates, and mutation states for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Forms, validation, optimistic updates, and mutation states Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Forms, validation, optimistic updates, and mutation states",
     "title": "Forms, validation, optimistic updates, and mutation states",
     "topic": "Routing, forms, and server communication",
     "topicFolderPath": "React/routing-forms-and-server-communication"
   },
   {
+    "canonicalPath": "/content/functional-components-and-jsx-composition/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/functional-components-and-jsx-composition.md",
     "folders": [
@@ -6070,12 +6984,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What are the most important JSX rules to remember?"
       }
     ],
+    "seoDescription": "Learn Functional components and JSX composition for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Functional components and JSX composition Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Functional components and JSX composition",
     "title": "Functional components and JSX composition",
     "topic": "Components, props, state, and rendering behavior",
     "topicFolderPath": "React/components-props-state-and-rendering-behavior"
   },
   {
+    "canonicalPath": "/content/global-loading-error-unauthorized-and-network-failure-ux-patterns/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/global-loading-error-unauthorized-and-network-failure-ux-patterns.md",
     "folders": [
@@ -6110,12 +7030,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How should background refetch failures be displayed?"
       }
     ],
+    "seoDescription": "Learn Global loading, error, unauthorized, and network-failure UX patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Global loading, error, unauthorized, and network-failure UX patterns Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Global loading, error, unauthorized, and network-failure UX patterns",
     "title": "Global loading, error, unauthorized, and network-failure UX patterns",
     "topic": "Production data access, API clients, and frontend auth",
     "topicFolderPath": "React/production-data-access-api-clients-and-frontend-auth"
   },
   {
+    "canonicalPath": "/content/keyboard-accessibility-semantic-html-aria-and-labels-ids/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/keyboard-accessibility-semantic-html-aria-and-labels-ids.md",
     "folders": [
@@ -6150,12 +7076,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When should you use ARIA in React?"
       }
     ],
+    "seoDescription": "Learn Keyboard accessibility, semantic HTML, ARIA, and labels/IDs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Keyboard accessibility, semantic HTML, ARIA, and labels/IDs Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Keyboard accessibility, semantic HTML, ARIA, and labels/IDs",
     "title": "Keyboard accessibility, semantic HTML, ARIA, and labels/IDs",
     "topic": "Testing, accessibility, and frontend debugging",
     "topicFolderPath": "React/testing-accessibility-and-frontend-debugging"
   },
   {
+    "canonicalPath": "/content/memoization-and-avoiding-needless-rerenders/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/memoization-and-avoiding-needless-rerenders.md",
     "folders": [
@@ -6190,12 +7122,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why can memo fail when props include objects, arrays, or functions?"
       }
     ],
+    "seoDescription": "Learn Memoization and avoiding needless rerenders for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Memoization and avoiding needless rerenders Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Memoization and avoiding needless rerenders",
     "title": "Memoization and avoiding needless rerenders",
     "topic": "State management, performance, and rendering optimization",
     "topicFolderPath": "React/state-management-performance-and-rendering-optimization"
   },
   {
+    "canonicalPath": "/content/memoization-with-usememo-and-dependency-correctness/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/memoization-with-usememo-and-dependency-correctness.md",
     "folders": [
@@ -6230,12 +7168,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why can object dependencies defeat memoization?"
       }
     ],
+    "seoDescription": "Learn Memoization with useMemo and dependency correctness for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Memoization with useMemo and dependency correctness Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Memoization with useMemo and dependency correctness",
     "title": "Memoization with useMemo and dependency correctness",
     "topic": "Hooks, effects, and custom hooks",
     "topicFolderPath": "React/hooks-effects-and-custom-hooks"
   },
   {
+    "canonicalPath": "/content/modules-and-import-export-behavior/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/modules-and-import-export-behavior.md",
     "folders": [
@@ -6270,12 +7214,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What does it mean that ES module imports are live bindings?"
       }
     ],
+    "seoDescription": "Learn Modules and import/export behavior for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Modules and import/export behavior Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Modules and import/export behavior",
     "title": "Modules and import/export behavior",
     "topic": "JavaScript fundamentals",
     "topicFolderPath": "React/javascript-fundamentals"
   },
   {
+    "canonicalPath": "/content/narrowing-and-control-flow-analysis/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/narrowing-and-control-flow-analysis.md",
     "folders": [
@@ -6310,12 +7260,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do discriminated unions help React UI state?"
       }
     ],
+    "seoDescription": "Learn Narrowing and control-flow analysis for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Narrowing and control-flow analysis Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Narrowing and control-flow analysis",
     "title": "Narrowing and control-flow analysis",
     "topic": "TypeScript for React",
     "topicFolderPath": "React/typescript-for-react"
   },
   {
+    "canonicalPath": "/content/nested-routes-layouts-params-and-route-boundaries/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/nested-routes-layouts-params-and-route-boundaries.md",
     "folders": [
@@ -6350,12 +7306,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do layout routes differ from prefix routes?"
       }
     ],
+    "seoDescription": "Learn Nested routes, layouts, params, and route boundaries for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Nested routes, layouts, params, and route boundaries Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Nested routes, layouts, params, and route boundaries",
     "title": "Nested routes, layouts, params, and route boundaries",
     "topic": "Routing, forms, and server communication",
     "topicFolderPath": "React/routing-forms-and-server-communication"
   },
   {
+    "canonicalPath": "/content/preventing-duplicate-requests-canceling-stale-requests-and-avoiding-race-conditions/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/preventing-duplicate-requests-canceling-stale-requests-and-avoiding-race-conditions.md",
     "folders": [
@@ -6390,12 +7352,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How should a React effect fetch data safely when a prop changes?"
       }
     ],
+    "seoDescription": "Learn Preventing duplicate requests, canceling stale requests, and avoiding race conditions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Preventing duplicate requests, canceling stale requests, and avoiding race conditions Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Preventing duplicate requests, canceling stale requests, and avoiding race conditions",
     "title": "Preventing duplicate requests, canceling stale requests, and avoiding race conditions",
     "topic": "Forms, validation, and frontend performance in production",
     "topicFolderPath": "React/forms-validation-and-frontend-performance-in-production"
   },
   {
+    "canonicalPath": "/content/promises-asynchronous-javascript/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/promises-asynchronous-javascript.md",
     "folders": [
@@ -6430,12 +7398,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the difference between Promise.all and Promise.allSettled?"
       }
     ],
+    "seoDescription": "Learn Promises and asynchronous JavaScript for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Promises and asynchronous JavaScript Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Promises and asynchronous JavaScript",
     "title": "Promises and asynchronous JavaScript",
     "topic": "JavaScript fundamentals",
     "topicFolderPath": "React/javascript-fundamentals"
   },
   {
+    "canonicalPath": "/content/proper-use-effect-usage-and-cleanup/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/proper-use-effect-usage-and-cleanup.md",
     "folders": [
@@ -6470,12 +7444,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why does Strict Mode run effects twice in development?"
       }
     ],
+    "seoDescription": "Learn Proper useEffect usage and cleanup for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Proper useEffect usage and cleanup Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Proper useEffect usage and cleanup",
     "title": "Proper useEffect usage and cleanup",
     "topic": "Hooks, effects, and custom hooks",
     "topicFolderPath": "React/hooks-effects-and-custom-hooks"
   },
   {
+    "canonicalPath": "/content/props-flow-local-state-and-lifting-state-up/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/props-flow-local-state-and-lifting-state-up.md",
     "folders": [
@@ -6510,12 +7490,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you decide whether state should be local or lifted?"
       }
     ],
+    "seoDescription": "Learn Props flow, local state, and lifting state up for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Props flow, local state, and lifting state up Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Props flow, local state, and lifting state up",
     "title": "Props flow, local state, and lifting state up",
     "topic": "Components, props, state, and rendering behavior",
     "topicFolderPath": "React/components-props-state-and-rendering-behavior"
   },
   {
+    "canonicalPath": "/content/query-strategy-and-avoiding-implementation-detail-assertions/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/query-strategy-and-avoiding-implementation-detail-assertions.md",
     "folders": [
@@ -6550,12 +7536,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why is getByRole(\"button\", { name: /save/i }) better than getByText(/save/i) for a button?"
       }
     ],
+    "seoDescription": "Learn Query strategy and avoiding implementation-detail assertions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Query strategy and avoiding implementation-detail assertions Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Query strategy and avoiding implementation-detail assertions",
     "title": "Query strategy and avoiding implementation-detail assertions",
     "topic": "Testing, accessibility, and frontend debugging",
     "topicFolderPath": "React/testing-accessibility-and-frontend-debugging"
   },
   {
+    "canonicalPath": "/content/react-hook-form-fundamentals-uncontrolled-inputs-controller-and-form-state/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/react-hook-form-fundamentals-uncontrolled-inputs-controller-and-form-state.md",
     "folders": [
@@ -6590,12 +7582,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When should you use Controller?"
       }
     ],
+    "seoDescription": "Learn React Hook Form fundamentals, uncontrolled inputs, `Controller`, and form state for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "React Hook Form fundamentals, uncontrolled inputs, `Controller`, and form state Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "React Hook Form fundamentals, uncontrolled inputs, `Controller`, and form state",
     "title": "React Hook Form fundamentals, uncontrolled inputs, `Controller`, and form state",
     "topic": "Forms, validation, and frontend performance in production",
     "topicFolderPath": "React/forms-validation-and-frontend-performance-in-production"
   },
   {
+    "canonicalPath": "/content/reducing-state-complexity-and-avoiding-unnecessary-rerenders-in-form-heavy-pages/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/reducing-state-complexity-and-avoiding-unnecessary-rerenders-in-form-heavy-pages.md",
     "folders": [
@@ -6630,12 +7628,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How should server state and form draft state be separated?"
       }
     ],
+    "seoDescription": "Learn Reducing state complexity and avoiding unnecessary rerenders in form-heavy pages for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Reducing state complexity and avoiding unnecessary rerenders in form-heavy pages Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Reducing state complexity and avoiding unnecessary rerenders in form-heavy pages",
     "title": "Reducing state complexity and avoiding unnecessary rerenders in form-heavy pages",
     "topic": "Forms, validation, and frontend performance in production",
     "topicFolderPath": "React/forms-validation-and-frontend-performance-in-production"
   },
   {
+    "canonicalPath": "/content/rerender-triggers-derived-state-and-avoiding-duplicated-state/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/rerender-triggers-derived-state-and-avoiding-duplicated-state.md",
     "folders": [
@@ -6670,12 +7674,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why should you avoid mirroring props in state?"
       }
     ],
+    "seoDescription": "Learn Rerender triggers, derived state, and avoiding duplicated state for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Rerender triggers, derived state, and avoiding duplicated state Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Rerender triggers, derived state, and avoiding duplicated state",
     "title": "Rerender triggers, derived state, and avoiding duplicated state",
     "topic": "Components, props, state, and rendering behavior",
     "topicFolderPath": "React/components-props-state-and-rendering-behavior"
   },
   {
+    "canonicalPath": "/content/route-loaders-actions-or-equivalent-data-loading-patterns/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/route-loaders-actions-or-equivalent-data-loading-patterns.md",
     "folders": [
@@ -6710,12 +7720,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why are route loaders often better than fetching in useEffect?"
       }
     ],
+    "seoDescription": "Learn Route loaders/actions or equivalent data-loading patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Route loaders/actions or equivalent data-loading patterns Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Route loaders/actions or equivalent data-loading patterns",
     "title": "Route loaders/actions or equivalent data-loading patterns",
     "topic": "Routing, forms, and server communication",
     "topicFolderPath": "React/routing-forms-and-server-communication"
   },
   {
+    "canonicalPath": "/content/rtk-query-custom-base-queries-including-axios-based-basequery-patterns/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/rtk-query-custom-base-queries-including-axios-based-basequery-patterns.md",
     "folders": [
@@ -6750,12 +7766,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When should you write a custom base query instead of using fetchBaseQuery?"
       }
     ],
+    "seoDescription": "Learn RTK Query custom base queries, including Axios-based baseQuery patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "RTK Query custom base queries, including Axios-based baseQuery patterns Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "RTK Query custom base queries, including Axios-based baseQuery patterns",
     "title": "RTK Query custom base queries, including Axios-based baseQuery patterns",
     "topic": "Production data access, API clients, and frontend auth",
     "topicFolderPath": "React/production-data-access-api-clients-and-frontend-auth"
   },
   {
+    "canonicalPath": "/content/secure-cookie-flags-httponly-secure-samesite-path-domain-and-expiration/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/secure-cookie-flags-httponly-secure-samesite-path-domain-and-expiration.md",
     "folders": [
@@ -6790,12 +7812,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why is omitting Domain often safer for auth cookies?"
       }
     ],
+    "seoDescription": "Learn Secure cookie flags: `HttpOnly`, `Secure`, `SameSite`, path, domain, and expiration for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Secure cookie flags: `HttpOnly`, `Secure`, `SameSite`, path, domain, and expiration Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Secure cookie flags: `HttpOnly`, `Secure`, `SameSite`, path, domain, and expiration",
     "title": "Secure cookie flags: `HttpOnly`, `Secure`, `SameSite`, path, domain, and expiration",
     "topic": "Production data access, API clients, and frontend auth",
     "topicFolderPath": "React/production-data-access-api-clients-and-frontend-auth"
   },
   {
+    "canonicalPath": "/content/strict-equality-reference-identity-and-immutability-implications/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/strict-equality-reference-identity-and-immutability-implications.md",
     "folders": [
@@ -6830,12 +7858,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does React decide whether state or Hook dependencies changed?"
       }
     ],
+    "seoDescription": "Learn Strict equality, reference identity, and immutability implications for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Strict equality, reference identity, and immutability implications Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Strict equality, reference identity, and immutability implications",
     "title": "Strict equality, reference identity, and immutability implications",
     "topic": "JavaScript fundamentals",
     "topicFolderPath": "React/javascript-fundamentals"
   },
   {
+    "canonicalPath": "/content/suspense-transitions-and-rendering-priority-concepts/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/suspense-transitions-and-rendering-priority-concepts.md",
     "folders": [
@@ -6870,12 +7904,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How can you prevent already visible content from being replaced by a Suspense fallback during navigation?"
       }
     ],
+    "seoDescription": "Learn Suspense, transitions, and rendering priority concepts for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Suspense, transitions, and rendering priority concepts Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Suspense, transitions, and rendering priority concepts",
     "title": "Suspense, transitions, and rendering priority concepts",
     "topic": "State management, performance, and rendering optimization",
     "topicFolderPath": "React/state-management-performance-and-rendering-optimization"
   },
   {
+    "canonicalPath": "/content/tsconfig-basics-strict-mode-module-settings/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/tsconfig-basics-strict-mode-module-settings.md",
     "folders": [
@@ -6910,12 +7950,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the difference between module and moduleResolution?"
       }
     ],
+    "seoDescription": "Learn tsconfig basics, strict mode, and module settings for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "tsconfig basics, strict mode, and module settings Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "tsconfig basics, strict mode, and module settings",
     "title": "tsconfig basics, strict mode, and module settings",
     "topic": "TypeScript for React",
     "topicFolderPath": "React/typescript-for-react"
   },
   {
+    "canonicalPath": "/content/types-unions-intersections-discriminated-unions/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/types-unions-intersections-discriminated-unions.md",
     "folders": [
@@ -6950,12 +7996,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do discriminated unions prevent invalid UI states?"
       }
     ],
+    "seoDescription": "Learn Types, unions, intersections, and discriminated unions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Types, unions, intersections, and discriminated unions Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Types, unions, intersections, and discriminated unions",
     "title": "Types, unions, intersections, and discriminated unions",
     "topic": "TypeScript for React",
     "topicFolderPath": "React/typescript-for-react"
   },
   {
+    "canonicalPath": "/content/use-state-use-reducer-use-context-and-custom-hooks/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/use-state-use-reducer-use-context-and-custom-hooks.md",
     "folders": [
@@ -6990,12 +8042,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When would you choose useReducer instead of useState?"
       }
     ],
+    "seoDescription": "Learn useState, useReducer, useContext, and custom hooks for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "useState, useReducer, useContext, and custom hooks Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "useState, useReducer, useContext, and custom hooks",
     "title": "useState, useReducer, useContext, and custom hooks",
     "topic": "Hooks, effects, and custom hooks",
     "topicFolderPath": "React/hooks-effects-and-custom-hooks"
   },
   {
+    "canonicalPath": "/content/use-sync-external-store-and-subscribing-to-external-state/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/use-sync-external-store-and-subscribing-to-external-state.md",
     "folders": [
@@ -7030,12 +8088,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why should getSnapshot not return a new object every time?"
       }
     ],
+    "seoDescription": "Learn useSyncExternalStore and subscribing to external state for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "useSyncExternalStore and subscribing to external state Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "useSyncExternalStore and subscribing to external state",
     "title": "useSyncExternalStore and subscribing to external state",
     "topic": "State management, performance, and rendering optimization",
     "topicFolderPath": "React/state-management-performance-and-rendering-optimization"
   },
   {
+    "canonicalPath": "/content/user-centric-testing-with-react-testing-library/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/user-centric-testing-with-react-testing-library.md",
     "folders": [
@@ -7070,12 +8134,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you test a form validation flow with React Testing Library?"
       }
     ],
+    "seoDescription": "Learn User-centric testing with React Testing Library for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "User-centric testing with React Testing Library Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "User-centric testing with React Testing Library",
     "title": "User-centric testing with React Testing Library",
     "topic": "Testing, accessibility, and frontend debugging",
     "topicFolderPath": "React/testing-accessibility-and-frontend-debugging"
   },
   {
+    "canonicalPath": "/content/utility-types-and-conditional-types/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/utility-types-and-conditional-types.md",
     "folders": [
@@ -7110,12 +8180,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What are conditional types?"
       }
     ],
+    "seoDescription": "Learn Utility types and conditional types for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Utility types and conditional types Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Utility types and conditional types",
     "title": "Utility types and conditional types",
     "topic": "TypeScript for React",
     "topicFolderPath": "React/typescript-for-react"
   },
   {
+    "canonicalPath": "/content/watch-vs-usewatch-form-render-isolation-and-large-form-performance/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/watch-vs-usewatch-form-render-isolation-and-large-form-performance.md",
     "folders": [
@@ -7150,12 +8226,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When would you choose watch instead of useWatch?"
       }
     ],
+    "seoDescription": "Learn `watch` vs `useWatch`, form render isolation, and large-form performance for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "`watch` vs `useWatch`, form render isolation, and large-form performance Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "`watch` vs `useWatch`, form render isolation, and large-form performance",
     "title": "`watch` vs `useWatch`, form render isolation, and large-form performance",
     "topic": "Forms, validation, and frontend performance in production",
     "topicFolderPath": "React/forms-validation-and-frontend-performance-in-production"
   },
   {
+    "canonicalPath": "/content/you-might-not-need-an-effect-patterns/",
+    "canonicalPathSource": "generated",
     "category": "React",
     "contentPath": "/src/contents/v1/React/you-might-not-need-an-effect-patterns.md",
     "folders": [
@@ -7190,12 +8272,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you replace an effect that filters a list into state?"
       }
     ],
+    "seoDescription": "Learn “You might not need an effect” patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "“You might not need an effect” patterns Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "“You might not need an effect” patterns",
     "title": "“You might not need an effect” patterns",
     "topic": "Hooks, effects, and custom hooks",
     "topicFolderPath": "React/hooks-effects-and-custom-hooks"
   },
   {
+    "canonicalPath": "/content/acid-basics-and-transaction-scope/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/acid-basics-and-transaction-scope.md",
     "folders": [
@@ -7230,12 +8318,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why are nested transactions in SQL Server not independently committed?"
       }
     ],
+    "seoDescription": "Learn ACID basics and transaction scope for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "ACID basics and transaction scope Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "ACID basics and transaction scope",
     "title": "ACID basics and transaction scope",
     "topic": "Transactions, isolation, locking, and deadlocks",
     "topicFolderPath": "SQL/transactions-isolation-locking-and-deadlocks"
   },
   {
+    "canonicalPath": "/content/backup-types-restore-strategy-and-recovery-objectives/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/backup-types-restore-strategy-and-recovery-objectives.md",
     "folders": [
@@ -7270,12 +8364,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do recovery models affect backup strategy?"
       }
     ],
+    "seoDescription": "Learn Backup types, restore strategy, and recovery objectives for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Backup types, restore strategy, and recovery objectives Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Backup types, restore strategy, and recovery objectives",
     "title": "Backup types, restore strategy, and recovery objectives",
     "topic": "Backup, recovery, HA/DR, security, and temporal data",
     "topicFolderPath": "SQL/backup-recovery-ha-dr-security-and-temporal-data"
   },
   {
+    "canonicalPath": "/content/baselines-workload-comparisons-and-targeted-tuning/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/baselines-workload-comparisons-and-targeted-tuning.md",
     "folders": [
@@ -7310,12 +8410,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you use Query Store to compare performance before and after a deployment?"
       }
     ],
+    "seoDescription": "Learn Baselines, workload comparisons, and targeted tuning for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Baselines, workload comparisons, and targeted tuning Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Baselines, workload comparisons, and targeted tuning",
     "title": "Baselines, workload comparisons, and targeted tuning",
     "topic": "Query tuning, Query Store, and plan stability",
     "topicFolderPath": "SQL/query-tuning-query-store-and-plan-stability"
   },
   {
+    "canonicalPath": "/content/char-vs-varchar-vs-nvarchar-and-unicode-storage-choices/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/char-vs-varchar-vs-nvarchar-and-unicode-storage-choices.md",
     "folders": [
@@ -7350,12 +8456,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Does VARCHAR(50) always mean 50 characters?"
       }
     ],
+    "seoDescription": "Learn CHAR vs VARCHAR vs NVARCHAR and Unicode storage choices for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "CHAR vs VARCHAR vs NVARCHAR and Unicode storage choices Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "CHAR vs VARCHAR vs NVARCHAR and Unicode storage choices",
     "title": "CHAR vs VARCHAR vs NVARCHAR and Unicode storage choices",
     "topic": "SQL practical interview comparisons and SQL Server-specific features",
     "topicFolderPath": "SQL/sql-practical-interview-comparisons-and-sql-server-specific-features"
   },
   {
+    "canonicalPath": "/content/clustered-vs-nonclustered-indexes/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/clustered-vs-nonclustered-indexes.md",
     "folders": [
@@ -7390,12 +8502,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why should clustered index keys usually be narrow and stable?"
       }
     ],
+    "seoDescription": "Learn Clustered vs nonclustered indexes for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Clustered vs nonclustered indexes Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Clustered vs nonclustered indexes",
     "title": "Clustered vs nonclustered indexes",
     "topic": "Indexes, statistics, and execution plans",
     "topicFolderPath": "SQL/indexes-statistics-and-execution-plans"
   },
   {
+    "canonicalPath": "/content/computed-columns-persisted-computed-columns-and-indexed-views/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/computed-columns-persisted-computed-columns-and-indexed-views.md",
     "folders": [
@@ -7430,12 +8548,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What requirements matter when indexing a computed column?"
       }
     ],
+    "seoDescription": "Learn Computed columns, persisted computed columns, and indexed views for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Computed columns, persisted computed columns, and indexed views Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Computed columns, persisted computed columns, and indexed views",
     "title": "Computed columns, persisted computed columns, and indexed views",
     "topic": "SQL practical interview comparisons and SQL Server-specific features",
     "topicFolderPath": "SQL/sql-practical-interview-comparisons-and-sql-server-specific-features"
   },
   {
+    "canonicalPath": "/content/data-types-nullability-and-business-rule-enforcement/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/data-types-nullability-and-business-rule-enforcement.md",
     "folders": [
@@ -7470,12 +8594,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why should money usually use DECIMAL instead of FLOAT?"
       }
     ],
+    "seoDescription": "Learn Data types, nullability, and business-rule enforcement for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Data types, nullability, and business-rule enforcement Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Data types, nullability, and business-rule enforcement",
     "title": "Data types, nullability, and business-rule enforcement",
     "topic": "Relational modeling and normalization",
     "topicFolderPath": "SQL/relational-modeling-and-normalization"
   },
   {
+    "canonicalPath": "/content/ddl-vs-dml-vs-dcl-and-how-schema-data-and-permissions-changes-differ/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/ddl-vs-dml-vs-dcl-and-how-schema-data-and-permissions-changes-differ.md",
     "folders": [
@@ -7510,12 +8640,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why is TRUNCATE TABLE often classified with DDL even though it removes data?"
       }
     ],
+    "seoDescription": "Learn DDL vs DML vs DCL and how schema, data, and permissions changes differ for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "DDL vs DML vs DCL and how schema, data, and permissions changes differ Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "DDL vs DML vs DCL and how schema, data, and permissions changes differ",
     "title": "DDL vs DML vs DCL and how schema, data, and permissions changes differ",
     "topic": "SQL practical interview comparisons and SQL Server-specific features",
     "topicFolderPath": "SQL/sql-practical-interview-comparisons-and-sql-server-specific-features"
   },
   {
+    "canonicalPath": "/content/deadlocks-detection-and-mitigation/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/deadlocks-detection-and-mitigation.md",
     "folders": [
@@ -7550,12 +8686,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does SQL Server choose a deadlock victim?"
       }
     ],
+    "seoDescription": "Learn Deadlocks, detection, and mitigation for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Deadlocks, detection, and mitigation Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Deadlocks, detection, and mitigation",
     "title": "Deadlocks, detection, and mitigation",
     "topic": "Transactions, isolation, locking, and deadlocks",
     "topicFolderPath": "SQL/transactions-isolation-locking-and-deadlocks"
   },
   {
+    "canonicalPath": "/content/delete-vs-truncate-including-logging-identity-reset-rollback-behavior-and-foreign-key-limitations/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/delete-vs-truncate-including-logging-identity-reset-rollback-behavior-and-foreign-key-limitations.md",
     "folders": [
@@ -7590,12 +8732,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why is TRUNCATE TABLE usually faster than DELETE for clearing a table?"
       }
     ],
+    "seoDescription": "Learn DELETE vs TRUNCATE, including logging, identity reset, rollback behavior, and foreign key limitations for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "DELETE vs TRUNCATE, including logging, identity reset, rollback behavior, and foreign key limitations Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "DELETE vs TRUNCATE, including logging, identity reset, rollback behavior, and foreign key limitations",
     "title": "DELETE vs TRUNCATE, including logging, identity reset, rollback behavior, and foreign key limitations",
     "topic": "SQL practical interview comparisons and SQL Server-specific features",
     "topicFolderPath": "SQL/sql-practical-interview-comparisons-and-sql-server-specific-features"
   },
   {
+    "canonicalPath": "/content/estimated-vs-actual-execution-plans/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/estimated-vs-actual-execution-plans.md",
     "folders": [
@@ -7630,12 +8778,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Are scans always bad in an execution plan?"
       }
     ],
+    "seoDescription": "Learn Estimated vs actual execution plans for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Estimated vs actual execution plans Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Estimated vs actual execution plans",
     "title": "Estimated vs actual execution plans",
     "topic": "Indexes, statistics, and execution plans",
     "topicFolderPath": "SQL/indexes-statistics-and-execution-plans"
   },
   {
+    "canonicalPath": "/content/group-by-and-aggregate-functions/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/group-by-and-aggregate-functions.md",
     "folders": [
@@ -7670,12 +8824,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why does SQL require selected columns to be grouped or aggregated?"
       }
     ],
+    "seoDescription": "Learn GROUP BY and aggregate functions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "GROUP BY and aggregate functions Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "GROUP BY and aggregate functions",
     "title": "GROUP BY and aggregate functions",
     "topic": "Core querying and data retrieval",
     "topicFolderPath": "SQL/core-querying-and-data-retrieval"
   },
   {
+    "canonicalPath": "/content/high-availability-and-disaster-recovery-basics/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/high-availability-and-disaster-recovery-basics.md",
     "folders": [
@@ -7710,12 +8870,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the difference between synchronous and asynchronous commit?"
       }
     ],
+    "seoDescription": "Learn High availability and disaster recovery basics for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "High availability and disaster recovery basics Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "High availability and disaster recovery basics",
     "title": "High availability and disaster recovery basics",
     "topic": "Backup, recovery, HA/DR, security, and temporal data",
     "topicFolderPath": "SQL/backup-recovery-ha-dr-security-and-temporal-data"
   },
   {
+    "canonicalPath": "/content/inner-left-other-join-patterns/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/inner-left-other-join-patterns.md",
     "folders": [
@@ -7750,12 +8916,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why can a LEFT JOIN accidentally behave like an INNER JOIN?"
       }
     ],
+    "seoDescription": "Learn INNER, LEFT, and other join patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "INNER, LEFT, and other join patterns Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "INNER, LEFT, and other join patterns",
     "title": "INNER, LEFT, and other join patterns",
     "topic": "Relational modeling and normalization",
     "topicFolderPath": "SQL/relational-modeling-and-normalization"
   },
   {
+    "canonicalPath": "/content/isolation-levels-and-row-versioning/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/isolation-levels-and-row-versioning.md",
     "folders": [
@@ -7790,12 +8962,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does READ COMMITTED differ with READCOMMITTEDSNAPSHOT ON?"
       }
     ],
+    "seoDescription": "Learn Isolation levels and row versioning for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Isolation levels and row versioning Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Isolation levels and row versioning",
     "title": "Isolation levels and row versioning",
     "topic": "Transactions, isolation, locking, and deadlocks",
     "topicFolderPath": "SQL/transactions-isolation-locking-and-deadlocks"
   },
   {
+    "canonicalPath": "/content/knowing-when-to-change-sql-indexes-or-schema-instead-of-forcing-hints/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/knowing-when-to-change-sql-indexes-or-schema-instead-of-forcing-hints.md",
     "folders": [
@@ -7830,12 +9008,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you decide whether a slow query needs SQL rewrite, index change, statistics update, or a hint?"
       }
     ],
+    "seoDescription": "Learn Knowing when to change SQL, indexes, or schema instead of forcing hints for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Knowing when to change SQL, indexes, or schema instead of forcing hints Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Knowing when to change SQL, indexes, or schema instead of forcing hints",
     "title": "Knowing when to change SQL, indexes, or schema instead of forcing hints",
     "topic": "Query tuning, Query Store, and plan stability",
     "topicFolderPath": "SQL/query-tuning-query-store-and-plan-stability"
   },
   {
+    "canonicalPath": "/content/least-privilege-roles-row-level-security-and-masking/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/least-privilege-roles-row-level-security-and-masking.md",
     "folders": [
@@ -7870,12 +9054,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why should applications avoid using dbowner?"
       }
     ],
+    "seoDescription": "Learn Least privilege, roles, row-level security, and masking for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Least privilege, roles, row-level security, and masking Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Least privilege, roles, row-level security, and masking",
     "title": "Least privilege, roles, row-level security, and masking",
     "topic": "Backup, recovery, HA/DR, security, and temporal data",
     "topicFolderPath": "SQL/backup-recovery-ha-dr-security-and-temporal-data"
   },
   {
+    "canonicalPath": "/content/local-vs-global-temporary-tables-and-table-variables/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/local-vs-global-temporary-tables-and-table-variables.md",
     "folders": [
@@ -7910,12 +9100,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do temp tables and table variables differ for query optimization?"
       }
     ],
+    "seoDescription": "Learn Local vs global temporary tables and table variables for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Local vs global temporary tables and table variables Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Local vs global temporary tables and table variables",
     "title": "Local vs global temporary tables and table variables",
     "topic": "SQL practical interview comparisons and SQL Server-specific features",
     "topicFolderPath": "SQL/sql-practical-interview-comparisons-and-sql-server-specific-features"
   },
   {
+    "canonicalPath": "/content/locking-behavior-and-blocking/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/locking-behavior-and-blocking.md",
     "folders": [
@@ -7950,12 +9146,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you find the head blocker?"
       }
     ],
+    "seoDescription": "Learn Locking behavior and blocking for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Locking behavior and blocking Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Locking behavior and blocking",
     "title": "Locking behavior and blocking",
     "topic": "Transactions, isolation, locking, and deadlocks",
     "topicFolderPath": "SQL/transactions-isolation-locking-and-deadlocks"
   },
   {
+    "canonicalPath": "/content/merge-and-upsert-patterns-including-concurrency-cautions/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/merge-and-upsert-patterns-including-concurrency-cautions.md",
     "folders": [
@@ -7990,12 +9192,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why can MERGE be risky with duplicate source rows?"
       }
     ],
+    "seoDescription": "Learn MERGE and upsert patterns, including concurrency cautions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "MERGE and upsert patterns, including concurrency cautions Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "MERGE and upsert patterns, including concurrency cautions",
     "title": "MERGE and upsert patterns, including concurrency cautions",
     "topic": "SQL practical interview comparisons and SQL Server-specific features",
     "topicFolderPath": "SQL/sql-practical-interview-comparisons-and-sql-server-specific-features"
   },
   {
+    "canonicalPath": "/content/normalization-and-when-denormalization-is-justified/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/normalization-and-when-denormalization-is-justified.md",
     "folders": [
@@ -8030,12 +9238,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do second and third normal form differ?"
       }
     ],
+    "seoDescription": "Learn Normalization and when denormalization is justified for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Normalization and when denormalization is justified Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Normalization and when denormalization is justified",
     "title": "Normalization and when denormalization is justified",
     "topic": "Relational modeling and normalization",
     "topicFolderPath": "SQL/relational-modeling-and-normalization"
   },
   {
+    "canonicalPath": "/content/null-handling-and-common-filtering-mistakes/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/null-handling-and-common-filtering-mistakes.md",
     "folders": [
@@ -8070,12 +9284,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why can NOT IN return no rows when the subquery contains NULL?"
       }
     ],
+    "seoDescription": "Learn NULL handling and common filtering mistakes for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "NULL handling and common filtering mistakes Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "NULL handling and common filtering mistakes",
     "title": "NULL handling and common filtering mistakes",
     "topic": "Core querying and data retrieval",
     "topicFolderPath": "SQL/core-querying-and-data-retrieval"
   },
   {
+    "canonicalPath": "/content/one-to-one-one-to-many-many-to-many-relationships/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/one-to-one-one-to-many-many-to-many-relationships.md",
     "folders": [
@@ -8110,12 +9330,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you implement a 1-to-1 relationship in SQL?"
       }
     ],
+    "seoDescription": "Learn One-to-one, one-to-many, and many-to-many relationships for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "One-to-one, one-to-many, and many-to-many relationships Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "One-to-one, one-to-many, and many-to-many relationships",
     "title": "One-to-one, one-to-many, and many-to-many relationships",
     "topic": "Core querying and data retrieval",
     "topicFolderPath": "SQL/core-querying-and-data-retrieval"
   },
   {
+    "canonicalPath": "/content/over-partition-by-row-number-rank-and-running-aggregates/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/over-partition-by-row-number-rank-and-running-aggregates.md",
     "folders": [
@@ -8150,12 +9376,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do you calculate a running total in SQL Server?"
       }
     ],
+    "seoDescription": "Learn OVER, PARTITION BY, ROW_NUMBER, RANK, and running aggregates for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "OVER, PARTITION BY, ROW_NUMBER, RANK, and running aggregates Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "OVER, PARTITION BY, ROW_NUMBER, RANK, and running aggregates",
     "title": "OVER, PARTITION BY, ROW_NUMBER, RANK, and running aggregates",
     "topic": "Advanced querying with window functions and CTEs",
     "topicFolderPath": "SQL/advanced-querying-with-window-functions-and-ctes"
   },
   {
+    "canonicalPath": "/content/parameter-sensitive-plans-and-skewed-data-distributions/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/parameter-sensitive-plans-and-skewed-data-distributions.md",
     "folders": [
@@ -8190,12 +9422,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does parameter sniffing interact with plan reuse?"
       }
     ],
+    "seoDescription": "Learn Parameter-sensitive plans and skewed data distributions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Parameter-sensitive plans and skewed data distributions Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Parameter-sensitive plans and skewed data distributions",
     "title": "Parameter-sensitive plans and skewed data distributions",
     "topic": "Query tuning, Query Store, and plan stability",
     "topicFolderPath": "SQL/query-tuning-query-store-and-plan-stability"
   },
   {
+    "canonicalPath": "/content/primary-key-vs-unique-constraint-candidate-keys-foreign-keys-and-constraint-design/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/primary-key-vs-unique-constraint-candidate-keys-foreign-keys-and-constraint-design.md",
     "folders": [
@@ -8230,12 +9468,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why use a surrogate primary key plus a unique business key?"
       }
     ],
+    "seoDescription": "Learn Primary key vs unique constraint, candidate keys, foreign keys, and constraint design for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Primary key vs unique constraint, candidate keys, foreign keys, and constraint design Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Primary key vs unique constraint, candidate keys, foreign keys, and constraint design",
     "title": "Primary key vs unique constraint, candidate keys, foreign keys, and constraint design",
     "topic": "SQL practical interview comparisons and SQL Server-specific features",
     "topicFolderPath": "SQL/sql-practical-interview-comparisons-and-sql-server-specific-features"
   },
   {
+    "canonicalPath": "/content/primary-keys-foreign-keys-constraints/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/primary-keys-foreign-keys-constraints.md",
     "folders": [
@@ -8270,12 +9514,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Does a foreign key automatically create an index?"
       }
     ],
+    "seoDescription": "Learn Primary keys, foreign keys, and constraints for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Primary keys, foreign keys, and constraints Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Primary keys, foreign keys, and constraints",
     "title": "Primary keys, foreign keys, and constraints",
     "topic": "Core querying and data retrieval",
     "topicFolderPath": "SQL/core-querying-and-data-retrieval"
   },
   {
+    "canonicalPath": "/content/query-store-for-regression-detection-and-plan-history/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/query-store-for-regression-detection-and-plan-history.md",
     "folders": [
@@ -8310,12 +9560,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How would you use Query Store to find a regressed query?"
       }
     ],
+    "seoDescription": "Learn Query Store for regression detection and plan history for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Query Store for regression detection and plan history Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Query Store for regression detection and plan history",
     "title": "Query Store for regression detection and plan history",
     "topic": "Query tuning, Query Store, and plan stability",
     "topicFolderPath": "SQL/query-tuning-query-store-and-plan-stability"
   },
   {
+    "canonicalPath": "/content/replacing-brittle-subqueries-with-clearer-query-structure/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/replacing-brittle-subqueries-with-clearer-query-structure.md",
     "folders": [
@@ -8350,12 +9606,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why can NOT IN be dangerous with subqueries?"
       }
     ],
+    "seoDescription": "Learn Replacing brittle subqueries with clearer query structure for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Replacing brittle subqueries with clearer query structure Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Replacing brittle subqueries with clearer query structure",
     "title": "Replacing brittle subqueries with clearer query structure",
     "topic": "Advanced querying with window functions and CTEs",
     "topicFolderPath": "SQL/advanced-querying-with-window-functions-and-ctes"
   },
   {
+    "canonicalPath": "/content/schema-migrations-source-control-reviewable-sql-scripts-and-release-safety/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/schema-migrations-source-control-reviewable-sql-scripts-and-release-safety.md",
     "folders": [
@@ -8390,12 +9652,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is the difference between migration-based and state-based database deployment?"
       }
     ],
+    "seoDescription": "Learn Schema migrations, source control, reviewable SQL scripts, and release safety for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Schema migrations, source control, reviewable SQL scripts, and release safety Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Schema migrations, source control, reviewable SQL scripts, and release safety",
     "title": "Schema migrations, source control, reviewable SQL scripts, and release safety",
     "topic": "Database programmability and schema evolution",
     "topicFolderPath": "SQL/database-programmability-and-schema-evolution"
   },
   {
+    "canonicalPath": "/content/select-where-order-by-top-offset-fetch/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/select-where-order-by-top-offset-fetch.md",
     "folders": [
@@ -8430,12 +9698,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why should TOP usually be used with ORDER BY?"
       }
     ],
+    "seoDescription": "Learn SELECT, WHERE, ORDER BY, TOP/OFFSET-FETCH for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "SELECT, WHERE, ORDER BY, TOP/OFFSET-FETCH Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "SELECT, WHERE, ORDER BY, TOP/OFFSET-FETCH",
     "title": "SELECT, WHERE, ORDER BY, TOP/OFFSET-FETCH",
     "topic": "Relational modeling and normalization",
     "topicFolderPath": "SQL/relational-modeling-and-normalization"
   },
   {
+    "canonicalPath": "/content/selectivity-covering-indexes-and-index-maintenance-trade-offs/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/selectivity-covering-indexes-and-index-maintenance-trade-offs.md",
     "folders": [
@@ -8470,12 +9744,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do key columns differ from included columns?"
       }
     ],
+    "seoDescription": "Learn Selectivity, covering indexes, and index maintenance trade-offs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Selectivity, covering indexes, and index maintenance trade-offs Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Selectivity, covering indexes, and index maintenance trade-offs",
     "title": "Selectivity, covering indexes, and index maintenance trade-offs",
     "topic": "Indexes, statistics, and execution plans",
     "topicFolderPath": "SQL/indexes-statistics-and-execution-plans"
   },
   {
+    "canonicalPath": "/content/standard-and-recursive-ctes/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/standard-and-recursive-ctes.md",
     "folders": [
@@ -8510,12 +9790,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Are CTEs materialized in SQL Server?"
       }
     ],
+    "seoDescription": "Learn Standard and recursive CTEs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Standard and recursive CTEs Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Standard and recursive CTEs",
     "title": "Standard and recursive CTEs",
     "topic": "Advanced querying with window functions and CTEs",
     "topicFolderPath": "SQL/advanced-querying-with-window-functions-and-ctes"
   },
   {
+    "canonicalPath": "/content/statistics-and-how-the-optimizer-uses-them/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/statistics-and-how-the-optimizer-uses-them.md",
     "folders": [
@@ -8550,12 +9836,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How does the optimizer use statistics to choose a plan?"
       }
     ],
+    "seoDescription": "Learn Statistics and how the optimizer uses them for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Statistics and how the optimizer uses them Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Statistics and how the optimizer uses them",
     "title": "Statistics and how the optimizer uses them",
     "topic": "Indexes, statistics, and execution plans",
     "topicFolderPath": "SQL/indexes-statistics-and-execution-plans"
   },
   {
+    "canonicalPath": "/content/stored-procedure-transaction-patterns-with-try-catch-output-parameters-and-error-handling/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/stored-procedure-transaction-patterns-with-try-catch-output-parameters-and-error-handling.md",
     "folders": [
@@ -8590,12 +9882,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is XACTSTATE used for?"
       }
     ],
+    "seoDescription": "Learn Stored procedure transaction patterns with `TRY...CATCH`, output parameters, and error handling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Stored procedure transaction patterns with `TRY...CATCH`, output parameters, and error handling Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Stored procedure transaction patterns with `TRY...CATCH`, output parameters, and error handling",
     "title": "Stored procedure transaction patterns with `TRY...CATCH`, output parameters, and error handling",
     "topic": "SQL practical interview comparisons and SQL Server-specific features",
     "topicFolderPath": "SQL/sql-practical-interview-comparisons-and-sql-server-specific-features"
   },
   {
+    "canonicalPath": "/content/stored-procedures-output-parameters-and-encapsulated-database-logic/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/stored-procedures-output-parameters-and-encapsulated-database-logic.md",
     "folders": [
@@ -8630,12 +9928,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What are the benefits and drawbacks of encapsulating logic in stored procedures?"
       }
     ],
+    "seoDescription": "Learn Stored procedures, output parameters, and encapsulated database logic for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Stored procedures, output parameters, and encapsulated database logic Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Stored procedures, output parameters, and encapsulated database logic",
     "title": "Stored procedures, output parameters, and encapsulated database logic",
     "topic": "Database programmability and schema evolution",
     "topicFolderPath": "SQL/database-programmability-and-schema-evolution"
   },
   {
+    "canonicalPath": "/content/temporal-or-reporting-style-query-patterns/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/temporal-or-reporting-style-query-patterns.md",
     "folders": [
@@ -8670,12 +9974,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do system-versioned temporal tables differ from event tables?"
       }
     ],
+    "seoDescription": "Learn Temporal or reporting-style query patterns for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Temporal or reporting-style query patterns Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Temporal or reporting-style query patterns",
     "title": "Temporal or reporting-style query patterns",
     "topic": "Advanced querying with window functions and CTEs",
     "topicFolderPath": "SQL/advanced-querying-with-window-functions-and-ctes"
   },
   {
+    "canonicalPath": "/content/temporal-tables-historical-retention-and-lifecycle-management/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/temporal-tables-historical-retention-and-lifecycle-management.md",
     "folders": [
@@ -8710,12 +10020,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "How do temporal tables differ from audit tables?"
       }
     ],
+    "seoDescription": "Learn Temporal tables, historical retention, and lifecycle management for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Temporal tables, historical retention, and lifecycle management Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Temporal tables, historical retention, and lifecycle management",
     "title": "Temporal tables, historical retention, and lifecycle management",
     "topic": "Backup, recovery, HA/DR, security, and temporal data",
     "topicFolderPath": "SQL/backup-recovery-ha-dr-security-and-temporal-data"
   },
   {
+    "canonicalPath": "/content/triggers-and-their-trade-offs/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/triggers-and-their-trade-offs.md",
     "folders": [
@@ -8750,12 +10066,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "When should you use a trigger instead of a constraint?"
       }
     ],
+    "seoDescription": "Learn Triggers and their trade-offs for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Triggers and their trade-offs Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Triggers and their trade-offs",
     "title": "Triggers and their trade-offs",
     "topic": "Database programmability and schema evolution",
     "topicFolderPath": "SQL/database-programmability-and-schema-evolution"
   },
   {
+    "canonicalPath": "/content/union-vs-union-all-except-intersect-and-duplicate-handling/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/union-vs-union-all-except-intersect-and-duplicate-handling.md",
     "folders": [
@@ -8790,12 +10112,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why can UNION produce incorrect reports for transaction data?"
       }
     ],
+    "seoDescription": "Learn UNION vs UNION ALL, EXCEPT, INTERSECT, and duplicate handling for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "UNION vs UNION ALL, EXCEPT, INTERSECT, and duplicate handling Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "UNION vs UNION ALL, EXCEPT, INTERSECT, and duplicate handling",
     "title": "UNION vs UNION ALL, EXCEPT, INTERSECT, and duplicate handling",
     "topic": "SQL practical interview comparisons and SQL Server-specific features",
     "topicFolderPath": "SQL/sql-practical-interview-comparisons-and-sql-server-specific-features"
   },
   {
+    "canonicalPath": "/content/views-and-user-defined-functions/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/views-and-user-defined-functions.md",
     "folders": [
@@ -8830,12 +10158,18 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "What is SCHEMABINDING and why would you use it?"
       }
     ],
+    "seoDescription": "Learn Views and user-defined functions for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "Views and user-defined functions Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "Views and user-defined functions",
     "title": "Views and user-defined functions",
     "topic": "Database programmability and schema evolution",
     "topicFolderPath": "SQL/database-programmability-and-schema-evolution"
   },
   {
+    "canonicalPath": "/content/where-vs-having-and-filtering-before-vs-after-aggregation/",
+    "canonicalPathSource": "generated",
     "category": "SQL",
     "contentPath": "/src/contents/v1/SQL/where-vs-having-and-filtering-before-vs-after-aggregation.md",
     "folders": [
@@ -8870,6 +10204,10 @@ export const curriculumManifest: CurriculumManifestEntry[] = [
         "question": "Why is using HAVING Status = 'Completed' usually worse than using WHERE Status = 'Completed'?"
       }
     ],
+    "seoDescription": "Learn WHERE vs HAVING and filtering before vs after aggregation for technical interviews, including core concepts, practical examples, common mistakes, and interview questions.",
+    "seoDescriptionSource": "fallback",
+    "seoTitle": "WHERE vs HAVING and filtering before vs after aggregation Interview Questions | DEV_NET_CORE",
+    "seoTitleSource": "fallback",
     "subtopic": "WHERE vs HAVING and filtering before vs after aggregation",
     "title": "WHERE vs HAVING and filtering before vs after aggregation",
     "topic": "SQL practical interview comparisons and SQL Server-specific features",
diff --git a/src/contents/v1/NET/async-and-await-semantics-in-csharp.md b/src/contents/v1/NET/async-and-await-semantics-in-csharp.md
index 03b0322..2a61756 100644
--- a/src/contents/v1/NET/async-and-await-semantics-in-csharp.md
+++ b/src/contents/v1/NET/async-and-await-semantics-in-csharp.md
@@ -3,6 +3,9 @@ id: async-and-await-semantics-in-csharp
 topic: Async programming, tasks, cancellation, and concurrency
 subtopic: Async and Await Semantics 
 category: .NET
+seoTitle: Async and Await in C# Interview Questions
+seoDescription: Learn async and await in C# for technical interviews, including Task, cancellation, exception handling, and common deadlock risks.
+canonicalPath: /content/async-and-await-semantics-in-csharp/
 ---
 
 ## Overview
diff --git a/src/index.css b/src/index.css
index c799e6b..7131c85 100644
--- a/src/index.css
+++ b/src/index.css
@@ -13,6 +13,82 @@
   -moz-osx-font-smoothing: grayscale;
 }
 
+html[data-theme="dark"] {
+  color-scheme: dark;
+  --color-background: #111318;
+  --color-on-background: #e2e2e8;
+  --color-surface: #111318;
+  --color-surface-container-lowest: #0c0e12;
+  --color-surface-container-low: #1a1c20;
+  --color-surface-container: #1e2024;
+  --color-surface-container-high: #282a2e;
+  --color-on-surface: #e2e2e8;
+  --color-on-surface-variant: #b9cacb;
+  --color-outline: #849495;
+  --color-outline-variant: #3b494b;
+  --color-primary: #dbfcff;
+  --color-on-primary: #00363a;
+  --color-primary-container: #00f0ff;
+  --color-on-primary-container: #006970;
+  --color-secondary: #d8b9ff;
+  --color-tertiary: #d1fff5;
+  --color-error: #ffb4ab;
+  --color-glass: rgba(18, 23, 33, 0.8);
+  --color-card-border: rgba(255, 255, 255, 0.1);
+  --color-accent-border: rgba(0, 240, 255, 0.2);
+  --color-accent-soft: rgba(0, 240, 255, 0.1);
+  --color-accent-hover: rgba(0, 240, 255, 0.08);
+  --color-card-hover-border: rgba(0, 240, 255, 0.45);
+  --color-chip-background: rgba(255, 255, 255, 0.05);
+  --color-chip-text: #94a3b8;
+  --color-code-surface: #0c0e12;
+  --color-feature-band: rgba(26, 28, 32, 0.5);
+  --color-grid-line: rgba(0, 240, 255, 0.05);
+  --color-subtle-text: #64748b;
+  --color-warning: rgba(234, 179, 8, 0.5);
+  --shadow-accent-glow: 0 0 20px rgba(0, 240, 255, 0.3);
+  --shadow-card-hover: 0 0 15px rgba(0, 240, 255, 0.1);
+  --shadow-panel-glow: 0 0 20px rgba(0, 240, 255, 0.3);
+}
+
+html[data-theme="light"] {
+  color-scheme: light;
+  --color-background: #f9f9ff;
+  --color-on-background: #1a1c20;
+  --color-surface: #f9f9ff;
+  --color-surface-container-lowest: #ffffff;
+  --color-surface-container-low: #f3f3f9;
+  --color-surface-container: #ededf3;
+  --color-surface-container-high: #e8e8ee;
+  --color-on-surface: #1a1c20;
+  --color-on-surface-variant: #3b494b;
+  --color-outline: #6a7a7b;
+  --color-outline-variant: #b9cacb;
+  --color-primary: #006970;
+  --color-on-primary: #ffffff;
+  --color-primary-container: #ff0000;
+  --color-on-primary-container: #006970;
+  --color-secondary: #7b24dc;
+  --color-tertiary: #006b5f;
+  --color-error: #ba1a1a;
+  --color-glass: rgba(255, 255, 255, 0.72);
+  --color-card-border: rgba(106, 122, 123, 0.24);
+  --color-accent-border: rgba(0, 240, 255, 0.3);
+  --color-accent-soft: rgba(0, 240, 255, 0.15);
+  --color-accent-hover: rgba(0, 240, 255, 0.14);
+  --color-card-hover-border: rgba(0, 105, 112, 0.4);
+  --color-chip-background: rgba(0, 105, 112, 0.08);
+  --color-chip-text: #3b494b;
+  --color-code-surface: #ffffff;
+  --color-feature-band: rgba(243, 243, 249, 0.75);
+  --color-grid-line: rgba(0, 105, 112, 0.06);
+  --color-subtle-text: #6a7a7b;
+  --color-warning: rgba(202, 138, 4, 0.55);
+  --shadow-accent-glow: 0 0 20px rgba(0, 240, 255, 0.18);
+  --shadow-card-hover: 0 0 18px rgba(0, 240, 255, 0.14);
+  --shadow-panel-glow: 0 0 20px rgba(0, 240, 255, 0.16);
+}
+
 html {
   background: var(--color-background, #111318);
 }
diff --git a/src/lib/redux/createAppStore.ts b/src/lib/redux/createAppStore.ts
new file mode 100644
index 0000000..eee862d
--- /dev/null
+++ b/src/lib/redux/createAppStore.ts
@@ -0,0 +1,27 @@
+import { combineReducers, configureStore } from "@reduxjs/toolkit";
+import { dumnmyApi } from "./api/dummyApi";
+import { contentReducer } from "./slices/contentSlice";
+import { dummyReducer } from "./slices/dummySilce";
+import { simulationReducer } from "./slices/simulationSlice";
+
+const rootReducer = combineReducers({
+  content: contentReducer,
+  dumnmy: dummyReducer,
+  simulation: simulationReducer,
+  [dumnmyApi.reducerPath]: dumnmyApi.reducer,
+});
+
+export type RootState = ReturnType<typeof rootReducer>;
+export type AppPreloadedState = Partial<RootState>;
+
+export function createAppStore(preloadedState?: AppPreloadedState) {
+  return configureStore({
+    middleware: (getDefaultMiddleware) =>
+      getDefaultMiddleware().concat(dumnmyApi.middleware),
+    preloadedState,
+    reducer: rootReducer,
+  });
+}
+
+export type AppStore = ReturnType<typeof createAppStore>;
+export type AppDispatch = AppStore["dispatch"];
diff --git a/src/lib/redux/hooks/hooks.ts b/src/lib/redux/hooks/hooks.ts
index 248ffdb..e7dccb0 100644
--- a/src/lib/redux/hooks/hooks.ts
+++ b/src/lib/redux/hooks/hooks.ts
@@ -1,5 +1,5 @@
 import { type TypedUseSelectorHook, useDispatch, useSelector } from 'react-redux';
-import type { RootState, AppDispatch } from '../store';
+import type { AppDispatch, RootState } from '../createAppStore';
 
 export const useAppDispatch = () => useDispatch<AppDispatch>();
 export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector;
diff --git a/src/lib/redux/persistence.ts b/src/lib/redux/persistence.ts
new file mode 100644
index 0000000..e6be0ca
--- /dev/null
+++ b/src/lib/redux/persistence.ts
@@ -0,0 +1,71 @@
+import type { AppPreloadedState, AppStore } from "./createAppStore";
+import {
+  createInitialContentState,
+  loadContentProgressFromLocalStorage,
+  saveContentProgressToLocalStorage,
+  setContentProgress,
+} from "./slices/contentSlice";
+import {
+  clearSimulationSessionState,
+  createInitialSimulationState,
+  loadSimulationSession,
+  loadSimulationSessionState,
+  saveSimulationSessionState,
+} from "./slices/simulationSlice";
+
+export function loadBrowserPreloadedState(): AppPreloadedState | undefined {
+  if (typeof window === "undefined") {
+    return undefined;
+  }
+
+  return {
+    content: createInitialContentState(loadContentProgressFromLocalStorage()),
+    simulation: createInitialSimulationState(loadSimulationSessionState()),
+  };
+}
+
+export function startBrowserStorePersistence(store: AppStore) {
+  if (typeof window === "undefined") {
+    return () => undefined;
+  }
+
+  let previousContentProgress = store.getState().content.progress;
+  let previousSimulationSession =
+    store.getState().simulation.currentSession;
+
+  return store.subscribe(() => {
+    const nextContentProgress = store.getState().content.progress;
+    const nextSimulationSession = store.getState().simulation.currentSession;
+
+    if (nextContentProgress !== previousContentProgress) {
+      previousContentProgress = nextContentProgress;
+      saveContentProgressToLocalStorage(nextContentProgress);
+    }
+
+    if (nextSimulationSession !== previousSimulationSession) {
+      previousSimulationSession = nextSimulationSession;
+
+      if (nextSimulationSession) {
+        saveSimulationSessionState(nextSimulationSession);
+      } else {
+        clearSimulationSessionState();
+      }
+    }
+  });
+}
+
+export function hydrateBrowserStoreFromPersistence(store: AppStore) {
+  if (typeof window === "undefined") {
+    return () => undefined;
+  }
+
+  store.dispatch(setContentProgress(loadContentProgressFromLocalStorage()));
+
+  const savedSession = loadSimulationSessionState();
+
+  if (savedSession) {
+    store.dispatch(loadSimulationSession(savedSession));
+  }
+
+  return startBrowserStorePersistence(store);
+}
diff --git a/src/lib/redux/selectors/contentSelectors.ts b/src/lib/redux/selectors/contentSelectors.ts
index 30f9c3f..ca944c4 100644
--- a/src/lib/redux/selectors/contentSelectors.ts
+++ b/src/lib/redux/selectors/contentSelectors.ts
@@ -1,4 +1,4 @@
-import type { RootState } from "../store";
+import type { RootState } from "../createAppStore";
 
 export const selectSelectedContentTopicId = (state: RootState) =>
   state.content.selectedTopicId;
diff --git a/src/lib/redux/selectors/dummySelector.ts b/src/lib/redux/selectors/dummySelector.ts
index ba153be..8d6b9e0 100644
--- a/src/lib/redux/selectors/dummySelector.ts
+++ b/src/lib/redux/selectors/dummySelector.ts
@@ -1,3 +1,3 @@
-import type { RootState } from '../store';
+import type { RootState } from '../createAppStore';
 
-export const selectDummyItems = (state: RootState) => state.dumnmy.items
\ No newline at end of file
+export const selectDummyItems = (state: RootState) => state.dumnmy.items
diff --git a/src/lib/redux/selectors/simulationSelectors.ts b/src/lib/redux/selectors/simulationSelectors.ts
index 0802472..c903ffb 100644
--- a/src/lib/redux/selectors/simulationSelectors.ts
+++ b/src/lib/redux/selectors/simulationSelectors.ts
@@ -1,4 +1,4 @@
-import type { RootState } from "../store";
+import type { RootState } from "../createAppStore";
 
 export const selectSimulationState = (state: RootState) => state.simulation;
 
diff --git a/src/lib/redux/slices/contentSlice.ts b/src/lib/redux/slices/contentSlice.ts
index 7328caf..bb0ad3d 100644
--- a/src/lib/redux/slices/contentSlice.ts
+++ b/src/lib/redux/slices/contentSlice.ts
@@ -34,7 +34,7 @@ type SetQuestionCompletionPayload = {
 
 export const CONTENT_PROGRESS_STORAGE_KEY = "dev-net-core:content-progress";
 
-const initialState: ContentState = createInitialState();
+const initialState: ContentState = createInitialContentState();
 
 const contentSlice = createSlice({
   name: "content",
@@ -97,7 +97,7 @@ const contentSlice = createSlice({
         completedQuestion,
       });
     },
-    resetContentState: () => createInitialState(),
+    resetContentState: () => createInitialContentState(),
   },
 });
 
@@ -111,10 +111,12 @@ export const {
 
 export const contentReducer = contentSlice.reducer;
 
-function createInitialState(): ContentState {
+export function createInitialContentState(
+  progress: ContentProgressState = {}
+): ContentState {
   return {
     selectedTopicId: undefined,
-    progress: loadContentProgressFromLocalStorage(),
+    progress,
   };
 }
 
diff --git a/src/lib/redux/slices/simulationSlice.ts b/src/lib/redux/slices/simulationSlice.ts
index aaa6c96..2bcd90b 100644
--- a/src/lib/redux/slices/simulationSlice.ts
+++ b/src/lib/redux/slices/simulationSlice.ts
@@ -520,9 +520,9 @@ function applySessionToState(
   state.simulationStep = session.step;
 }
 
-function createInitialSimulationState(): SimulationState {
-  const savedSession = loadSimulationSessionState();
-
+export function createInitialSimulationState(
+  savedSession?: SimulationSessionState
+): SimulationState {
   if (savedSession) {
     return {
       currentSession: savedSession,
diff --git a/src/lib/redux/store.ts b/src/lib/redux/store.ts
index 2197cf7..bbed25e 100644
--- a/src/lib/redux/store.ts
+++ b/src/lib/redux/store.ts
@@ -1,49 +1,9 @@
-import { configureStore } from '@reduxjs/toolkit';
-import { dumnmyApi } from './api/dummyApi';
-import {dummyReducer } from './slices/dummySilce'
+import { createAppStore } from "./createAppStore";
 import {
-  contentReducer,
-  saveContentProgressToLocalStorage,
-} from './slices/contentSlice';
-import {
-  clearSimulationSessionState,
-  saveSimulationSessionState,
-  simulationReducer,
-} from './slices/simulationSlice';
-
-export const store = configureStore({
-  reducer: {
-    content: contentReducer,
-    dumnmy: dummyReducer,
-    simulation: simulationReducer,
-    [dumnmyApi.reducerPath]: dumnmyApi.reducer,
-  },
-  middleware: (getDefaultMiddleware) =>
-    getDefaultMiddleware().concat(dumnmyApi.middleware),
-});
-
-let previousContentProgress = store.getState().content.progress;
-let previousSimulationSession = store.getState().simulation.currentSession;
-
-store.subscribe(() => {
-  const nextContentProgress = store.getState().content.progress;
-  const nextSimulationSession = store.getState().simulation.currentSession;
-
-  if (nextContentProgress !== previousContentProgress) {
-    previousContentProgress = nextContentProgress;
-    saveContentProgressToLocalStorage(nextContentProgress);
-  }
-
-  if (nextSimulationSession !== previousSimulationSession) {
-    previousSimulationSession = nextSimulationSession;
+  loadBrowserPreloadedState,
+  startBrowserStorePersistence,
+} from "./persistence";
 
-    if (nextSimulationSession) {
-      saveSimulationSessionState(nextSimulationSession);
-    } else {
-      clearSimulationSessionState();
-    }
-  }
-});
+export const browserStore = createAppStore(loadBrowserPreloadedState());
 
-export type RootState = ReturnType<typeof store.getState>;
-export type AppDispatch = typeof store.dispatch;
+startBrowserStorePersistence(browserStore);
diff --git a/src/main.tsx b/src/main.tsx
index 5ff77d7..171cdae 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -2,10 +2,9 @@ import { StrictMode } from "react";
 import { createRoot } from "react-dom/client";
 import "./index.css";
 import App from "./App.tsx";
+import { AppProviders } from "./AppProviders.tsx";
 import { BrowserRouter } from "react-router-dom";
-import { Provider } from "react-redux";
-import { store } from "./lib/redux/store.ts";
-import { AppThemeModeProvider } from "./theme/ThemeModeProvider.tsx";
+import { browserStore } from "./lib/redux/store.ts";
 
 const routerBasename =
   import.meta.env.BASE_URL === "/"
@@ -14,12 +13,10 @@ const routerBasename =
 
 createRoot(document.getElementById("root")!).render(
   <StrictMode>
-    <Provider store={store}>
+    <AppProviders store={browserStore}>
       <BrowserRouter basename={routerBasename}>
-        <AppThemeModeProvider>
-          <App />
-        </AppThemeModeProvider>
+        <App />
       </BrowserRouter>
-    </Provider>
+    </AppProviders>
   </StrictMode>
 );
diff --git a/src/pages/Content.tsx b/src/pages/Content.tsx
index 7aef3c0..ac14f35 100644
--- a/src/pages/Content.tsx
+++ b/src/pages/Content.tsx
@@ -1,19 +1,23 @@
 import { useEffect, useState } from "react";
-import { Navigate, useNavigate, useParams } from "react-router-dom";
+import { useParams } from "react-router-dom";
 import {
   findCurriculumSubTopicById,
-  getFirstCurriculumSubTopic,
   getMarkdownBody,
   type CurriculumSubTopicNode,
 } from "../components/content/CurriculumTreeView";
 import { LeftContentPanel } from "../components/content/LeftContentPanel";
 import { MainContent } from "../components/content/MainContent";
 import { RightContentPanel } from "../components/content/RightContentPanel";
+import {
+  getMatchingContentRouteData,
+  type ContentRouteData,
+} from "../components/content/contentRouteData";
 import { removeCommonInterviewQuestionsSection } from "../components/content/markdown";
 import welcomeMarkdown from "../contents/resources/welcome.md?raw";
 import { useAppDispatch, useAppSelector } from "../lib/redux/hooks/hooks";
 import { selectSelectedContentTopicId } from "../lib/redux/selectors/contentSelectors";
 import { setSelectedTopicId } from "../lib/redux/slices/contentSlice";
+import NotFound from "./NotFound";
 
 const welcomeContent = getMarkdownBody(welcomeMarkdown);
 
@@ -23,15 +27,22 @@ type LoadedContentState = {
   topicId?: string;
 };
 
-export default function Content() {
+type ContentProps = {
+  initialRouteData?: ContentRouteData;
+};
+
+export default function Content({ initialRouteData }: ContentProps) {
   const { topicId } = useParams<{ topicId?: string }>();
-  const navigate = useNavigate();
   const dispatch = useAppDispatch();
   const selectedTopicId = useAppSelector(selectSelectedContentTopicId);
   const isWelcomeContent = !topicId;
-  const firstTopic = getFirstCurriculumSubTopic();
+  const routeData = getMatchingContentRouteData(initialRouteData, topicId);
   const selectedTopic = topicId ? findCurriculumSubTopicById(topicId) : undefined;
   const routeSelectedTopicId = selectedTopic?.id;
+  const initialTopicMarkdown =
+    routeData?.kind === "topic"
+      ? getMarkdownBody(routeData.markdown)
+      : undefined;
   const [loadedContent, setLoadedContent] = useState<LoadedContentState>({
     error: "",
     markdown: "",
@@ -63,7 +74,7 @@ export default function Content() {
   useEffect(() => {
     let isCancelled = false;
 
-    if (!selectedTopic) {
+    if (!selectedTopic || initialTopicMarkdown !== undefined) {
       return;
     }
 
@@ -91,50 +102,42 @@ export default function Content() {
     return () => {
       isCancelled = true;
     };
-  }, [selectedTopic]);
+  }, [initialTopicMarkdown, selectedTopic]);
 
   const selectTopic = (topic: CurriculumSubTopicNode) => {
     if (selectedTopicId !== topic.id) {
       dispatch(setSelectedTopicId(topic.id));
     }
-
-    navigate(`/content/${topic.id}/`);
   };
 
   if (isWelcomeContent) {
     return (
       <ContentLayout
         isWelcomeContent
-        markdown={welcomeContent}
+        markdown={
+          routeData?.kind === "welcome"
+            ? getMarkdownBody(routeData.markdown)
+            : welcomeContent
+        }
         onTopicSelect={selectTopic}
         selectedTopic={undefined}
       />
     );
   }
 
-  if (!firstTopic) {
-    return (
-      <ContentLayout
-        isWelcomeContent={false}
-        markdown=""
-        onTopicSelect={() => undefined}
-        selectedTopic={undefined}
-      />
-    );
-  }
-
-  if (!selectedTopic) {
-    return <Navigate replace to={`/content/${firstTopic.id}/`} />;
+  if (routeData?.kind === "not-found" || !selectedTopic) {
+    return <NotFound />;
   }
 
   return (
     <ContentLayout
       isWelcomeContent={false}
       markdown={
-        selectedContent?.error ||
-        (selectedContent?.markdown
-          ? getMarkdownBody(selectedContent.markdown)
-          : "Loading content...")
+        initialTopicMarkdown ??
+        (selectedContent?.error ||
+          (selectedContent?.markdown
+            ? getMarkdownBody(selectedContent.markdown)
+            : "Loading content..."))
       }
       onTopicSelect={selectTopic}
       selectedTopic={selectedTopic}
diff --git a/src/pages/Home.tsx b/src/pages/Home.tsx
index 2b87c08..b2f6d44 100644
--- a/src/pages/Home.tsx
+++ b/src/pages/Home.tsx
@@ -13,7 +13,7 @@ import TerminalOutlinedIcon from "@mui/icons-material/TerminalOutlined";
 import { Box, Button, Container, Stack } from "@mui/material";
 import { useMemo } from "react";
 import type { ReactNode } from "react";
-import { useNavigate } from "react-router-dom";
+import { Link as RouterLink } from "react-router-dom";
 import {
   collectSubTopicNodes,
   generatedCurriculumTree,
@@ -103,7 +103,7 @@ function buildLearningPaths(): LearningPath[] {
       className:
         learningPathClassNames[categoryNode.title] ??
         "lg:col-span-4 lg:min-h-[217px]",
-      to: subTopics[0] ? `/content/${subTopics[0].id}/` : "/content",
+      to: subTopics[0] ? `/content/${subTopics[0].id}/` : "/content/",
     };
   });
 }
@@ -269,20 +269,21 @@ function PageSection({
 function CyberButton({
   children,
   intent = "primary",
-  onClick,
+  to,
 }: {
   children: ReactNode;
   intent?: "primary" | "secondary";
-  onClick?: () => void;
+  to: string;
 }) {
   const isPrimary = intent === "primary";
 
   return (
     <Button
+      component={RouterLink}
       disableElevation
       disableRipple
       className="gleeple-heading h-[54px] px-8 text-center"
-      onClick={onClick}
+      onClick={scrollToPageTop}
       sx={{
         borderRadius: 0,
         border: isPrimary
@@ -311,7 +312,7 @@ function CyberButton({
           filter: isPrimary ? "brightness(1.08)" : "none",
         },
       }}
-      type="button"
+      to={to}
     >
       {children}
     </Button>
@@ -407,10 +408,8 @@ function CodePreview() {
 
 function LearningPathCard({
   path,
-  onSelect,
 }: {
   path: LearningPath;
-  onSelect: (to: string) => void;
 }) {
   const isFeatured = path.tags.length > 0;
 
@@ -418,17 +417,18 @@ function LearningPathCard({
     <Box
       aria-label={`Open ${path.title} learning path`}
       className={`theme-glass-card group flex flex-col justify-between p-[25px] ${path.className}`}
-      component="button"
-      onClick={() => onSelect(path.to)}
+      component={RouterLink}
+      onClick={scrollToPageTop}
       sx={{
         appearance: "none",
         color: "inherit",
         cursor: "pointer",
         font: "inherit",
         textAlign: "left",
+        textDecoration: "none",
         width: "100%",
       }}
-      type="button"
+      to={path.to}
     >
       <Stack spacing={2} className="relative z-10">
         <div className="flex items-start justify-between gap-4">
@@ -530,14 +530,8 @@ function RoadmapStepCard({ step }: { step: RoadmapStep }) {
 }
 
 export default function Home() {
-  const navigate = useNavigate();
   const drills = useMemo(() => getRandomDrills(), []);
 
-  const navigateFromHome = (path: string) => {
-    navigate(path);
-    scrollToPageTop();
-  };
-
   return (
     <Box className="theme-page min-h-screen overflow-hidden">
       <Box className="flex flex-col items-center gap-20 pb-20 pt-24 md:pt-32">
@@ -571,13 +565,10 @@ export default function Home() {
                 spacing={2}
                 className="pt-2"
               >
-                <CyberButton onClick={() => navigateFromHome("/content")}>
+                <CyberButton to="/content/">
                   Start Learning Now
                 </CyberButton>
-                <CyberButton
-                  intent="secondary"
-                  onClick={() => navigateFromHome("/practice")}
-                >
+                <CyberButton intent="secondary" to="/practice/">
                   Explore Question Bank
                 </CyberButton>
               </Stack>
@@ -594,11 +585,7 @@ export default function Home() {
 
           <div className="grid grid-cols-1 gap-6 md:grid-cols-2 lg:grid-cols-12">
             {learningPaths.map((path) => (
-              <LearningPathCard
-                key={path.title}
-                onSelect={navigateFromHome}
-                path={path}
-              />
+              <LearningPathCard key={path.title} path={path} />
             ))}
           </div>
         </PageSection>
@@ -622,9 +609,10 @@ export default function Home() {
               subtitle="Common technical assessment benchmarks"
             />
             <Button
+              component={RouterLink}
               endIcon={<ArrowForwardIcon sx={{ fontSize: 16 }} />}
               className="gleeple-heading"
-              onClick={() => navigateFromHome("/practice")}
+              onClick={scrollToPageTop}
               sx={{
                 borderRadius: 0,
                 color: "var(--color-primary-container)",
@@ -635,6 +623,7 @@ export default function Home() {
                 whiteSpace: "nowrap",
                 "&:hover": { backgroundColor: "var(--color-accent-hover)" },
               }}
+              to="/practice/"
             >
               View All Questions
             </Button>
@@ -677,7 +666,7 @@ export default function Home() {
               interview performance with our platform.
             </p>
             <div className="relative mt-6">
-              <CyberButton onClick={() => navigateFromHome("/content")}>
+              <CyberButton to="/content/">
                 Get Started
               </CyberButton>
             </div>
diff --git a/src/pages/Practice.tsx b/src/pages/Practice.tsx
index 7ee2a9d..f3ac1b6 100644
--- a/src/pages/Practice.tsx
+++ b/src/pages/Practice.tsx
@@ -31,6 +31,7 @@ import {
   setSubTopicProgress,
   type ContentSubTopicProgress,
 } from "../lib/redux/slices/contentSlice";
+import NotFound from "./NotFound";
 
 const practiceLevels = ["Beginner", "Intermediate", "Advanced"];
 const emptyCompletedQuestions: number[] = [];
@@ -786,7 +787,7 @@ function PracticeIndexCta({ firstTopic }: { firstTopic?: CurriculumSubTopicNode
             component={RouterLink}
             endIcon={<RocketLaunchOutlinedIcon />}
             sx={{ px: 5, py: 1.5 }}
-            to={`/simulation`}
+            to="/simulation/"
             variant="contained"
           >
             Start simulation
@@ -1070,7 +1071,7 @@ export default function Practice() {
   }
 
   if (!topic) {
-    return <EmptyPracticeState onGoBack={() => navigate(-1)} />;
+    return <NotFound />;
   }
 
   if (!topicPractice) {
diff --git a/src/routing/canonicalPath.ts b/src/routing/canonicalPath.ts
new file mode 100644
index 0000000..0b654eb
--- /dev/null
+++ b/src/routing/canonicalPath.ts
@@ -0,0 +1,31 @@
+const trailingSlashRouteAliases = new Set([
+  "/about-us",
+  "/bug-report",
+  "/changelog",
+  "/content",
+  "/practice",
+  "/privacy",
+  "/roadmap",
+  "/simulation",
+  "/simulation/setup",
+  "/terms",
+]);
+
+export function getCanonicalPathname(pathname: string) {
+  if (pathname === "/home" || pathname === "/home/") {
+    return "/";
+  }
+
+  if (pathname.endsWith("/")) {
+    return undefined;
+  }
+
+  if (
+    trailingSlashRouteAliases.has(pathname) ||
+    /^\/(?:content|practice)\/[^/]+$/.test(pathname)
+  ) {
+    return `${pathname}/`;
+  }
+
+  return undefined;
+}
diff --git a/src/theme/ThemeModeProvider.tsx b/src/theme/ThemeModeProvider.tsx
index 08b8c22..9b094a9 100644
--- a/src/theme/ThemeModeProvider.tsx
+++ b/src/theme/ThemeModeProvider.tsx
@@ -1,21 +1,57 @@
-import { useEffect, useMemo, useState } from "react";
+import {
+  useCallback,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 import type { ReactNode } from "react";
 import { CssBaseline, ThemeProvider } from "@mui/material";
 import {
   appThemeTokens,
   applyThemeVariables,
   buildMuiTheme,
+  persistThemeMode,
+  readBootstrappedThemeMode,
   ThemeModeContext,
   type AppThemeMode,
 } from "./themeMode";
 
-export function AppThemeModeProvider({ children }: { children: ReactNode }) {
-  const [mode, setMode] = useState<AppThemeMode>("dark");
+type AppThemeModeProviderProps = {
+  children: ReactNode;
+  initialMode?: AppThemeMode;
+};
+
+export function AppThemeModeProvider({
+  children,
+  initialMode = "dark",
+}: AppThemeModeProviderProps) {
+  const [mode, setModeState] = useState<AppThemeMode>(initialMode);
+  const hasReadBootstrappedMode = useRef(false);
   const tokens = appThemeTokens[mode];
 
-  useEffect(() => {
+  useLayoutEffect(() => {
+    if (!hasReadBootstrappedMode.current) {
+      hasReadBootstrappedMode.current = true;
+      const bootstrappedMode = readBootstrappedThemeMode(initialMode);
+
+      if (bootstrappedMode !== mode) {
+        // The bootstrap is an external pre-hydration input. Reconcile it in a
+        // layout effect so server markup hydrates as dark before the saved
+        // choice is applied, while still updating before the browser paints.
+        // eslint-disable-next-line react-hooks/set-state-in-effect
+        setModeState(bootstrappedMode);
+        return;
+      }
+    }
+
     applyThemeVariables(tokens);
-  }, [tokens]);
+  }, [initialMode, mode, tokens]);
+
+  const setMode = useCallback((nextMode: AppThemeMode) => {
+    persistThemeMode(nextMode);
+    setModeState(nextMode);
+  }, []);
 
   const muiTheme = useMemo(() => buildMuiTheme(mode, tokens), [mode, tokens]);
 
@@ -24,10 +60,9 @@ export function AppThemeModeProvider({ children }: { children: ReactNode }) {
       mode,
       tokens,
       setMode,
-      toggleMode: () =>
-        setMode((current) => (current === "dark" ? "light" : "dark")),
+      toggleMode: () => setMode(mode === "dark" ? "light" : "dark"),
     }),
-    [mode, tokens]
+    [mode, setMode, tokens]
   );
 
   return (
diff --git a/src/theme/themeMode.ts b/src/theme/themeMode.ts
index 7caea5a..a6b6919 100644
--- a/src/theme/themeMode.ts
+++ b/src/theme/themeMode.ts
@@ -3,6 +3,8 @@ import { createTheme, type PaletteMode } from "@mui/material";
 
 export type AppThemeMode = "dark" | "light";
 
+export const THEME_MODE_STORAGE_KEY = "dev-net-core:theme";
+
 export type AppThemeTokens = {
   mode: AppThemeMode;
   background: string;
@@ -136,11 +138,16 @@ export const ThemeModeContext = createContext<
 >(undefined);
 
 export function applyThemeVariables(tokens: AppThemeTokens) {
+  if (typeof document === "undefined") {
+    return;
+  }
+
   const root = document.documentElement;
 
   root.dataset.theme = tokens.mode;
   root.classList.toggle("dark", tokens.mode === "dark");
   root.classList.toggle("light", tokens.mode === "light");
+  root.style.colorScheme = tokens.mode;
 
   root.style.setProperty("--color-background", tokens.background);
   root.style.setProperty("--color-on-background", tokens.onBackground);
@@ -193,6 +200,42 @@ export function applyThemeVariables(tokens: AppThemeTokens) {
   root.style.setProperty("--shadow-panel-glow", tokens.panelGlow);
 }
 
+export function readBootstrappedThemeMode(
+  fallback: AppThemeMode
+): AppThemeMode {
+  if (typeof document === "undefined") {
+    return fallback;
+  }
+
+  const documentMode = document.documentElement.dataset.theme;
+
+  if (documentMode === "dark" || documentMode === "light") {
+    return documentMode;
+  }
+
+  try {
+    const storedMode = window.localStorage.getItem(THEME_MODE_STORAGE_KEY);
+
+    return storedMode === "dark" || storedMode === "light"
+      ? storedMode
+      : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+export function persistThemeMode(mode: AppThemeMode) {
+  if (typeof window === "undefined") {
+    return;
+  }
+
+  try {
+    window.localStorage.setItem(THEME_MODE_STORAGE_KEY, mode);
+  } catch {
+    // Theme changes still work for the current page when storage is unavailable.
+  }
+}
+
 export function buildMuiTheme(mode: PaletteMode, tokens: AppThemeTokens) {
   return createTheme({
     palette: {
diff --git a/tsconfig.framework.json b/tsconfig.framework.json
new file mode 100644
index 0000000..c1e286e
--- /dev/null
+++ b/tsconfig.framework.json
@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.app.json",
+  "compilerOptions": {
+    "rootDirs": [".", "./.react-router/types"],
+    "types": ["node", "vite/client"]
+  },
+  "include": [
+    "app",
+    "src",
+    ".react-router/types/**/*",
+    "shared/**/*.d.mts"
+  ]
+}
diff --git a/tsconfig.node.json b/tsconfig.node.json
index 8a67f62..1c0ee2d 100644
--- a/tsconfig.node.json
+++ b/tsconfig.node.json
@@ -22,5 +22,10 @@
     "noFallthroughCasesInSwitch": true,
     "noUncheckedSideEffectImports": true
   },
-  "include": ["vite.config.ts"]
+  "include": [
+    "build/vite/**/*.ts",
+    "react-router.config.ts",
+    "vite.config.ts",
+    "vite.framework.config.ts"
+  ]
 }
diff --git a/vite.config.ts b/vite.config.ts
index 1bbbb50..0f06ee4 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -1,42 +1,7 @@
-import fs from 'node:fs'
-import path from 'node:path'
 import { defineConfig } from 'vite'
 import react from '@vitejs/plugin-react'
 import tailwindcss from '@tailwindcss/vite'
-
-const rawMarkdownHashPathPrefix = '\0raw-markdown-hash-path:'
-
-function rawMarkdownHashPathPlugin() {
-  return {
-    name: 'raw-markdown-hash-path',
-    enforce: 'pre' as const,
-    resolveId(source: string, importer?: string) {
-      if (!importer || !source.includes('#') || !source.includes('.md?raw')) {
-        return null
-      }
-
-      const [filePath] = source.split('?')
-      const importerPath = importer.split('?')[0]
-      const resolvedPath = path.resolve(path.dirname(importerPath), filePath)
-
-      if (!fs.existsSync(resolvedPath)) {
-        return null
-      }
-
-      return `${rawMarkdownHashPathPrefix}${resolvedPath}`
-    },
-    load(id: string) {
-      if (!id.startsWith(rawMarkdownHashPathPrefix)) {
-        return null
-      }
-
-      const filePath = id.slice(rawMarkdownHashPathPrefix.length)
-      const markdown = fs.readFileSync(filePath, 'utf8')
-
-      return `export default ${JSON.stringify(markdown)};`
-    },
-  }
-}
+import { rawMarkdownHashPathPlugin } from './build/vite/rawMarkdownHashPathPlugin'
 
 // https://vite.dev/config/
 export default defineConfig({
diff --git a/vite.framework.config.ts b/vite.framework.config.ts
new file mode 100644
index 0000000..75d1a6f
--- /dev/null
+++ b/vite.framework.config.ts
@@ -0,0 +1,15 @@
+import { fileURLToPath } from "node:url";
+import tailwindcss from "@tailwindcss/vite";
+import { reactRouter } from "@react-router/dev/vite";
+import { defineConfig } from "vite";
+import { rawMarkdownHashPathPlugin } from "./build/vite/rawMarkdownHashPathPlugin";
+
+export default defineConfig({
+  base: "/",
+  plugins: [
+    rawMarkdownHashPathPlugin(),
+    reactRouter(),
+    tailwindcss(),
+  ],
+  root: fileURLToPath(new URL(".", import.meta.url)),
+});