diff --git a/docs/develop/java/activities/standalone-activities.mdx b/docs/develop/java/activities/standalone-activities.mdx
index 24d316b4f8..e2341df20f 100644
--- a/docs/develop/java/activities/standalone-activities.mdx
+++ b/docs/develop/java/activities/standalone-activities.mdx
@@ -15,6 +15,7 @@ import { ReleaseNoteHeader } from '@site/src/components';
 
 <ReleaseNoteHeader
   featureName="standaloneActivity"
+  language="Java"
 />
 
 [Standalone Activities](/standalone-activity) are Activities that run independently, without being orchestrated by a
diff --git a/docs/develop/typescript/best-practices/data-handling/external-storage.mdx b/docs/develop/typescript/best-practices/data-handling/external-storage.mdx
index fda6df5e20..d4aefe8ebd 100644
--- a/docs/develop/typescript/best-practices/data-handling/external-storage.mdx
+++ b/docs/develop/typescript/best-practices/data-handling/external-storage.mdx
@@ -12,7 +12,7 @@ description: Offload large payloads to external storage using the claim check pa
 
 import { ReleaseNoteHeader } from '@site/src/components';
 
-<ReleaseNoteHeader type="prerelease">
+<ReleaseNoteHeader featureName="externalStorage">
   APIs and configuration may change before General Availability. Join the
   [#large-payloads Slack channel](https://temporalio.slack.com/archives/C09VA2DE15Y) to provide feedback or ask for
   help.
diff --git a/docs/evaluate/development-production-features/release-stages.mdx b/docs/evaluate/development-production-features/release-stages.mdx
index d4a112cb0f..08b2c94227 100644
--- a/docs/evaluate/development-production-features/release-stages.mdx
+++ b/docs/evaluate/development-production-features/release-stages.mdx
@@ -8,6 +8,8 @@ tags:
 - Temporal
 ---
 
+import { FeatureStageTable } from '@site/src/components';
+
 :::tip CHANGELOG
 To stay up-to-date with the latest feature changes, visit the [changelog](https://temporal.io/change-log).
 :::
@@ -27,6 +29,8 @@ Product Release Guide Expectations:
 | **Feature Cloud pricing**       | No additional cost.                                                | Pricing changes are kept to a minimum.                                                      | Pricing is stable.                               |
 | **Feature Interoperability**    | Limited.                                                           | Features are compatible with each other, unless otherwise stated.                           | Features are compatible with each other.         |
 
+<FeatureStageTable />
+
 ## Pre-release {/* #pre-release */}
 
 **Access:** Most Pre-release features are released in the open source Temporal software and are publicly available.
diff --git a/readme/COMPONENTS.md b/readme/COMPONENTS.md
index 4fb41058e4..436438bfdb 100644
--- a/readme/COMPONENTS.md
+++ b/readme/COMPONENTS.md
@@ -27,6 +27,8 @@ Whether you’re using core components or experimenting with new ones, this guid
 - [Using SdkGuideLinks](#using-sdkguidelinks)
 - [Using AnnotatedCode](#using-annotatedcode)
 - [Using ReleaseNoteHeader](#using-release-note-header)
+- [Using FeatureStageLabel](#using-featurestagelabel)
+- [Using FeatureStageTable](#using-featurestagetable)
 
 ## Finding Components
 
@@ -521,9 +523,22 @@ Role: To provide a consistent component for adding, updating, and removing relea
 
 Usage:
 
-In `/src/constants`, update the [`featureReleaseTypes.js`](../src/constants/featureReleaseTypes.js) file to include the release stage for the feature you want.
+In `/src/constants`, update the [`featureReleaseTypes.js`](../src/constants/featureReleaseTypes.js) file to include the feature you want, its stage, and its display metadata (used by the `FeatureStageTable` on the [release stages page](../docs/evaluate/development-production-features/release-stages.mdx)).
 
-Example: `serverlessWorkers: "prerelease"`
+```js
+serverlessWorkers: {
+  stage: "prerelease",
+  name: "Serverless Workers",
+  description: "Run a Temporal Worker as a serverless function invoked by Temporal Cloud.",
+  infoLink: "/serverless-workers",
+  // Optional — only add this when a feature's stage genuinely differs by SDK
+  // language. Keys must match ReleaseNoteHeader's SDK language vocabulary
+  // (".NET" | "Go" | "Java" | "PHP" | "Python" | "Ruby" | "Rust" | "TypeScript").
+  languageOverrides: {
+    Java: "publicPreview",
+  },
+},
+```
 
 Then on the pages you want it to show, add this to the top of the content, right below the frontmatter. The `featureName` prop is how you share the release stages you add to `featureReleaseTypes.js` across pages.
 
@@ -569,4 +584,42 @@ Use the `href` prop to make the `children` content a link.
 >
   Sign up for updates to be notified when Serverless Workers reach Public Preview.
 </ReleaseNoteHeader>
-```
\ No newline at end of file
+```
+
+If a feature's `languageOverrides` includes the SDK this page is about, add the `language` prop so the badge resolves to that language's stage instead of the feature's default.
+```js
+<ReleaseNoteHeader
+  featureName="serverlessWorkers"
+  language="Java"
+/>
+```
+
+## Using FeatureStageLabel
+
+Role: The inline sibling of `ReleaseNoteHeader`, for mentioning a feature's stage mid-sentence in prose instead of as a page-level banner. Sourced from the same [`featureReleaseTypes.js`](../src/constants/featureReleaseTypes.js) registry, so these mentions can't drift out of sync with the banner the way a hand-written `[Public Preview](/evaluate/development-production-features/release-stages#public-preview)` link can.
+
+Usage:
+
+```js
+import { FeatureStageLabel } from '@site/src/components';
+
+The Rust SDK is in <FeatureStageLabel featureName="rustSdk" />, and its API can change between releases.
+```
+
+Accepts the same `featureName`, `language`, and `type` props as `ReleaseNoteHeader`, resolved the same way. Renders a plain prose link — no pill/badge styling — since it's meant to sit inline in a sentence.
+
+## Using FeatureStageTable
+
+Role: Renders every feature currently in `featureReleaseTypes.js`, grouped by stage, as a Markdown-style table. Used on the [release stages page](../docs/evaluate/development-production-features/release-stages.mdx) to give a single, always-current view of what's non-GA — no separate list to hand-maintain.
+
+Usage:
+
+```js
+import { FeatureStageTable } from '@site/src/components';
+
+<FeatureStageTable />
+```
+
+Takes no props — it reads `featureReleaseTypes.js` directly, so a feature appears here automatically once it has a registry entry with `name`, `description`, and `infoLink`. Each stage section (Pre-release, Public Preview) is its own table with two columns, Feature and Details — there's no separate Stage column, since the section heading already says it. The Details cell is the feature's `description`; a feature with a `languageOverrides` entry gets a bolded note appended (e.g. "…without a Workflow orchestrating it. **Note:** Java support is in Pre-release.") instead of a separate row per language.
+
+Write `description` as its own brief, feature-specific summary — what the feature actually does, in one sentence — rather than reusing the target page's meta `description` verbatim. A page's meta description is written for the whole page and SEO, so it's often too broad (e.g. a general SDK setup page) or too generic ("Learn how...") for a table row about one specific feature.
\ No newline at end of file
diff --git a/readme/COMPONENT_REGISTRY.md b/readme/COMPONENT_REGISTRY.md
index 57c55de5ba..ca3d0c0b43 100644
--- a/readme/COMPONENT_REGISTRY.md
+++ b/readme/COMPONENT_REGISTRY.md
@@ -2,13 +2,13 @@
 
 Generated by `scripts/audit-components.mjs`. Run to update.
 
-**Coverage: 43/51 (84%)**
+**Coverage: 44/52 (85%)**
 
 | Component | File Count | Strategy | Covered |
 |-----------|------------|----------|---------|
+| `ReleaseNoteHeader` | 84 | `release-note-header` | ✅ |
 | `TabItem` | 84 | `tabitem` | ✅ |
 | `Tabs` | 83 | `tabs` | ✅ |
-| `ReleaseNoteHeader` | 76 | `release-note-header` | ✅ |
 | `NoZoom` | 60 | `UNKNOWN` | ❌ |
 | `RelatedReadContainer` | 23 | `related-read-container` | ✅ |
 | `RelatedReadItem` | 20 | `related-read-item` | ✅ |
@@ -44,6 +44,7 @@ Generated by `scripts/audit-components.mjs`. Run to update.
 | `CallerWorkflow` | 1 | `UNKNOWN` | ❌ |
 | `SdkOverviewCards` | 1 | `sdk-overview-cards` | ✅ |
 | `TemporalLifecycleDemo` | 1 | `UNKNOWN` | ❌ |
+| `FeatureStageTable` | 1 | `feature-stage-table` | ✅ |
 | `CloudRegionCount` | 1 | `strip-block` | ✅ |
 | `GuidesGrid` | 1 | `UNKNOWN` | ❌ |
 | `HeroWrapper` | 1 | `strip-tag` | ✅ |
diff --git a/readme/MARKDOWN_PIPELINE.md b/readme/MARKDOWN_PIPELINE.md
index a78c9925fc..01eee1b839 100644
--- a/readme/MARKDOWN_PIPELINE.md
+++ b/readme/MARKDOWN_PIPELINE.md
@@ -130,6 +130,8 @@ Each component maps to a strategy in `COMPONENT_REGISTRY` (in `scripts/mdx-to-md
 | YouTube/`<iframe>` embeds (often in a styled `<div>`) | strip | Removed; keep a markdown Watch link in surrounding tip/prose for LLMs |
 | `CallToAction` | `call-to-action` | `- [h3 title](href): p description` |
 | `ReleaseNoteHeader` | `release-note-header` | `> **Public Preview** — Go, Java…` availability note + body blockquote. The self-closing form (`<ReleaseNoteHeader … />`) emits just the note and leaves the page body intact. |
+| `FeatureStageLabel` | `inline-feature-stage-label` | Inline: replaced with `[Public Preview](…#public-preview)` (or Pre-release), resolved from `featureReleaseTypes.js` the same way as `ReleaseNoteHeader` |
+| `FeatureStageTable` | `feature-stage-table` | Two Markdown tables (Pre-release, then Public Preview) listing every registered feature, resolved from `featureReleaseTypes.js` |
 | `RelatedReadContainer` / `RelatedReadItem` | `related-read-container` / `related-read-item` | `**Related:**` Markdown link list |
 | `RelatedReadList` | `related-read` | Link list from the `readList` prop |
 | `ToolTipTerm` | `tooltip-term` | Inline: replaced with the bare `term` text |
diff --git a/scripts/component-handlers/feature-stage-table.mjs b/scripts/component-handlers/feature-stage-table.mjs
new file mode 100644
index 0000000000..71c3078d5a
--- /dev/null
+++ b/scripts/component-handlers/feature-stage-table.mjs
@@ -0,0 +1,59 @@
+/**
+ * component-handlers/feature-stage-table.mjs
+ *
+ * Handler for <FeatureStageTable /> (self-closing, no props).
+ * Component: src/components/elements/Tables/FeatureStageTable.js
+ *
+ * Renders the current FEATURE_RELEASE_TYPES registry as Markdown tables, one
+ * per stage (Pre-release, then Public Preview), matching the React
+ * component's grouping and Notes-column behavior for language overrides.
+ */
+
+// Language-override note, e.g. "**Note:** Java support is in Pre-release." The
+// stage itself isn't repeated here — the section heading already says it.
+function noteFor(entry, stageLabels) {
+  if (!entry.languageOverrides) return "";
+  const clauses = Object.entries(entry.languageOverrides).map(
+    ([lang, stage]) => `${lang} support is in ${stageLabels[stage].label}`
+  );
+  return `**Note:** ${clauses.join("; ")}.`;
+}
+
+function detailsFor(entry, stageLabels) {
+  const note = noteFor(entry, stageLabels);
+  return note ? `${entry.description} ${note}` : entry.description;
+}
+
+/**
+ * @param {object} featureReleaseTypes FEATURE_RELEASE_TYPES from featureReleaseTypes.js
+ * @param {object} stageLabels STAGE_LABELS from featureReleaseTypes.js
+ * @returns {string}
+ */
+export function featureStageTableToMarkdown(featureReleaseTypes, stageLabels) {
+  const stageOrder = ["prerelease", "publicPreview"];
+  const headingByStage = {
+    prerelease: "### Pre-release features",
+    publicPreview: "### Public Preview features",
+  };
+
+  const sections = stageOrder
+    .map((stage) => {
+      const entries = Object.values(featureReleaseTypes).filter((entry) => entry.stage === stage);
+      if (entries.length === 0) return null;
+
+      const rows = entries.map(
+        (entry) => `| [${entry.name}](${entry.infoLink}) | ${detailsFor(entry, stageLabels)} |`
+      );
+
+      return [
+        headingByStage[stage],
+        "",
+        "| Feature | Details |",
+        "| --- | --- |",
+        ...rows,
+      ].join("\n");
+    })
+    .filter(Boolean);
+
+  return sections.join("\n\n");
+}
diff --git a/scripts/mdx-to-md.mjs b/scripts/mdx-to-md.mjs
index 0b26c21402..2e3b7157a5 100644
--- a/scripts/mdx-to-md.mjs
+++ b/scripts/mdx-to-md.mjs
@@ -15,6 +15,8 @@
  *   - <CodeSnippet language="x">  → fenced code block
  *   - <CallToAction href>         → markdown link (h3 title + p description)
  *   - <ReleaseNoteHeader>         → availability blockquote + body
+ *   - <FeatureStageLabel />       → inline `[Public Preview](...)` link
+ *   - <FeatureStageTable />       → Markdown tables resolved from FEATURE_RELEASE_TYPES
  *   - <RelatedReadContainer>      → markdown link list from <RelatedReadItem>s
  *   - <RelatedReadList>           → markdown link list from readList prop
  *   - <SdkGuideLinks>             → markdown link list, one per SDK (path/filter/title or links prop)
@@ -39,7 +41,8 @@ import { cookbookPreviewToMarkdown } from "./component-handlers/cookbook-preview
 import { heroCardToMarkdown, heroHeadlineToMarkdown } from "./component-handlers/hero.mjs";
 import { parseCardItems, cardsToMarkdown } from "./component-handlers/cards.mjs";
 import { sdkOverviewCardsToMarkdown } from "./component-handlers/sdk-overview-cards.mjs";
-import { FEATURE_RELEASE_TYPES } from "../src/constants/featureReleaseTypes.js";
+import { featureStageTableToMarkdown } from "./component-handlers/feature-stage-table.mjs";
+import { FEATURE_RELEASE_TYPES, STAGE_LABELS, resolveFeatureStage } from "../src/constants/featureReleaseTypes.js";
 import { readFileSync, existsSync } from "fs";
 import { join } from "path";
 
@@ -75,6 +78,8 @@ export const COMPONENT_REGISTRY = {
   CookbookPreview: "cookbook-preview",
   SdkOverviewCards: "sdk-overview-cards",
   ViewSourceCodeNotice: "view-source-code-notice",
+  FeatureStageLabel: "inline-feature-stage-label",
+  FeatureStageTable: "feature-stage-table",
 
   // Homepage hero (docs/index.mdx). Copy is authored in the MDX and composed
   // from presentational components in src/components/elements/HomePageHero.js.
@@ -141,9 +146,9 @@ const RELEASE_NOTE_LABELS = {
   deprecated: "Deprecated",
 };
 
-/** Mirrors ReleaseNoteHeader.getResolvedType — featureName lookup, then type, then default. */
-function resolveReleaseNoteType(featureName, type) {
-  return FEATURE_RELEASE_TYPES[featureName] || type || "publicPreview";
+/** Thin call-through to the shared resolver in featureReleaseTypes.js. */
+function resolveReleaseNoteType(featureName, type, language) {
+  return resolveFeatureStage(featureName, { type, language });
 }
 
 function releaseNoteLabelFromType(resolvedType) {
@@ -358,6 +363,16 @@ export function applyInlineTransforms(line) {
     (m, inner) => extractProp(m, "term") || inner
   );
 
+  // Inline <FeatureStageLabel featureName="x" /> → [Public Preview](descriptionLink)
+  out = out.replace(/<FeatureStageLabel\b[^>]*\/>/g, (m) => {
+    const featureName = extractProp(m, "featureName") || "";
+    const language = extractProp(m, "language");
+    const type = extractProp(m, "type");
+    const stage = resolveFeatureStage(featureName, { type, language });
+    const meta = STAGE_LABELS[stage] || STAGE_LABELS.publicPreview;
+    return `[${meta.label}](${meta.descriptionLink})`;
+  });
+
   // Collapse a line left whitespace-only (e.g. after a comment was stripped)
   // to a true blank line — an indented blank could otherwise read as code.
   if (/^\s+$/.test(out)) return "";
@@ -1109,8 +1124,9 @@ export function transformMdx(mdxContent, options = {}) {
       }
       const featureName = extractProp(tag, "featureName") || "";
       const type = extractProp(tag, "type");
+      const language = extractProp(tag, "language");
       const labelOverride = extractProp(tag, "label");
-      const resolvedType = resolveReleaseNoteType(featureName, type);
+      const resolvedType = resolveReleaseNoteType(featureName, type, language);
       releaseNoteLabel = labelOverride || releaseNoteLabelFromType(resolvedType);
       const langsMatch = tag.match(/languages=\{(\[[^\]]*\])\}/);
       if (langsMatch) {
@@ -1310,6 +1326,18 @@ export function transformMdx(mdxContent, options = {}) {
       continue;
     }
 
+    // --- FeatureStageTable (self-closing, no props) → resolved Markdown tables ---
+    if (state === State.NORMAL && /^\s*<FeatureStageTable\b/.test(line)) {
+      let tag = line;
+      while (!/\/?>/.test(tag) && i + 1 < lines.length) {
+        i++;
+        tag += " " + lines[i].trim();
+      }
+      outputLines.push(featureStageTableToMarkdown(FEATURE_RELEASE_TYPES, STAGE_LABELS));
+      outputLines.push("");
+      continue;
+    }
+
     // --- QuickstartCards / PatternCards / GridCardList → Markdown link list from items prop ---
     if (state === State.NORMAL && /^\s*<(QuickstartCards|PatternCards|GridCardList)\b/.test(line)) {
       let tag = line;
diff --git a/src/components/elements/FeatureStageLabel/FeatureStageLabel.js b/src/components/elements/FeatureStageLabel/FeatureStageLabel.js
new file mode 100644
index 0000000000..bedaf533de
--- /dev/null
+++ b/src/components/elements/FeatureStageLabel/FeatureStageLabel.js
@@ -0,0 +1,14 @@
+import React from "react";
+import Link from "@docusaurus/Link";
+import { resolveFeatureStage, STAGE_LABELS } from "../../../constants/featureReleaseTypes";
+
+// Inline sibling of ReleaseNoteHeader for mid-sentence prose, e.g.
+// "The Rust SDK is in <FeatureStageLabel featureName="..." />." Renders a
+// plain prose link — no pill/badge styling — sourced from the same registry
+// so these mentions can't drift the way hand-written links have.
+export default function FeatureStageLabel({ featureName, language, type }) {
+  const resolvedType = resolveFeatureStage(featureName, { type, language });
+  const meta = STAGE_LABELS[resolvedType] || STAGE_LABELS.publicPreview;
+
+  return <Link to={meta.descriptionLink}>{meta.label}</Link>;
+}
diff --git a/src/components/elements/FeatureStageLabel/index.js b/src/components/elements/FeatureStageLabel/index.js
new file mode 100644
index 0000000000..1a25d762cc
--- /dev/null
+++ b/src/components/elements/FeatureStageLabel/index.js
@@ -0,0 +1 @@
+export { default as FeatureStageLabel } from './FeatureStageLabel'
diff --git a/src/components/elements/ReleaseNoteHeader/ReleaseNoteHeader.js b/src/components/elements/ReleaseNoteHeader/ReleaseNoteHeader.js
index d857de4ed5..8608dae878 100644
--- a/src/components/elements/ReleaseNoteHeader/ReleaseNoteHeader.js
+++ b/src/components/elements/ReleaseNoteHeader/ReleaseNoteHeader.js
@@ -4,19 +4,17 @@ import React from "react";
 import Link from "@docusaurus/Link";
 import SdkSvg from '../SdkSvgs/SdkSvg';
 import styles from "./ReleaseNoteHeader.module.css";
-import { FEATURE_RELEASE_TYPES } from "../../../constants/featureReleaseTypes";
+import { resolveFeatureStage, STAGE_LABELS } from "../../../constants/featureReleaseTypes";
 
 export const BASE_RELEASE_STAGES = {
   prerelease: {
-    label: "Pre-release",
-    descriptionLink: "/evaluate/development-production-features/release-stages#pre-release",
+    ...STAGE_LABELS.prerelease,
     backgroundColor: "var(--release-prerelease-bg)",
     borderColor: "var(--release-prerelease-border)",
     textColor: "var(--release-prerelease-text)",
   },
   publicPreview: {
-    label: "Public Preview",
-    descriptionLink: "/evaluate/development-production-features/release-stages#public-preview",
+    ...STAGE_LABELS.publicPreview,
     backgroundColor: "var(--release-public-preview-bg)",
     borderColor: "var(--release-public-preview-border)",
     textColor: "var(--release-public-preview-text)",
@@ -45,8 +43,8 @@ const LANGUAGE_TO_SDK_SLUG = {
   "TypeScript": "typescript",
 }
 
-function getResolvedType({ featureName, type }) {
-  return FEATURE_RELEASE_TYPES[featureName] || type || "publicPreview";
+function getResolvedType({ featureName, type, language }) {
+  return resolveFeatureStage(featureName, { type, language });
 }
 
 function getTheme(type, overrides = {}) {
@@ -63,6 +61,10 @@ export default function ReleaseNoteHeader({
   type = "publicPreview",
   // name of the feature being released
   featureName,
+  // If featureName has a languageOverrides entry for this language, it wins
+  // over the feature's default stage. Distinct from `languages` below, which
+  // only controls which SDK icons are rendered.
+  language,
   // If there is anything specific to say about the release, it can be passed as a child to the component. It can also be a link if href is provided.
   children = "APIs and configuration may change before the stable release.",
   // If child is a link, this is where the link can be passed.
@@ -74,7 +76,7 @@ export default function ReleaseNoteHeader({
   // If you want to override the default label for the release type, you can pass it here. This is useful for cases like "generalAvailability" where you might want to just say "Stable".
   label,
 }) {
-  const resolvedType = getResolvedType({ featureName, type });
+  const resolvedType = getResolvedType({ featureName, type, language });
   const theme = getTheme(resolvedType);
 
   const releaseLabel = label || theme.label;
@@ -91,7 +93,7 @@ export default function ReleaseNoteHeader({
       style={style}
       role="note"
       aria-label={releaseLabel}
-      data-release-type={type}
+      data-release-type={resolvedType}
     >
       <div className={styles.accent} aria-hidden="true" />
       <div className={styles.content}>
diff --git a/src/components/elements/Tables/FeatureStageTable.js b/src/components/elements/Tables/FeatureStageTable.js
new file mode 100644
index 0000000000..2c18a22771
--- /dev/null
+++ b/src/components/elements/Tables/FeatureStageTable.js
@@ -0,0 +1,51 @@
+import React from "react";
+import Link from "@docusaurus/Link";
+import { DocsTable, DocsTableRow, NewDocsCell } from '@site/src/components';
+import { FEATURE_RELEASE_TYPES, STAGE_LABELS } from "../../../constants/featureReleaseTypes";
+
+const STAGE_ORDER = ["prerelease", "publicPreview"];
+const HEADING_BY_STAGE = {
+  prerelease: "Pre-release features",
+  publicPreview: "Public Preview features",
+};
+
+// Language-override note, e.g. "Java support is in Pre-release." The stage
+// itself isn't repeated here — the section heading already says it.
+function languageOverrideNote(entry) {
+  if (!entry.languageOverrides) return null;
+  const clauses = Object.entries(entry.languageOverrides)
+    .map(([lang, stage]) => `${lang} support is in ${STAGE_LABELS[stage].label}`)
+    .join("; ");
+  return `${clauses}.`;
+}
+
+export default function FeatureStageTable() {
+  return (
+    <>
+      {STAGE_ORDER.map((stage) => {
+        const entries = Object.values(FEATURE_RELEASE_TYPES).filter((entry) => entry.stage === stage);
+        if (entries.length === 0) return null;
+
+        return (
+          <React.Fragment key={stage}>
+            <h3>{HEADING_BY_STAGE[stage]}</h3>
+            <DocsTable Columns={["Feature", "Details"]}>
+              {entries.map((entry) => {
+                const note = languageOverrideNote(entry);
+                return (
+                  <DocsTableRow key={entry.name}>
+                    <NewDocsCell><Link to={entry.infoLink}>{entry.name}</Link></NewDocsCell>
+                    <NewDocsCell>
+                      {entry.description}
+                      {note && <> <strong>Note:</strong> {note}</>}
+                    </NewDocsCell>
+                  </DocsTableRow>
+                );
+              })}
+            </DocsTable>
+          </React.Fragment>
+        );
+      })}
+    </>
+  );
+}
diff --git a/src/components/elements/Tables/index.js b/src/components/elements/Tables/index.js
index 66c8add24b..085415576b 100644
--- a/src/components/elements/Tables/index.js
+++ b/src/components/elements/Tables/index.js
@@ -1,3 +1,4 @@
 export * from './DocsTable'
+export { default as FeatureStageTable } from './FeatureStageTable'
 export { default as JsonTable } from './JsonTable'
 export { default as OperationsTable } from './OperationsTable'
\ No newline at end of file
diff --git a/src/components/elements/index.js b/src/components/elements/index.js
index 0ad882c123..41e5f5d045 100644
--- a/src/components/elements/index.js
+++ b/src/components/elements/index.js
@@ -1,3 +1,4 @@
+export * from './FeatureStageLabel'
 export * from './HomePageHero'
 export * from './Images'
 export * from './RelatedRead'
diff --git a/src/constants/featureReleaseTypes.js b/src/constants/featureReleaseTypes.js
index 3c0e0e6b9b..2bd746fb13 100644
--- a/src/constants/featureReleaseTypes.js
+++ b/src/constants/featureReleaseTypes.js
@@ -1,12 +1,83 @@
 // ⚠️ LLM MARKDOWN PIPELINE: also consumed by scripts/mdx-to-md.mjs for
-// ReleaseNoteHeader label resolution. Keep in sync when adding feature mappings.
+// ReleaseNoteHeader / FeatureStageLabel / FeatureStageTable resolution.
+// Keep in sync when adding feature mappings or language overrides.
+
+// Label + release-stages.mdx anchor for each stage. Shared by ReleaseNoteHeader,
+// FeatureStageLabel, and FeatureStageTable so the labels/links live in one place.
+export const STAGE_LABELS = {
+  prerelease: {
+    label: "Pre-release",
+    descriptionLink: "/evaluate/development-production-features/release-stages#pre-release",
+  },
+  publicPreview: {
+    label: "Public Preview",
+    descriptionLink: "/evaluate/development-production-features/release-stages#public-preview",
+  },
+};
+
 export const FEATURE_RELEASE_TYPES = {
-  cloudCli: "prerelease",
-  standaloneActivity: "publicPreview",
-  standaloneNexusOperation: "prerelease",
-  workflowStreams: "publicPreview",
-  serverlessWorkersLambda: "publicPreview",
-  serverlessWorkersCloudRun: "prerelease",
-  externalStorage: "publicPreview",
-  projects: "prerelease",
+  cloudCli: {
+    stage: "prerelease",
+    name: "Cloud CLI extension",
+    description: "Manage Temporal Cloud resources, like Namespaces and users, from the Temporal CLI.",
+    infoLink: "/cli/setup-cli",
+  },
+  standaloneActivity: {
+    stage: "publicPreview",
+    name: "Standalone Activities",
+    description: "Run an Activity directly from a Temporal Client without a Workflow orchestrating it.",
+    infoLink: "/standalone-activity",
+    // Overrides `stage` only when the caller passes a matching `language` prop.
+    // Keys must match ReleaseNoteHeader.js's LANGUAGE_TO_SDK_SVG vocabulary
+    // (".NET" | "Go" | "Java" | "PHP" | "Python" | "Ruby" | "Rust" | "TypeScript").
+    languageOverrides: {
+      Java: "prerelease",
+    },
+  },
+  standaloneNexusOperation: {
+    stage: "prerelease",
+    name: "Standalone Nexus Operations",
+    description: "Execute a top-level Nexus Operation directly from a Client, without a caller Workflow.",
+    infoLink: "/standalone-nexus-operation",
+  },
+  workflowStreams: {
+    stage: "publicPreview",
+    name: "Workflow Streams",
+    description: "Add a durable event channel to a Workflow so outside observers can follow its progress in real time.",
+    infoLink: "/workflow-streams",
+  },
+  serverlessWorkersLambda: {
+    stage: "publicPreview",
+    name: "Serverless Workers on AWS Lambda",
+    description: "Run a Temporal Worker as an AWS Lambda function that Temporal Cloud invokes when tasks arrive.",
+    infoLink: "/serverless-workers",
+  },
+  serverlessWorkersCloudRun: {
+    stage: "prerelease",
+    name: "Serverless Workers on GCP Cloud Run",
+    description: "Run a Temporal Worker as a GCP Cloud Run service that Temporal Cloud invokes when tasks arrive.",
+    infoLink: "/serverless-workers",
+  },
+  externalStorage: {
+    stage: "publicPreview",
+    name: "External Storage",
+    description: "Offload large payloads to external storage, like Amazon S3, using the claim check pattern.",
+    infoLink: "/external-storage",
+  },
+  projects: {
+    stage: "prerelease",
+    name: "Cloud Projects",
+    description: "Organize Temporal Cloud resources, like Namespaces and Nexus Endpoints, around your organizational structure.",
+    infoLink: "/cloud/projects",
+  },
 };
+
+/** featureName lookup (with an optional per-language override) wins, then `type`, then default. */
+export function resolveFeatureStage(featureName, { type, language } = {}) {
+  const entry = FEATURE_RELEASE_TYPES[featureName];
+  if (entry) {
+    const override = language && entry.languageOverrides && entry.languageOverrides[language];
+    return override || entry.stage;
+  }
+  return type || "publicPreview";
+}
diff --git a/src/constants/featureReleaseTypes.test.mjs b/src/constants/featureReleaseTypes.test.mjs
new file mode 100644
index 0000000000..26f1e8f3c0
--- /dev/null
+++ b/src/constants/featureReleaseTypes.test.mjs
@@ -0,0 +1,60 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { FEATURE_RELEASE_TYPES, resolveFeatureStage } from "./featureReleaseTypes.js";
+
+// Mirrors the language vocabulary in ReleaseNoteHeader.js's LANGUAGE_TO_SDK_SVG
+// (can't import it directly here — that file is JSX and pulls in React).
+const CANONICAL_LANGUAGES = [".NET", "Go", "Java", "PHP", "Python", "Ruby", "Rust", "TypeScript"];
+
+describe("resolveFeatureStage", () => {
+  it("returns the entry's base stage when there is no language override", () => {
+    assert.strictEqual(resolveFeatureStage("cloudCli"), "prerelease");
+  });
+
+  it("returns the language override when it matches", () => {
+    assert.strictEqual(
+      resolveFeatureStage("standaloneActivity", { language: "Java" }),
+      "prerelease"
+    );
+  });
+
+  it("falls through to the base stage when the language has no override", () => {
+    assert.strictEqual(
+      resolveFeatureStage("standaloneActivity", { language: "Go" }),
+      "publicPreview"
+    );
+  });
+
+  it("falls back to the `type` option for an unregistered featureName", () => {
+    assert.strictEqual(
+      resolveFeatureStage("notInTheRegistry", { type: "prerelease" }),
+      "prerelease"
+    );
+  });
+
+  it("defaults to publicPreview for an unregistered featureName with no `type`", () => {
+    assert.strictEqual(resolveFeatureStage("notInTheRegistry"), "publicPreview");
+  });
+});
+
+describe("FEATURE_RELEASE_TYPES data shape", () => {
+  it("every languageOverrides key is a canonical SDK language", () => {
+    for (const [featureName, entry] of Object.entries(FEATURE_RELEASE_TYPES)) {
+      if (!entry.languageOverrides) continue;
+      for (const lang of Object.keys(entry.languageOverrides)) {
+        assert.ok(
+          CANONICAL_LANGUAGES.includes(lang),
+          `${featureName}.languageOverrides has an unrecognized language key: "${lang}"`
+        );
+      }
+    }
+  });
+
+  it("every entry has the required display metadata", () => {
+    for (const [featureName, entry] of Object.entries(FEATURE_RELEASE_TYPES)) {
+      for (const field of ["stage", "name", "description", "infoLink"]) {
+        assert.ok(entry[field], `${featureName} is missing "${field}"`);
+      }
+    }
+  });
+});
diff --git a/tests/test-mdx-to-md.mjs b/tests/test-mdx-to-md.mjs
index 519f0708bc..a82a4b6f01 100644
--- a/tests/test-mdx-to-md.mjs
+++ b/tests/test-mdx-to-md.mjs
@@ -764,6 +764,60 @@ test("ReleaseNoteHeader featureName overrides explicit type when mapped", () =>
   assertContains(markdown, "> **Pre-release**");
 });
 
+test("ReleaseNoteHeader language override resolves the per-language stage", () => {
+  const input = `<ReleaseNoteHeader featureName="standaloneActivity" language="Java" />\n\nJava-specific content.`;
+  const { markdown } = transformMdx(input);
+  assertContains(markdown, "> **Pre-release**");
+  assertContains(markdown, "Java-specific content.");
+});
+
+test("ReleaseNoteHeader language with no override falls back to the feature's base stage", () => {
+  const input = `<ReleaseNoteHeader featureName="standaloneActivity" language="Go" />\n\nGo-specific content.`;
+  const { markdown } = transformMdx(input);
+  assertContains(markdown, "> **Public Preview**");
+});
+
+// ---------------------------------------------------------------------------
+// Unit tests: transformMdx — FeatureStageLabel
+// ---------------------------------------------------------------------------
+console.log("\n📦 transformMdx — FeatureStageLabel");
+
+test("FeatureStageLabel resolves an inline stage link from featureName", () => {
+  const input = `The Rust SDK is in <FeatureStageLabel featureName="serverlessWorkersCloudRun" />.`;
+  const { markdown } = transformMdx(input);
+  assertContains(
+    markdown,
+    "[Pre-release](/evaluate/development-production-features/release-stages#pre-release)"
+  );
+  assertNotContains(markdown, "FeatureStageLabel");
+});
+
+test("FeatureStageLabel resolves a language override inline", () => {
+  const input = `Java support for this feature is in <FeatureStageLabel featureName="standaloneActivity" language="Java" />.`;
+  const { markdown } = transformMdx(input);
+  assertContains(
+    markdown,
+    "[Pre-release](/evaluate/development-production-features/release-stages#pre-release)"
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Unit tests: transformMdx — FeatureStageTable
+// ---------------------------------------------------------------------------
+console.log("\n📦 transformMdx — FeatureStageTable");
+
+test("FeatureStageTable resolves both stage groups with a Details column and language-override note", () => {
+  const input = `<FeatureStageTable />`;
+  const { markdown } = transformMdx(input);
+  assertContains(markdown, "### Pre-release features");
+  assertContains(markdown, "### Public Preview features");
+  assertContains(markdown, "| Feature | Details |");
+  assertContains(markdown, "[Standalone Activities](/standalone-activity)");
+  assertContains(markdown, "**Note:** Java support is in Pre-release.");
+  assertNotContains(markdown, "| Stage |");
+  assertNotContains(markdown, "FeatureStageTable");
+});
+
 // ---------------------------------------------------------------------------
 // Unit tests: transformMdx — CallToAction
 // ---------------------------------------------------------------------------
@@ -1302,7 +1356,7 @@ test("all registry strategies are valid strings", () => {
     "captioned-image", "video", "photo-carousel", "code-snippet", "sdk-tabs", "tooltip-term",
     "release-note-header", "call-to-action", "setup-steps", "setup-step",
     "json-table", "integrations-grid", "cookbook-preview", "sdk-overview-cards", "hero-card", "hero-headline", "view-source-code-notice", "cards", "strip-tag", "strip-block", "details", "summary",
-    "sdk-guide-links",
+    "sdk-guide-links", "inline-feature-stage-label", "feature-stage-table",
   ];
   for (const [comp, strategy] of Object.entries(COMPONENT_REGISTRY)) {
     assert(