diff --git a/apps/docs/app/reference/[...slug]/page.tsx b/apps/docs/app/reference/[...slug]/page.tsx
index 2c7bb70463bd9..0ed5497704c71 100644
--- a/apps/docs/app/reference/[...slug]/page.tsx
+++ b/apps/docs/app/reference/[...slug]/page.tsx
@@ -33,6 +33,10 @@ export default async function ReferencePage(props: { params: Promise<{ slug: Arr
     const { sdkId, maybeVersion, path } = parsedPath
 
     const sdkData = REFERENCES[sdkId]
+    if (sdkData.enabled === false) {
+      notFound()
+    }
+
     const latestVersion = sdkData.versions[0]
     const version = maybeVersion ?? latestVersion
 
diff --git a/apps/docs/components/Navigation/Navigation.types.ts b/apps/docs/components/Navigation/Navigation.types.ts
index 7918a38e68e64..816a5b363b005 100644
--- a/apps/docs/components/Navigation/Navigation.types.ts
+++ b/apps/docs/components/Navigation/Navigation.types.ts
@@ -11,6 +11,9 @@ export interface NavMenuSection {
   name: string
   url?: `/${string}` | `https://${string}`
   items: Partial<NavMenuSection>[]
+  icon?: string
+  hasLightIcon?: boolean
+  isDarkMode?: boolean
   enabled?: boolean
 }
 
diff --git a/apps/docs/components/Navigation/NavigationMenu/NavigationMenu.constants.ts b/apps/docs/components/Navigation/NavigationMenu/NavigationMenu.constants.ts
index ea41b02c326d8..0a86df1786003 100644
--- a/apps/docs/components/Navigation/NavigationMenu/NavigationMenu.constants.ts
+++ b/apps/docs/components/Navigation/NavigationMenu/NavigationMenu.constants.ts
@@ -1,6 +1,6 @@
 import type { ComponentProps } from 'react'
 
-import { isFeatureEnabled } from 'common'
+import { isFeatureEnabled } from 'common/enabled-features'
 import type { IconPanel } from 'ui-patterns/IconPanel'
 import type { GlobalMenuItems, NavMenuConstant, NavMenuSection } from '../Navigation.types'
 
@@ -460,7 +460,7 @@ export const NativeMobileLoginItems = [
   },
 ]
 
-export const SocialLoginItems = [
+export const SocialLoginItems: Array<Partial<NavMenuSection>> = [
   {
     name: 'Google',
     icon: '/docs/img/icons/google-icon',
@@ -591,7 +591,7 @@ export const PhoneLoginsItems = [
   },
 ]
 
-export const auth = {
+export const auth: NavMenuConstant = {
   icon: 'auth',
   title: 'Auth',
   items: [
@@ -1440,6 +1440,10 @@ export const functions: NavMenuConstant = {
           name: 'Development Environment',
           url: '/guides/functions/development-environment' as `/${string}`,
         },
+        {
+          name: 'Architecture',
+          url: '/guides/functions/architecture',
+        },
       ],
     },
     {
@@ -1865,7 +1869,7 @@ export const storage: NavMenuConstant = {
   ],
 }
 
-export const vectorIndexItems = [
+export const vectorIndexItems: Array<Partial<NavMenuSection>> = [
   {
     name: 'HNSW indexes',
     url: '/guides/ai/vector-indexes/hnsw-indexes',
@@ -1876,7 +1880,7 @@ export const vectorIndexItems = [
   },
 ]
 
-export const ai = {
+export const ai: NavMenuConstant = {
   icon: 'ai',
   title: 'AI & Vectors',
   url: '/guides/ai',
diff --git a/apps/docs/content/guides/functions.mdx b/apps/docs/content/guides/functions.mdx
index 04632855d9344..fdcf0627f9ad4 100644
--- a/apps/docs/content/guides/functions.mdx
+++ b/apps/docs/content/guides/functions.mdx
@@ -4,7 +4,7 @@ title: 'Edge Functions'
 description: 'Globally distributed TypeScript functions.'
 subtitle: 'Globally distributed TypeScript functions.'
 sidebar_label: 'Overview'
-hideToc: true
+tocVideo: 'za_loEtS4gs'
 ---
 
 Edge Functions are server-side TypeScript functions, distributed globally at the edge—close to your users. They can be used for listening to webhooks or integrating your Supabase project with third-parties [like Stripe](https://github.com/supabase/supabase/tree/master/examples/edge-functions/supabase/functions/stripe-webhooks). Edge Functions are developed using [Deno](https://deno.com), which offers a few benefits to you as a developer:
@@ -14,6 +14,33 @@ Edge Functions are server-side TypeScript functions, distributed globally at the
 - It is TypeScript first and supports WASM.
 - Edge Functions are globally distributed for low-latency.
 
+## How it works
+
+- **Request enters an edge gateway (relay)** — the gateway routes traffic, handles auth headers/JWT validation, and applies routing/traffic rules.
+- **Auth & policies are applied** — the gateway (or your function) can validate Supabase JWTs, apply rate-limits, and centralize security checks before executing code.
+- **[Edge runtime](https://github.com/supabase/edge-runtime) executes your function** — the function runs on a regionally-distributed Edge Runtime node closest to the user for minimal latency.
+- **Integrations & data access** — functions commonly call Supabase APIs (Auth, Postgres, Storage) or third-party APIs. For Postgres, prefer connection strategies suited for edge/serverless environments (see the `connect-to-postgres` guide).
+- **Observability and logs** — invocations emit logs and metrics you can explore in the dashboard or downstream monitoring (Sentry, etc.).
+- **Response returns via the gateway** — the gateway forwards the response back to the client and records request metadata.
+
+## Quick technical notes
+
+- **Runtime:** Supabase Edge Runtime (Deno compatible runtime with TypeScript first). Functions are simple `.ts` files that export a handler.
+- **Local dev parity:** Use Supabase CLI for a local runtime similar to production for faster iteration (`supabase functions serve` command).
+- **Global deployment:** Deploy your Edge Functions via Supabase Dashboard, CLI or MCP.
+- **Cold starts & concurrency:** cold starts are possible — design for short-lived, idempotent operations. Heavy long-running jobs should be moved to [background workers](/docs/guides/functions/background-tasks).
+- **Database connections:** treat Postgres like a remote, pooled service — use connection pools or serverless-friendly drivers.
+- **Secrets:** store credentials in Supabase [project secrets](/docs/reference/cli/supabase-secrets) and access them via environment variables.
+
+## When to use Edge Functions
+
+- Authenticated or public HTTP endpoints that need low latency.
+- Webhook receivers (Stripe, GitHub, etc.).
+- On-demand image or Open Graph generation.
+- Small AI inference tasks or orchestrating calls to external LLM APIs (like OpenAI)
+- Sending transactional emails.
+- Building messaging bots for Slack, Discord, etc.
+
 <div className="not-prose">
   <Button size="medium" asChild>
     <a href="/docs/guides/functions/quickstart">Get started</a>
diff --git a/apps/docs/content/guides/functions/architecture.mdx b/apps/docs/content/guides/functions/architecture.mdx
new file mode 100644
index 0000000000000..d074e55b864bb
--- /dev/null
+++ b/apps/docs/content/guides/functions/architecture.mdx
@@ -0,0 +1,107 @@
+---
+id: 'architecture'
+title: 'Edge Functions Architecture'
+description: 'Guide to Supabase Edge Functions: Architecture and How They Work'
+subtitle: 'Understanding the Architecture of Supabase Edge Functions'
+tocVideo: 'za_loEtS4gs'
+---
+
+This guide explains the architecture and inner workings of Supabase Edge Functions, based on the concepts demonstrated in the video "Supabase Edge Functions Explained". Edge functions are serverless compute resources that run at the edge of the network, close to users, enabling low-latency execution for tasks like API endpoints, webhooks, and real-time data processing. This guide breaks down Edge Functions into key sections: an example use case, deployment process, global distribution, and execution mechanics.
+
+## 1. Understanding Edge Functions through an example: Image filtering
+
+To illustrate how edge functions operate, consider a photo-sharing app where users upload images and apply filters (e.g., grayscale or sepia) before saving them.
+
+- **Workflow Overview**:
+
+  - A user uploads an original image to Supabase Storage.
+  - When the user selects a filter, the client-side app (using the Supabase JavaScript SDK) invokes an edge function named something like "apply-filter."
+  - The edge function:
+    1. Downloads the original image from Supabase Storage.
+    2. Applies the filter using a library like ImageMagick.
+    3. Uploads the processed image back to Storage.
+    4. Returns the path to the filtered image to the client.
+
+- **Why Edge Functions?**:
+  - They handle compute-intensive tasks without burdening the client device or the database.
+  - Execution happens server-side but at the edge, ensuring speed and scalability.
+  - Developers define the function in a simple JavaScript file within the Supabase functions directory.
+
+This example highlights edge functions as lightweight, on-demand code snippets that integrate seamlessly with Supabase services like Storage and Auth.
+
+## 2. Deployment process
+
+Deploying an edge function is straightforward and automated, requiring no manual server setup.
+
+- **Steps to Deploy**:
+
+  1. Write the function code in your local Supabase project (e.g., in `supabase/functions/apply-filter/index.ts`).
+  2. Run the command `supabase functions deploy apply-filter` via the Supabase CLI.
+  3. The CLI bundles the function and its dependencies into an **ESZip file**—a compact format created by Deno that includes a complete module graph for quick loading and execution.
+  4. The bundled file is uploaded to Supabase's backend.
+  5. Supabase generates a unique URL for the function, making it accessible globally.
+
+- **Key Benefits of Deployment**:
+  - Automatic handling of dependencies and bundling.
+  - No need to manage infrastructure; Supabase distributes the function across its global edge network.
+
+Once deployed, the function is ready for invocation from anywhere, with Supabase handling scaling and availability.
+
+## 3. Global distribution and routing
+
+Edge functions leverage a distributed architecture to minimize latency by running code close to the user.
+
+- **Architecture Components**:
+
+  - **Global API Gateway**: Acts as the entry point for all requests. It uses the requester's IP address to determine geographic location and routes the request to the nearest edge location (e.g., routing a request from Amsterdam to Frankfurt).
+  - **Edge Locations**: Supabase's network of data centers worldwide where functions are replicated. The ESZip bundle is automatically distributed to these locations upon deployment.
+  - **Routing Logic**: Based on geolocation mapping, ensuring the function executes as close as possible to the user for optimal performance.
+
+- **How Distribution Works**:
+  - Post-deployment, the function is propagated to all edge nodes.
+  - This setup eliminates the need for developers to configure CDNs or regional servers manually.
+
+This global edge network is what makes edge functions "edge-native," providing consistent performance regardless of user location.
+
+## 4. Execution mechanics: Fast and isolated
+
+The core of edge functions' efficiency lies in their execution environment, which prioritizes speed, isolation, and scalability.
+
+- **Request Handling**:
+
+  1. A client sends an HTTP request (e.g., POST) to the function's URL, including parameters like auth headers, image ID, and filter type.
+  2. The global API gateway routes it to the nearest edge location.
+  3. At the edge, Supabase's **edge runtime** validates the request (e.g., checks authorization).
+
+- **Execution Environment**:
+
+  - A new **V8 isolate** is spun up for each invocation. V8 is the JavaScript engine used by Chrome and Node.js, providing a lightweight, sandboxed environment.
+  - Each isolate has its own memory heap and execution thread, ensuring complete isolation—no interference between concurrent requests.
+  - The ESZip bundle is loaded into the isolate, and the function code runs.
+  - After execution, the response (e.g., filtered image path) is sent back to the client.
+
+- **Performance Optimizations**:
+
+  - **Cold Starts**: Even initial executions are fast (milliseconds) due to the compact ESZip format and minimal Deno runtime overhead.
+  - **Warm Starts**: Isolates can remain active for a period (plan-dependent) to handle subsequent requests without restarting.
+  - **Concurrency**: Multiple isolates can run simultaneously in the same edge location, supporting high traffic.
+
+- **Isolation and Security**:
+  - Isolates prevent side effects from one function affecting others, enhancing reliability.
+  - No persistent state; each run is stateless, ideal for ephemeral tasks.
+
+Compared to traditional serverless or monolithic architectures, this setup offers lower latency, automatic scaling, and no infrastructure management, making it perfect for global apps.
+
+## Benefits and use cases
+
+- **Advantages**:
+
+  - **Low Latency**: Proximity to users reduces round-trip times.
+  - **Scalability**: Handles variable loads without provisioning servers.
+  - **Developer-Friendly**: Focus on code; Supabase manages the rest.
+  - **Cost-Effective**: Pay-per-use model, with fast execution minimizing costs.
+
+- **Common Use Cases**:
+  - Real-time data transformations (e.g., image processing).
+  - API integrations and webhooks.
+  - Personalization and A/B testing at the edge.
diff --git a/apps/docs/content/navigation.references.ts b/apps/docs/content/navigation.references.ts
index e3b02e54ab00c..fb619cb0539b9 100644
--- a/apps/docs/content/navigation.references.ts
+++ b/apps/docs/content/navigation.references.ts
@@ -1,3 +1,13 @@
+import { isFeatureEnabled } from 'common/enabled-features'
+
+const {
+  sdkCsharp: sdkCsharpEnabled,
+  sdkDart: sdkDartEnabled,
+  sdkKotlin: sdkKotlinEnabled,
+  sdkPython: sdkPythonEnabled,
+  sdkSwift: sdkSwiftEnabled,
+} = isFeatureEnabled(['sdk:csharp', 'sdk:dart', 'sdk:kotlin', 'sdk:python', 'sdk:swift'])
+
 export const REFERENCES = {
   javascript: {
     type: 'sdk',
@@ -35,6 +45,7 @@ export const REFERENCES = {
         specFile: 'supabase_dart_v1',
       },
     },
+    enabled: sdkDartEnabled,
   },
   csharp: {
     type: 'sdk',
@@ -53,6 +64,7 @@ export const REFERENCES = {
         specFile: 'supabase_csharp_v0',
       },
     },
+    enabled: sdkCsharpEnabled,
   },
   swift: {
     type: 'sdk',
@@ -71,6 +83,7 @@ export const REFERENCES = {
         specFile: 'supabase_swift_v1',
       },
     },
+    enabled: sdkSwiftEnabled,
   },
   kotlin: {
     type: 'sdk',
@@ -93,6 +106,7 @@ export const REFERENCES = {
         specFile: 'supabase_kt_v1',
       },
     },
+    enabled: sdkKotlinEnabled,
   },
   python: {
     type: 'sdk',
@@ -107,6 +121,7 @@ export const REFERENCES = {
         specFile: 'supabase_py_v2',
       },
     },
+    enabled: sdkPythonEnabled,
   },
   cli: {
     type: 'cli',
@@ -160,7 +175,7 @@ export const REFERENCES = {
 } as const
 
 export const clientSdkIds = Object.keys(REFERENCES).filter(
-  (reference) => REFERENCES[reference].type === 'sdk'
+  (reference) => REFERENCES[reference].type === 'sdk' && REFERENCES[reference].enabled !== false
 )
 
 export const selfHostingServices = Object.keys(REFERENCES).filter(
diff --git a/apps/docs/features/docs/GuidesMdx.utils.tsx b/apps/docs/features/docs/GuidesMdx.utils.tsx
index 50b5dede231a2..b6c7a7742319a 100644
--- a/apps/docs/features/docs/GuidesMdx.utils.tsx
+++ b/apps/docs/features/docs/GuidesMdx.utils.tsx
@@ -16,6 +16,7 @@ import { BASE_PATH } from '~/lib/constants'
 import { GUIDES_DIRECTORY, isValidGuideFrontmatter, type GuideFrontmatter } from '~/lib/docs'
 import { GuideModelLoader } from '~/resources/guide/guideModelLoader'
 import { newEditLink } from './GuidesMdx.template'
+import { checkGuidePageEnabled } from './NavigationPageStatus.utils'
 
 const PUBLISHED_SECTIONS = [
   'ai',
@@ -42,6 +43,8 @@ const PUBLISHED_SECTIONS = [
 const getGuidesMarkdownInternal = async (slug: string[]) => {
   const relPath = slug.join(sep).replace(/\/$/, '')
   const fullPath = join(GUIDES_DIRECTORY, relPath + '.mdx')
+  const guidesPath = `/guides/${slug.join('/')}`
+
   /**
    * SAFETY CHECK:
    * Prevent accessing anything outside of published sections and GUIDES_DIRECTORY
@@ -53,6 +56,15 @@ const getGuidesMarkdownInternal = async (slug: string[]) => {
     notFound()
   }
 
+  /**
+   * DISABLED PAGE CHECK:
+   * Check if this page is disabled in the navigation configuration
+   */
+  if (!checkGuidePageEnabled(guidesPath)) {
+    console.log('Page is disabled: %s', guidesPath)
+    notFound()
+  }
+
   try {
     const guide = (await GuideModelLoader.fromFs(relative(GUIDES_DIRECTORY, fullPath))).unwrap()
     const content = guide.content ?? ''
@@ -121,12 +133,25 @@ const genGuidesStaticParams = (directory?: string) => async () => {
           )
       )
 
+  // Flattening earlier will not work because there is nothing to flatten
+  // until the promises resolve.
+  const allParams = (await Promise.all(promises)).flat()
+
   /**
-   * Flattening earlier will not work because there is nothing to flatten
-   * until the promises resolve.
+   * Filter out disabled pages from static generation
    */
-  const result = (await Promise.all(promises)).flat()
-  return result
+  const enabledParams = allParams.filter((param) => {
+    const guidesPath = `/guides/${directory ? `${directory}/` : ''}${param.slug.join('/')}`
+    const isEnabled = checkGuidePageEnabled(guidesPath)
+
+    if (!isEnabled) {
+      console.log('Excluding disabled page from static generation: %s', guidesPath)
+    }
+
+    return isEnabled
+  })
+
+  return enabledParams
 }
 
 const genGuideMeta =
diff --git a/apps/docs/features/docs/NavigationPageStatus.utils.ts b/apps/docs/features/docs/NavigationPageStatus.utils.ts
new file mode 100644
index 0000000000000..6968e1e23aa1f
--- /dev/null
+++ b/apps/docs/features/docs/NavigationPageStatus.utils.ts
@@ -0,0 +1,130 @@
+import { type NavMenuConstant } from '~/components/Navigation/Navigation.types'
+import {
+  GLOBAL_MENU_ITEMS,
+  ai,
+  api,
+  auth,
+  cron,
+  database,
+  deployment,
+  functions,
+  gettingstarted,
+  graphql,
+  integrations,
+  local_development,
+  platform,
+  queues,
+  realtime,
+  security,
+  self_hosting,
+  storage,
+  telemetry,
+} from '~/components/Navigation/NavigationMenu/NavigationMenu.constants'
+
+// Map of section names to their nav constants
+const SECTION_NAV_MAPS: Record<string, NavMenuConstant> = {
+  ai,
+  api,
+  auth,
+  cron,
+  database,
+  deployment,
+  functions,
+  'getting-started': gettingstarted,
+  graphql,
+  integrations,
+  'local-development': local_development,
+  platform,
+  queues,
+  realtime,
+  security,
+  'self-hosting': self_hosting,
+  storage,
+  telemetry,
+}
+
+interface ConditionalNavItem {
+  url?: string
+  href?: string
+  enabled?: boolean
+  items?: Readonly<ConditionalNavItem[]>
+  menuItems?: Readonly<ConditionalNavItem[][]>
+}
+
+/**
+ * Recursively walks navigation items and collects all disabled paths.
+ * If a parent is disabled, all its children are also considered disabled.
+ */
+function collectDisabledPaths(
+  items: Readonly<ConditionalNavItem[] | ConditionalNavItem[][]>,
+  disabledPaths: Set<string>,
+  parentDisabled: boolean = false
+): void {
+  for (const item of items) {
+    if (Array.isArray(item)) {
+      // Handle nested arrays (like in GLOBAL_MENU_ITEMS)
+      collectDisabledPaths(item, disabledPaths, parentDisabled)
+    } else {
+      const isCurrentDisabled = parentDisabled || item.enabled === false
+      const itemUrl = item.url || item.href
+
+      if (itemUrl && itemUrl.startsWith('/guides/')) {
+        const normalizedUrl = normalizeUrl(itemUrl)
+        if (isCurrentDisabled) {
+          disabledPaths.add(normalizedUrl)
+        }
+      }
+
+      // Recursively check children, passing down the disabled status
+      if (item.items) {
+        collectDisabledPaths(item.items, disabledPaths, isCurrentDisabled)
+      }
+      if (item.menuItems) {
+        collectDisabledPaths(item.menuItems, disabledPaths, isCurrentDisabled)
+      }
+    }
+  }
+}
+
+/**
+ * Normalizes URLs for comparison by removing leading/trailing slashes and ensuring consistent format
+ */
+function normalizeUrl(url: string): string {
+  return url.replace(/^\/+|\/+$/g, '').toLowerCase()
+}
+
+/**
+ * Creates and caches the set of all disabled guide paths.
+ * This is computed once and reused across all checks.
+ */
+let cachedDisabledPaths: Set<string> | null = null
+
+function getDisabledGuidePaths(): Set<string> {
+  if (cachedDisabledPaths === null) {
+    cachedDisabledPaths = new Set<string>()
+
+    // Collect disabled paths from global menu items
+    collectDisabledPaths(GLOBAL_MENU_ITEMS, cachedDisabledPaths)
+
+    // Collect disabled paths from section-specific navigation
+    Object.values(SECTION_NAV_MAPS).forEach((sectionNav) => {
+      if (sectionNav.items) {
+        collectDisabledPaths([sectionNav], cachedDisabledPaths!)
+      }
+    })
+  }
+
+  return cachedDisabledPaths
+}
+
+/**
+ * Checks if a guides page is enabled based on the navigation menu configuration
+ *
+ * @param guidesPath - The path to the guides page (e.g., "/guides/auth/users")
+ * @returns true if enabled, false if disabled
+ */
+export function checkGuidePageEnabled(guidesPath: string): boolean {
+  const disabledPaths = getDisabledGuidePaths()
+  const normalizedPath = normalizeUrl(guidesPath)
+  return !disabledPaths.has(normalizedPath)
+}
diff --git a/apps/docs/middleware.ts b/apps/docs/middleware.ts
index cdc560edfc6ae..919802bbdf57b 100644
--- a/apps/docs/middleware.ts
+++ b/apps/docs/middleware.ts
@@ -1,5 +1,6 @@
 import { isbot } from 'isbot'
 import { type NextRequest, NextResponse } from 'next/server'
+
 import { clientSdkIds } from '~/content/navigation.references'
 import { BASE_PATH } from '~/lib/constants'
 
diff --git a/apps/docs/resources/guide/guideModelLoader.ts b/apps/docs/resources/guide/guideModelLoader.ts
index 4ba9674de1ef3..5af209f9f3824 100644
--- a/apps/docs/resources/guide/guideModelLoader.ts
+++ b/apps/docs/resources/guide/guideModelLoader.ts
@@ -1,9 +1,10 @@
 import matter from 'gray-matter'
 import { promises as fs } from 'node:fs'
-import { join, relative } from 'node:path'
+import { join, relative, resolve } from 'node:path'
 
 import { extractMessageFromAnyError, FileNotFoundError, MultiError } from '~/app/api/utils'
 import { preprocessMdxWithDefaults } from '~/features/directives/utils'
+import { checkGuidePageEnabled } from '~/features/docs/NavigationPageStatus.utils'
 import { Both, Result } from '~/features/helpers.fn'
 import { GUIDES_DIRECTORY } from '~/lib/docs'
 import { processMdx } from '~/scripts/helpers.mdx'
@@ -19,6 +20,24 @@ function isHiddenFile(path: string): boolean {
   return path.split('/').some((part) => part.startsWith('_'))
 }
 
+/**
+ * Determines if a guide file is disabled in the navigation configuration.
+ *
+ * @param relPath - Relative path to the .mdx file within the base directory
+ * @param baseDir - Base directory to calculate relPath from
+ * @returns true if the page is disabled, false if enabled
+ */
+function isDisabledGuide(relPath: string, baseDir: string): boolean {
+  const fullPath = resolve(baseDir, relPath)
+  if (!fullPath.startsWith(GUIDES_DIRECTORY)) return false
+
+  const relGuidePath = relative(GUIDES_DIRECTORY, fullPath)
+  const urlPath = relGuidePath.replace(/\.mdx?$/, '').replace(/\/index$/, '')
+  const guidesPath = `/guides/${urlPath}`
+
+  return !checkGuidePageEnabled(guidesPath)
+}
+
 /**
  * Recursively walks a directory and collects all .mdx files that are not hidden.
  */
@@ -40,7 +59,10 @@ async function walkMdxFiles(
           continue
         }
 
-        // Only include .mdx files
+        if (isDisabledGuide(relativePath, dir)) {
+          continue
+        }
+
         if (relativePath.endsWith('.mdx')) {
           mdxFiles.push(join(dir, relativePath))
         }
diff --git a/apps/docs/spec/common-cli-sections.json b/apps/docs/spec/common-cli-sections.json
index a9510186f8d56..1f658681d3d6a 100644
--- a/apps/docs/spec/common-cli-sections.json
+++ b/apps/docs/spec/common-cli-sections.json
@@ -95,12 +95,6 @@
         "slug": "supabase-gen",
         "type": "cli-command"
       },
-      {
-        "id": "supabase-gen-keys",
-        "title": "Generate keys (Preview branch)",
-        "slug": "supabase-gen-keys",
-        "type": "cli-command"
-      },
       {
         "id": "supabase-gen-signing-key",
         "title": "Generate a JWT signing key",
@@ -481,6 +475,18 @@
         "slug": "supabase-branches-update",
         "type": "cli-command"
       },
+      {
+        "id": "supabase-branches-pause",
+        "title": "Pause a preview branch",
+        "slug": "supabase-branches-pause",
+        "type": "cli-command"
+      },
+      {
+        "id": "supabase-branches-unpause",
+        "title": "Unpause a preview branch",
+        "slug": "supabase-branches-unpause",
+        "type": "cli-command"
+      },
       {
         "id": "supabase-branches-delete",
         "title": "Delete a preview branch",
@@ -609,30 +615,6 @@
       }
     ]
   },
-  {
-    "type": "category",
-    "title": "Encryption",
-    "items": [
-      {
-        "id": "supabase-encryption",
-        "title": "Manage encryption keys",
-        "slug": "supabase-encryption",
-        "type": "cli-command"
-      },
-      {
-        "id": "supabase-encryption-get-root-key",
-        "title": "Retrieve the root encryption key",
-        "slug": "supabase-encryption-get-root-key",
-        "type": "cli-command"
-      },
-      {
-        "id": "supabase-encryption-update-root-key",
-        "title": "Update root encryption key",
-        "slug": "supabase-encryption-update-root-key",
-        "type": "cli-command"
-      }
-    ]
-  },
   {
     "type": "category",
     "title": "Authentication",
diff --git a/apps/studio/components/interfaces/Linter/Linter.utils.tsx b/apps/studio/components/interfaces/Linter/Linter.utils.tsx
index a74ba2b547366..8aed1dac9868e 100644
--- a/apps/studio/components/interfaces/Linter/Linter.utils.tsx
+++ b/apps/studio/components/interfaces/Linter/Linter.utils.tsx
@@ -300,6 +300,15 @@ export const lintInfoMap: LintInfo[] = [
     docsLink: 'https://supabase.com/docs/guides/auth/auth-mfa',
     category: 'security',
   },
+  {
+    name: 'vulnerable_postgres_version',
+    title: 'Postgres version has security patches available',
+    icon: <LockIcon className="text-foreground-muted" size={15} strokeWidth={1} />,
+    link: ({ projectRef }) => `/project/${projectRef}/settings/infrastructure`,
+    linkText: 'View settings',
+    docsLink: 'https://supabase.com/docs/guides/platform/upgrading',
+    category: 'security',
+  },
 ]
 
 export const LintCTA = ({
diff --git a/packages/api-types/types/api.d.ts b/packages/api-types/types/api.d.ts
index a74db70f9e537..b4fbd0d06454c 100644
--- a/packages/api-types/types/api.d.ts
+++ b/packages/api-types/types/api.d.ts
@@ -3692,6 +3692,7 @@ export interface components {
           | 'auth_password_policy_missing'
           | 'leaked_service_key'
           | 'no_backup_admin'
+          | 'vulnerable_postgres_version'
         remediation: string
         title: string
       }[]
diff --git a/supa-mdx-lint/Rule003Spelling.toml b/supa-mdx-lint/Rule003Spelling.toml
index 6234bbea74abd..925d4abe8dc36 100644
--- a/supa-mdx-lint/Rule003Spelling.toml
+++ b/supa-mdx-lint/Rule003Spelling.toml
@@ -56,11 +56,14 @@ allow_list = [
     "[Ff]atals",
     "[Ff]rontend",
     "[Gg]apless",
+    "[Gg]eolocation",
     "[Gg]lobs?",
     "[Gg]lobstar",
+    "[Gg]rayscale",
     "[Gg]zip(s|ped|ping)?",
     "[Hh]r",
     "[Hh]ypertables?",
+    "[Ii]dempotency",
     "[KMG]bps",
     "[KMG]iB",
     "[Ll]iveness",
@@ -156,6 +159,7 @@ allow_list = [
     "Entra",
     "ePHI",
     "Erlang",
+    "ESZip",
     "Ethereum",
     "Figma",
     "Firestore",