diff --git a/.gitignore b/.gitignore
index 023f513..1400a18 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,6 @@ node_modules
 # translation cache and temporary translation folder
 .json-autotranslate-cache
 src/data/locales/
+
+# generated method document exports
+specs/
diff --git a/README.md b/README.md
index 6e9ebca..dc7368b 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,41 @@
 ## Create a new APIOps project (CLI)
 
+Interactive scaffold:
+
 ```bash
 npm create apiops@latest
 ```
 
-This command runs the `create-apiops` initializer package and generates a starter APIOps project template in your current directory. This is useful for a scaffolded proces (with or without AI) to create or review requirements for new APIs or improve existing APIs. 
+Named project scaffold:
+
+```bash
+npm create apiops@latest report-conversion-apiops
+```
+
+Non-interactive scaffold:
+
+```bash
+npm create apiops@latest -- --name report-conversion-apiops --locale en --cycle api-productization-cycle --style REST --yes
+```
+
+When using `npm create`, pass initializer flags after the `--` separator. Flags before the separator are handled by npm itself and may not reach `create-apiops`.
+
+To inspect the initializer options without starting prompts:
+
+```bash
+npm create apiops@latest -- --help
+```
+
+Useful options:
+
+- `--name <name>` or the first positional argument sets the project directory and package name
+- `--locale <locale>` sets the default method locale, such as `en` or `fi`
+- `--cycle <cycle-id>` sets the APIOps cycle used for station labels, stakeholders, and recommended resources; default: `api-productization-cycle`
+- `--style <style>` sets the API style focus: `REST`, `Event`, `GraphQL`, or `"Not sure yet"`
+- `--yes` accepts defaults for omitted options and runs without prompts; use it in non-interactive shells when any prompt answer is omitted
+- `--no-install` skips dependency installation and starter canvas generation
+
+This command runs the `create-apiops` initializer package and generates a starter APIOps project template in your current directory. This is useful for a scaffolded process (with or without AI) to create or review requirements for new APIs or improve existing APIs.
 
 This scaffolded project uses the CLI and/or the method-engine library (useful for AI or applications) provided by the main package. They guide the design and development using the APIOps Cycles method and canvases. 
 
@@ -58,7 +89,8 @@ The `snippet-engine` export resolves canonical resource snippets, including loca
 The method also includes reusable stakeholder data:
 
 - `src/data/method/stakeholders.json` defines the shared stakeholder catalog
-- `src/data/method/station-stakeholders.json` maps each station to weighted stakeholder participation
+- `src/data/method/cycles.json` defines APIOps cycles that reuse canonical core station ids while providing cycle-specific station labels, descriptions, and recommended resources
+- `src/data/method/station-stakeholders.json` maps cycle ids to station-specific stakeholder participation and optional responsibilities
 - `src/data/method/<locale>/labels.stakeholders.json` stores localized stakeholder titles, descriptions, and involvement labels
 
 Stakeholder involvement uses three lightweight levels:
@@ -106,11 +138,37 @@ If you spot a problem in the documentation or have an idea for new content, open
 
 ### Editing or adding content
 
-The main method content files are located under `src/data/method/`. These base files (`lines.json`, `stations.json`, `resources.json`, `criteria.json`, `station-criteria.json`, `stakeholders.json`, and `station-stakeholders.json`) are not localized and live at the root of the folder. Textual values in them reference label keys. English labels are in `src/data/method/en`, and translations are provided in locale folders through `labels.lines.json`, `labels.stations.json`, `labels.resources.json`, `labels.criteria.json`, and `labels.stakeholders.json`.
+The main method content files are located under `src/data/method/`. These base files (`lines.json`, `cycles.json`, `stations.json`, `resources.json`, `criteria.json`, `station-criteria.json`, `stakeholders.json`, and `station-stakeholders.json`) are not localized and live at the root of the folder. Textual values in them reference label keys. English labels are in `src/data/method/en`, and translations are provided in locale folders through `labels.lines.json`, `labels.cycles.json`, `labels.stations.json`, `labels.resources.json`, `labels.criteria.json`, and `labels.stakeholders.json`.
 
 Some longer or more complex resources also use canonical snippet assets under `src/snippets/` linked from `resources.json`. Those snippets are now primarily structured JSON or YAML files, with Markdown kept only where a resource genuinely needs prose content.
 
-Each station links to specific entry criteria followed by the next core station's criteria as exit criteria. Stakeholder participation is modeled separately through `stakeholders.json`, `station-stakeholders.json`, and `labels.stakeholders.json`.
+Each station links to specific entry criteria followed by the next core station's criteria as exit criteria. Cycles in `cycles.json` reuse canonical station ids and can override the displayed station label, station description, and recommended resources for that cycle. The `api-*` station and criteria ids are legacy canonical identifiers, not user-facing semantic labels; use cycle labels and descriptions for capability, integration, automation, or API-specific wording. Stakeholder participation is modeled separately through `stakeholders.json`, cycle-scoped mappings in `station-stakeholders.json`, and `labels.stakeholders.json`.
+
+#### Canonical localization terms
+
+Use these terms consistently when editing or translating method labels. The English labels are the editorial master; other locales should express the same concept naturally rather than translating the English sentence literally.
+
+Localization principles:
+
+1. English is the canonical source.
+2. Translate concepts, not words.
+3. Generic method terminology uses Capability, Interface, Interface contract, Implementation style, Publishing, and Enablement.
+4. The API Productization Cycle intentionally remains API-specific.
+5. Resource names remain unchanged unless they are already officially localized.
+6. Prefer natural language over literal translation.
+
+| English | FI | DE | FR | PT |
+| --- | --- | --- | --- | --- |
+| Capability | Kyvykkyys | Capability | Capacité | Capacidade |
+| Interface | Rajapinta | Schnittstelle | Interface | Interface |
+| Interface contract | Rajapintasopimus | Schnittstellenvertrag | Contrat d'interface | Contrato de interface |
+| Consumer | Hyödyntäjä | Nutzer | Utilisateur | Utilizador |
+| Business value | Liiketoiminta-arvo | Geschäftswert | Valeur métier | Valor de negócio |
+| Business goals | Liiketoimintatavoitteet | Geschäftsziele | Objectifs métier | Objectivos de negócio |
+| Implementation style | Toteutustapa | Implementierungsstil | Mode de mise en œuvre | Estilo de implementação |
+| Publishing | Julkaisu | Veröffentlichung | Publication | Publicação |
+| Enablement | Käyttöönoton tuki | Enablement | Enablement | Enablement |
+| Readiness | Valmius | Bereitschaft | Préparation | Prontidão |
 
 #### Editing existing method pages
 
diff --git a/bin/method-cli.js b/bin/method-cli.js
index a34b73f..d9fb646 100644
--- a/bin/method-cli.js
+++ b/bin/method-cli.js
@@ -1,7 +1,802 @@
 #!/usr/bin/env node
-import { main } from "../packages/create-apiops/bin/method-cli.js";
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import readline from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import * as methodEngine from "../src/lib/method-engine.js";
 
-main().catch((error) => {
-  console.error(error instanceof Error ? error.message : error);
+const currentFilePath = fileURLToPath(import.meta.url);
+
+const STATION_SCRIPT_HINTS = {
+  "api-product-strategy": {
+    resources: "npm run method:resources:strategy",
+    canvases: "npm run method:canvases:new-api"
+  },
+  "api-design": {
+    resources: "npm run method -- resources --station api-design --style \"REST\"",
+    canvases: "npm run method -- generate-canvases --station api-design --style \"REST\" --output ./specs/canvases"
+  }
+};
+
+function printUsage() {
+  console.log(`Usage:
+  node ./bin/method-cli.js start [--cycle <cycle-id>] [--locale <locale>] [--default-locale <locale>] [--json] [--list] [--answers <yes,no,...>] [--next-action <resources|canvases|exit>]
+  node ./bin/method-cli.js resources --station <station-id> [--cycle <cycle-id>] [--locale <locale>] [--style <style>] [--json] [--list] [--step-actions <details,next,...>]
+  node ./bin/method-cli.js generate-canvases [--station <station-id> | --stations <ids> | --preset new-api] [--cycle <cycle-id>] [--locale <locale>] [--style <style>] [--output <dir>] [--force] [--json]
+
+Examples:
+  node ./bin/method-cli.js start --locale en
+  node ./bin/method-cli.js start --cycle api-productization-cycle --locale en
+  node ./bin/method-cli.js start --default-locale en
+  node ./bin/method-cli.js start --locale en --answers yes,no,yes --next-action resources
+  node ./bin/method-cli.js resources --station api-product-strategy --cycle api-productization-cycle --locale en
+  node ./bin/method-cli.js generate-canvases --preset new-api --cycle api-productization-cycle --style REST --output ./specs/canvases
+`);
+}
+
+function fail(message) {
+  console.error(message);
   process.exit(1);
-});
+}
+
+function parseArgs(argv) {
+  if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
+    return { command: "help", options: {} };
+  }
+
+  const [command, ...rest] = argv;
+  const options = {};
+
+  for (let index = 0; index < rest.length; index += 1) {
+    const current = rest[index];
+    if (!current.startsWith("--")) {
+      fail(`Unexpected argument: ${current}`);
+    }
+
+    const key = current.slice(2);
+    if (key === "json" || key === "force" || key === "list") {
+      options[key] = true;
+      continue;
+    }
+
+    const value = rest[index + 1];
+    if (!value || value.startsWith("--")) {
+      fail(`Missing value for --${key}`);
+    }
+
+    options[key] = value;
+    index += 1;
+  }
+
+  return { command, options };
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function runCommand(command, args, options = {}) {
+  return spawnSync(command, args, {
+    encoding: "utf8",
+    shell: false,
+    ...options
+  });
+}
+
+function getNextStepHints(stationId) {
+  const hints = STATION_SCRIPT_HINTS[stationId];
+  if (hints) {
+    return hints;
+  }
+
+  return {
+    resources: `npm run method -- resources --station ${stationId}`,
+    canvases: `npm run method -- generate-canvases --station ${stationId} --output ./specs/canvases`
+  };
+}
+
+function getCycleId(options = {}) {
+  return options.cycle || methodEngine.DEFAULT_CYCLE_ID;
+}
+
+function loadCanvasJson(filePath, canvasId, locale) {
+  if (fs.existsSync(filePath)) {
+    return readJson(filePath);
+  }
+  return methodEngine.buildCanvasTemplate(canvasId, locale);
+}
+
+function formatPaletteHelp() {
+  return Object.entries(methodEngine.getNoteColorPalette())
+    .map(([intent, color]) => `${intent}=${color}`)
+    .join(", ");
+}
+
+async function fillCanvasSectionsInteractive(stationId, step, locale, output, rl) {
+  const outPath = methodEngine.generateCanvasForStationResource(stationId, step.resourceId, locale, output);
+  const canvasJson = loadCanvasJson(outPath, step.canvasId, locale);
+  const canvasMetadata = methodEngine.buildCanvasMetadata(step.canvasId, locale);
+  const starterFileName = path.basename(outPath);
+  const suggestedFileSlug = starterFileName.endsWith(".empty.json")
+    ? step.resourceId
+    : starterFileName.replace(/\.json$/i, "");
+  const requestedFileSlug = await rl.question(`Save filled canvas as file name (${suggestedFileSlug}): `);
+  const finalFileSlug = methodEngine.sanitizeFileSlug(requestedFileSlug, suggestedFileSlug);
+  const finalPath = path.join(path.dirname(outPath), `${finalFileSlug}.json`);
+
+  console.log("");
+  console.log(`Filling ${canvasMetadata.title} section by section.`);
+  console.log("Use `|` to create multiple notes in one section. Leave blank to keep existing notes. Type !clear to remove notes in a section.\n");
+  console.log("Prefix any note with `[benefit]`, `[neutral]`, `[negative]`, `[task]`, `[default]`, or `[color=#RRGGBB]` to set its color explicitly.");
+  console.log(`Palette: ${formatPaletteHelp()}\n`);
+
+  for (const section of canvasMetadata.sections) {
+    const existingSection = canvasJson.sections.find((entry) => entry.sectionId === section.id);
+    const existingNotes = existingSection?.stickyNotes || [];
+    console.log(`${section.title}`);
+    console.log(section.description);
+    console.log(`Default note color here: ${section.defaultNoteIntent} (${section.defaultNoteColor})`);
+    if (existingNotes.length > 0) {
+      console.log(`Current notes: ${existingNotes.map((note) => `${note.content} (${note.color})`).join(" | ")}`);
+    }
+
+    const answer = (await rl.question("Notes: ")).trim();
+    if (!answer) {
+      console.log("");
+      continue;
+    }
+
+    if (answer === "!clear") {
+      existingSection.stickyNotes = [];
+      console.log("");
+      continue;
+    }
+
+    const notes = answer
+      .split("|")
+      .map((entry) => entry.trim())
+      .filter(Boolean)
+      .map((content) => methodEngine.parseStickyNoteInput(content, {
+        canvasId: step.canvasId,
+        sectionId: section.id,
+        defaultIntent: section.defaultNoteIntent
+      }));
+
+    existingSection.stickyNotes = notes;
+    console.log("");
+  }
+
+  fs.writeFileSync(finalPath, `${JSON.stringify(canvasJson, null, 2)}\n`);
+  return finalPath;
+}
+
+function resolveCanvasExportCommand() {
+  const packageRoot = path.resolve(process.cwd(), "node_modules", "canvascreator");
+  if (!fs.existsSync(packageRoot)) {
+    return {
+      ok: false,
+      reason: "SVG export requires CanvasCreator export support, which is not installed in this project.",
+      help: "Run `npm install` to install project dependencies, or `npm install canvascreator` to add CanvasCreator manually."
+    };
+  }
+
+  const packageJsonPath = path.join(packageRoot, "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    const packageJson = readJson(packageJsonPath);
+    const binEntry = typeof packageJson.bin === "string"
+      ? packageJson.bin
+      : packageJson.bin?.["canvascreator-export"];
+
+    if (binEntry) {
+      const binPath = path.resolve(packageRoot, binEntry);
+      if (fs.existsSync(binPath)) {
+        return {
+          ok: true,
+          command: process.execPath,
+          args: [binPath]
+        };
+      }
+    }
+  }
+
+  const scriptPath = path.resolve(packageRoot, "scripts", "export.js");
+  if (fs.existsSync(scriptPath)) {
+    return {
+      ok: true,
+      command: process.execPath,
+      args: [scriptPath]
+    };
+  }
+
+  return {
+    ok: false,
+    reason: "CanvasCreator is installed, but its export CLI could not be found.",
+    help: "Reinstall `canvascreator` or use the CanvasCreator web app to export SVG from the JSON file."
+  };
+}
+
+function resolveStartLocale(options = {}) {
+  const explicitLocale = options.locale;
+  const defaultLocale = options["default-locale"] || methodEngine.DEFAULT_LOCALE;
+  if (explicitLocale) {
+    return explicitLocale;
+  }
+
+  return methodEngine.getSupportedMethodLocales().includes(defaultLocale)
+    ? defaultLocale
+    : methodEngine.DEFAULT_LOCALE;
+}
+
+async function maybePromptForStartLocale(options = {}) {
+  const selectedLocale = resolveStartLocale(options);
+  if (
+    options.locale ||
+    options.json ||
+    options.list ||
+    options.answers ||
+    !process.stdin.isTTY
+  ) {
+    return selectedLocale;
+  }
+
+  const supportedLocales = methodEngine.getSupportedMethodLocales();
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  try {
+    console.log(`Default method language: ${selectedLocale}`);
+    console.log(`Available languages: ${supportedLocales.join(", ")}`);
+    const answer = (await rl.question("Press Enter to keep the default, or type another locale for this run: "))
+      .trim()
+      .toLowerCase();
+    if (!answer) {
+      console.log("");
+      return selectedLocale;
+    }
+
+    if (supportedLocales.includes(answer)) {
+      console.log("");
+      return answer;
+    }
+
+    console.log(`Unknown locale "${answer}", using ${selectedLocale}.`);
+    console.log("");
+    return selectedLocale;
+  } finally {
+    rl.close();
+  }
+}
+
+function formatCommandFailure(result) {
+  if (result.error?.message) {
+    return result.error.message;
+  }
+
+  const stderr = String(result.stderr || "").trim();
+  if (stderr) {
+    return stderr;
+  }
+
+  const stdout = String(result.stdout || "").trim();
+  if (stdout) {
+    return stdout;
+  }
+
+  return "Canvas export failed.";
+}
+
+function exportCanvasSvgForResource(stationId, step, locale, output) {
+  const jsonPath = methodEngine.generateCanvasForStationResource(stationId, step.resourceId, locale, output);
+  const exportCommand = resolveCanvasExportCommand();
+  if (!exportCommand.ok) {
+    return {
+      ok: false,
+      reason: exportCommand.reason,
+      help: exportCommand.help,
+      jsonPath
+    };
+  }
+
+  const outputDir = path.dirname(jsonPath);
+  const outputFile = path.join(outputDir, `${step.resourceId}.svg`);
+  const result = runCommand(
+    exportCommand.command,
+    [
+      ...exportCommand.args,
+      "--input", jsonPath,
+      "--format", "svg",
+      "--output", outputFile
+    ],
+    {
+      cwd: process.cwd()
+    }
+  );
+
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      reason: formatCommandFailure(result),
+      jsonPath
+    };
+  }
+
+  return {
+    ok: true,
+    jsonPath,
+    outputFile
+  };
+}
+
+function printStartText(data) {
+  console.log(`APIOps starting station check (${data.length} core stations)\n`);
+  for (const station of data) {
+    console.log(`${station.order}. ${station.title} (${station.id})`);
+    console.log(`   ${station.description}`);
+    if (station.suggestedForNewApi) {
+      console.log("   Suggested default for a new API unless later-station criteria are already clearly met.");
+    }
+    console.log("   Criteria to check:");
+    for (const criterion of station.criteria) {
+      console.log(`   - ${criterion.label}`);
+    }
+    console.log("");
+  }
+}
+
+function printMenuOptions(options) {
+  for (const option of options) {
+    console.log(`${option.key}. ${option.label}`);
+  }
+}
+
+async function askMenuChoice(rl, prompt, options, providedChoice) {
+  const validKeys = new Set(options.map((option) => option.key));
+  if (providedChoice) {
+    if (!validKeys.has(providedChoice)) {
+      fail(`Unsupported menu choice: ${providedChoice}`);
+    }
+    console.log(`${prompt} ${providedChoice}`);
+    return providedChoice;
+  }
+
+  while (true) {
+    const answer = (await rl.question(prompt)).trim();
+    if (validKeys.has(answer)) {
+      return answer;
+    }
+    console.log(`Choose one of: ${options.map((option) => option.key).join(", ")}`);
+  }
+}
+
+function printResourceDetails(metadata) {
+  console.log("");
+  console.log(`${metadata.title} (${metadata.id})`);
+  console.log(`Type: ${metadata.category}`);
+  console.log(metadata.description);
+  if (metadata.steps.length > 0) {
+    console.log("How it works:");
+    for (const step of metadata.steps) {
+      console.log(`- ${step}`);
+    }
+  }
+  if (metadata.tips.length > 0) {
+    console.log("Tips:");
+    for (const tip of metadata.tips) {
+      console.log(`- ${tip}`);
+    }
+  }
+  if (metadata.canvasId) {
+    console.log(`Canvas template: ${metadata.canvasId}`);
+  }
+  if (metadata.snippet) {
+    console.log(`Snippet: ${metadata.snippet}`);
+  }
+}
+
+function printCanvasDetails(metadata) {
+  console.log("");
+  console.log(`${metadata.title} (${metadata.id})`);
+  if (metadata.purpose) {
+    console.log(`Purpose: ${metadata.purpose}`);
+  }
+  if (metadata.howToUse) {
+    console.log(`How to use: ${metadata.howToUse}`);
+  }
+  if (metadata.sections.length > 0) {
+    console.log("Sections:");
+    for (const section of metadata.sections) {
+      console.log(`- ${section.title}: ${section.description}`);
+    }
+  }
+}
+
+async function runInteractiveStart(data, options) {
+  const answers = {};
+  const providedAnswers = (options.answers || "")
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+  const useProvidedAnswers = providedAnswers.length > 0;
+  const rl = !useProvidedAnswers
+    ? readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    })
+    : null;
+  let answerIndex = 0;
+  let recommendedStation = null;
+  let stoppingCriterion = null;
+
+  console.log(`APIOps guided station check (${data.length} core stations)`);
+  console.log("Answer each criterion with yes, no, or skip.");
+  console.log("The guide stops at the first `no` and recommends that station immediately.\n");
+
+  try {
+    for (const station of data) {
+      console.log(`${station.order}. ${station.title} (${station.id})`);
+      console.log(`   ${station.description}`);
+
+      for (const criterion of station.criteria) {
+        let normalized;
+        const promptPrefix = `   - ${criterion.label}`;
+
+        if (useProvidedAnswers) {
+          const providedAnswer = providedAnswers[answerIndex];
+          if (!providedAnswer) {
+            fail(`Not enough answers in --answers. Stopped at station ${station.id}, criterion ${criterion.id}.`);
+          }
+          normalized = methodEngine.normalizeAnswer(providedAnswer);
+          if (!normalized) {
+            fail(`Unsupported answer in --answers at position ${answerIndex + 1}: ${providedAnswer}`);
+          }
+          console.log(`${promptPrefix} -> ${providedAnswer}`);
+        } else {
+          while (!normalized) {
+            const answer = await rl.question(`${promptPrefix} (yes/no/skip): `);
+            normalized = methodEngine.normalizeAnswer(answer);
+            if (!normalized) {
+              console.log("Please answer yes, no, or skip.");
+            }
+          }
+        }
+
+        answerIndex += 1;
+        answers[criterion.id] = normalized;
+
+        if (normalized === "not-met") {
+          recommendedStation = station;
+          stoppingCriterion = criterion;
+          break;
+        }
+      }
+
+      console.log("");
+
+      if (recommendedStation) {
+        break;
+      }
+    }
+  } finally {
+    rl?.close();
+  }
+
+  const result = recommendedStation
+    ? {
+      recommendedStation: {
+        id: recommendedStation.id,
+        title: recommendedStation.title,
+        unmetCriteria: [stoppingCriterion]
+      }
+    }
+    : methodEngine.evaluateStartRecommendation(data, answers);
+
+  console.log("");
+  console.log(`Recommended start station: ${result.recommendedStation.title} (${result.recommendedStation.id})`);
+  console.log(recommendedStation
+    ? "Reason: this is the first station where a required criterion was marked as not met."
+    : "Reason: all checked core-station criteria were marked as met.");
+
+  if (result.recommendedStation.unmetCriteria.length > 0) {
+    console.log("Criteria still to address here:");
+    for (const criterion of result.recommendedStation.unmetCriteria) {
+      console.log(`- ${criterion.label}`);
+    }
+  }
+
+  const actionOptions = [
+    { key: "1", label: "Review station resources" },
+    { key: "2", label: "Generate empty starter canvases for this station" },
+    { key: "3", label: "Exit" }
+  ];
+  const mappedActions = {
+    resources: "1",
+    canvases: "2",
+    exit: "3"
+  };
+  const providedAction = options["next-action"] ? mappedActions[options["next-action"]] : null;
+  const actionRl = !providedAction
+    ? readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    })
+    : null;
+
+  console.log("");
+  console.log("Next step options:");
+  printMenuOptions(actionOptions);
+
+  const actionChoice = await askMenuChoice(actionRl, "Choose next step (1/2/3): ", actionOptions, providedAction);
+  actionRl?.close();
+
+  if (actionChoice === "1") {
+    await runInteractiveResources({
+      station: result.recommendedStation.id,
+      locale: options.locale || methodEngine.DEFAULT_LOCALE,
+      style: options.style || methodEngine.DEFAULT_STYLE,
+      cycle: getCycleId(options)
+    });
+    return;
+  }
+
+  if (actionChoice === "2") {
+    const generateResult = methodEngine.generateCanvases({
+      station: result.recommendedStation.id,
+      locale: options.locale || methodEngine.DEFAULT_LOCALE,
+      style: options.style || methodEngine.DEFAULT_STYLE,
+      cycle: getCycleId(options),
+      output: methodEngine.DEFAULT_OUTPUT_DIR
+    });
+    printGeneratedCanvasText(generateResult);
+    return;
+  }
+
+  const nextHints = getNextStepHints(result.recommendedStation.id);
+  console.log("");
+  console.log("You can continue later with:");
+  console.log(`- ${nextHints.resources}`);
+  console.log(`- ${nextHints.canvases}`);
+}
+
+function printResourceText(data) {
+  console.log(`${data.stationTitle} (${data.stationId})`);
+  console.log(`${data.stationDescription}\n`);
+  for (const step of data.steps) {
+    console.log(`${step.order}. ${step.step}`);
+    if (step.missing) {
+      console.log(`   Missing resource mapping for ${step.resourceId}`);
+      continue;
+    }
+    console.log(`   Resource: ${step.resourceTitle} (${step.resourceId})`);
+    console.log(`   Type: ${step.category}`);
+    if (step.canvasId) {
+      console.log(`   Canvas template: ${step.canvasId}`);
+    }
+    if (step.snippet) {
+      console.log(`   Snippet: ${step.snippet}`);
+    }
+    console.log(`   ${step.resourceDescription}`);
+  }
+}
+
+async function runInteractiveResources(options) {
+  const locale = options.locale || methodEngine.DEFAULT_LOCALE;
+  const style = methodEngine.normalizeStyle(options.style || methodEngine.DEFAULT_STYLE);
+  const output = options.output || methodEngine.DEFAULT_OUTPUT_DIR;
+  const data = methodEngine.buildStationResourceData(options.station, locale, style, getCycleId(options));
+  const scriptedActions = (options["step-actions"] || "")
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+  let scriptedIndex = 0;
+  const useScriptedActions = scriptedActions.length > 0;
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  console.log(`${data.stationTitle} (${data.stationId})`);
+  console.log(`${data.stationDescription}\n`);
+
+  try {
+    for (const step of data.steps) {
+      console.log(`${step.order}. ${step.step}`);
+      if (step.missing) {
+        console.log(`Missing resource mapping for ${step.resourceId}\n`);
+        continue;
+      }
+
+      console.log(`Resource: ${step.resourceTitle} (${step.resourceId})`);
+      console.log(`Type: ${step.category}`);
+
+      while (true) {
+        const menuOptions = [
+          { key: "1", label: "View resource details" },
+          ...(step.canvasId ? [{ key: "2", label: "View related canvas details" }] : []),
+          ...(step.canvasId ? [{ key: "3", label: "Fill the canvas section by section and save JSON" }] : []),
+          ...(step.canvasId ? [{ key: "4", label: "Show CanvasCreator edit URL" }] : []),
+          ...(step.canvasId ? [{ key: "5", label: "Export current canvas JSON to SVG" }] : []),
+          ...(step.canvasId ? [{ key: "6", label: "Create or show starter canvas JSON" }] : []),
+          { key: step.canvasId ? "7" : "2", label: "Continue to next step" },
+          { key: step.canvasId ? "8" : "3", label: "Exit" }
+        ];
+
+        printMenuOptions(menuOptions);
+        const scriptedAction = useScriptedActions ? scriptedActions[scriptedIndex] : null;
+        const choice = await askMenuChoice(
+          rl,
+          `Choose action for step ${step.order}: `,
+          menuOptions,
+          scriptedAction
+        );
+        if (useScriptedActions) {
+          scriptedIndex += 1;
+        }
+
+        if (choice === "1") {
+          printResourceDetails(methodEngine.buildResourceMetadata(step.resourceId, locale));
+          console.log("");
+          continue;
+        }
+
+        if (choice === "2" && step.canvasId) {
+          printCanvasDetails(methodEngine.buildCanvasMetadata(step.canvasId, locale));
+          console.log("");
+          continue;
+        }
+
+        if (choice === "3" && step.canvasId) {
+          const outPath = await fillCanvasSectionsInteractive(data.stationId, step, locale, output, rl);
+          console.log(`Saved canvas JSON: ${outPath}`);
+          console.log("");
+          continue;
+        }
+
+        if (choice === "4" && step.canvasId) {
+          const outPath = methodEngine.generateCanvasForStationResource(data.stationId, step.resourceId, locale, output);
+          console.log("");
+          console.log(`CanvasCreator URL: ${methodEngine.getCanvasCreatorUrl(step.canvasId, locale)}`);
+          console.log(`Import or edit JSON from: ${outPath}`);
+          console.log("After editing in CanvasCreator, export JSON/SVG/PDF/PNG there and copy the files back into this repo.");
+          console.log("");
+          continue;
+        }
+
+        if (choice === "5" && step.canvasId) {
+          const exportResult = exportCanvasSvgForResource(data.stationId, step, locale, output);
+          console.log("");
+          if (exportResult.ok) {
+            console.log(`SVG export: ${exportResult.outputFile}`);
+            console.log(`Source JSON: ${exportResult.jsonPath}`);
+          } else {
+            console.log(`SVG export unavailable: ${exportResult.reason}`);
+            if (exportResult.help) {
+              console.log(exportResult.help);
+            }
+            console.log(`Canvas JSON is still available at: ${exportResult.jsonPath}`);
+            console.log(`CanvasCreator URL: ${methodEngine.getCanvasCreatorUrl(step.canvasId, locale)}`);
+          }
+          console.log("");
+          continue;
+        }
+
+        if (choice === "6" && step.canvasId) {
+          const outPath = methodEngine.generateCanvasForStationResource(data.stationId, step.resourceId, locale, output);
+          console.log("");
+          console.log(`Starter canvas JSON: ${outPath}`);
+          console.log("");
+          continue;
+        }
+
+        const continueKey = step.canvasId ? "7" : "2";
+        const exitKey = step.canvasId ? "8" : "3";
+
+        if (choice === continueKey) {
+          console.log("");
+          break;
+        }
+
+        if (choice === exitKey) {
+          console.log("");
+          console.log("Stopped resource walkthrough.");
+          return;
+        }
+      }
+    }
+  } finally {
+    rl.close();
+  }
+
+  console.log("Reached the end of the station steps.");
+}
+
+function printGeneratedCanvasText(result) {
+  console.log(`Generated empty canvases in ${result.outputRoot}`);
+  if (result.generated.length > 0) {
+    console.log("");
+    for (const entry of result.generated) {
+      console.log(`- ${entry.resourceId} -> ${entry.file}`);
+    }
+  }
+
+  if (result.skipped.length > 0) {
+    console.log("");
+    console.log("Skipped existing files:");
+    for (const entry of result.skipped) {
+      console.log(`- ${entry.resourceId} -> ${entry.file}`);
+    }
+    console.log("\nUse --force to overwrite existing starter files.");
+  }
+}
+
+export async function main() {
+  const { command, options } = parseArgs(process.argv.slice(2));
+
+  if (command === "help") {
+    printUsage();
+    return;
+  }
+
+  if (command === "start") {
+    const locale = await maybePromptForStartLocale(options);
+    const data = methodEngine.buildStartData(locale, getCycleId(options));
+    if (options.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+
+    if (options.list || (!process.stdin.isTTY && !options.answers)) {
+      printStartText(data);
+      return;
+    }
+
+    await runInteractiveStart(data, { ...options, locale });
+    return;
+  }
+
+  if (command === "resources") {
+    if (!options.station) {
+      fail("resources requires --station <station-id>");
+    }
+
+    const data = methodEngine.buildStationResourceData(
+      options.station,
+      options.locale || methodEngine.DEFAULT_LOCALE,
+      methodEngine.normalizeStyle(options.style || methodEngine.DEFAULT_STYLE),
+      getCycleId(options)
+    );
+    if (options.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+
+    if (!options.list && (process.stdin.isTTY || options["step-actions"])) {
+      await runInteractiveResources(options);
+      return;
+    }
+
+    printResourceText(data);
+    return;
+  }
+
+  if (command === "generate-canvases") {
+    const result = methodEngine.generateCanvases(options);
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    printGeneratedCanvasText(result);
+    return;
+  }
+
+  fail(`Unknown command: ${command}`);
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === currentFilePath) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  });
+}
diff --git a/package-lock.json b/package-lock.json
index 21a0a8d..fc71509 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "apiops-cycles-method-data",
-  "version": "3.4.4",
+  "version": "4.0.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "apiops-cycles-method-data",
-      "version": "3.4.4",
+      "version": "4.0.0",
       "license": "Apache-2.0",
       "workspaces": [
         "packages/*"
@@ -802,10 +802,20 @@
       "license": "ISC"
     },
     "node_modules/js-yaml": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
-      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.0.tgz",
+      "integrity": "sha512-1td788aAnnZ5qs7V2QIRl1owjtYpbKt749Y3xauqQgwIIGF/xXWz1wMTEBx5O3LK3lXLVuqXPdPxj2BoFHaW9Q==",
       "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/puzrin"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/nodeca"
+        }
+      ],
       "license": "MIT",
       "dependencies": {
         "argparse": "^2.0.1"
@@ -1105,9 +1115,9 @@
       }
     },
     "node_modules/read-yaml-file/node_modules/js-yaml": {
-      "version": "3.14.2",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.2.tgz",
-      "integrity": "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==",
+      "version": "3.15.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.15.0.tgz",
+      "integrity": "sha512-ttBQIIQPDeLjpPOohtUdXuXUVoA2uIB6fEH9HyJ7234s5mBJ5wTx20njxplLZQgLaOfpmPQA7X2t5AX6tIPbog==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -1341,7 +1351,13 @@
       },
       "engines": {
         "node": ">=22"
+      },
+      "optionalDependencies": {
+        "apiops-cycles-method-data": "^4.0.0"
       }
+    },
+    "packages/create-apiops/node_modules/apiops-cycles-method-data": {
+      "optional": true
     }
   }
 }
diff --git a/package.json b/package.json
index fcd5045..7e1b508 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "apiops-cycles-method-data",
-  "version": "3.4.4",
+  "version": "4.0.0",
   "description": "APIOps Cycles Method data and canvases",
   "license": "Apache-2.0",
   "type": "module",
@@ -26,6 +26,7 @@
     "./localizedData.json": "./src/data/canvas/localizedData.json",
     "./method/stations.json": "./src/data/method/stations.json",
     "./method/resources.json": "./src/data/method/resources.json",
+    "./method/cycles.json": "./src/data/method/cycles.json",
     "./method/station-criteria.json": "./src/data/method/station-criteria.json",
     "./method/stakeholders.json": "./src/data/method/stakeholders.json",
     "./method/station-stakeholders.json": "./src/data/method/station-stakeholders.json",
@@ -37,7 +38,8 @@
     "release:create-apiops:publish": "npm publish --workspace packages/create-apiops --access public",
     "check:packaging:skills": "node scripts/check-packaging-skills.mjs",
     "check:package:contents": "node scripts/check-package-contents.mjs",
-    "test:create-apiops": "node scripts/test-create-apiops-scaffold.mjs && node scripts/test-method-cli.mjs && node scripts/test-run-design-audit.mjs"
+    "test:create-apiops": "node scripts/test-create-apiops-scaffold.mjs && node scripts/test-method-cli.mjs && node scripts/test-run-design-audit.mjs",
+    "test:create-apiops:integration": "node scripts/test-create-apiops-scaffold.mjs --install-integration && node scripts/test-method-cli.mjs && node scripts/test-run-design-audit.mjs"
   },
   "devDependencies": {
     "@changesets/cli": "^2.29.7",
diff --git a/packages/create-apiops/README.md b/packages/create-apiops/README.md
new file mode 100644
index 0000000..9c9ad07
--- /dev/null
+++ b/packages/create-apiops/README.md
@@ -0,0 +1,63 @@
+# create-apiops
+
+Scaffold a new APIOps project with method guidance, API design artifacts, OpenAPI linting, and APIOps Cycles audit scaffolding.
+
+## Usage
+
+Interactive scaffold:
+
+```bash
+npm create apiops@latest
+```
+
+Named project scaffold:
+
+```bash
+npm create apiops@latest report-conversion-apiops
+```
+
+Non-interactive scaffold:
+
+```bash
+npm create apiops@latest -- --name report-conversion-apiops --locale en --cycle api-productization-cycle --style REST --yes
+```
+
+Skip dependency installation:
+
+```bash
+npm create apiops@latest -- report-conversion-apiops --locale en --cycle api-productization-cycle --style REST --yes --no-install
+```
+
+## npm create argument forwarding
+
+When using `npm create`, pass initializer flags after the `--` separator. Flags before the separator are handled by npm itself and may not reach `create-apiops`.
+
+The first positional argument is treated as the project name, so these are equivalent:
+
+```bash
+npm create apiops@latest report-conversion-apiops
+npm create apiops@latest -- --name report-conversion-apiops
+```
+
+## Help
+
+```bash
+npm create apiops@latest -- --help
+```
+
+You can also run the initializer directly:
+
+```bash
+npx create-apiops@latest --help
+```
+
+## Options
+
+- `--name <name>` or the first positional argument sets the project directory and package name.
+- `--locale <locale>` sets the default method locale. Default: `en`.
+- `--cycle <cycle-id>` sets the APIOps cycle for station labels, stakeholders, and recommended resources. Default: `api-productization-cycle`.
+- `--style <style>` sets the API style focus: `REST`, `Event`, `GraphQL`, or `"Not sure yet"`. Default: `REST`.
+- `--yes`, `-y` accepts defaults for omitted options and runs without prompts. Use it in non-interactive shells when any prompt answer is omitted.
+- `--no-install` skips dependency installation and starter canvas generation.
+- `--version`, `-v` prints the initializer version.
+- `--help`, `-h` prints usage without starting prompts.
diff --git a/packages/create-apiops/bin/create-apiops-project.js b/packages/create-apiops/bin/create-apiops-project.js
index 72b2fba..2844c66 100644
--- a/packages/create-apiops/bin/create-apiops-project.js
+++ b/packages/create-apiops/bin/create-apiops-project.js
@@ -12,23 +12,54 @@ const templateDir = path.resolve(__dirname, "..", "template");
 const DEFAULTS = {
   name: "my-api-project",
   locale: "en",
+  cycle: "api-productization-cycle",
   style: "REST",
   install: true
 };
 
 function parseArgs(argv) {
   const args = {
+    help: false,
+    version: false,
     yes: false,
     name: undefined,
     locale: undefined,
+    cycle: undefined,
     style: undefined,
-    install: undefined
+    install: undefined,
+    errors: []
+  };
+
+  const readValue = (arg, key, index) => {
+    const equalIndex = arg.indexOf("=");
+    if (equalIndex !== -1) {
+      const value = arg.slice(equalIndex + 1);
+      if (!value) {
+        args.errors.push(`Missing value for ${arg.slice(0, equalIndex)}.`);
+      }
+      return { value, nextIndex: index };
+    }
+
+    const value = argv[index + 1];
+    if (!value || value.startsWith("--")) {
+      args.errors.push(`Missing value for --${key}.`);
+      return { value: undefined, nextIndex: index };
+    }
+    return { value, nextIndex: index + 1 };
   };
 
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
 
-    if (arg === "--yes") {
+    if (arg === "--help" || arg === "-h") {
+      args.help = true;
+      continue;
+    }
+    if (arg === "--version" || arg === "-v") {
+      args.version = true;
+      continue;
+    }
+    if (arg === "--yes" || arg === "-y") {
       args.yes = true;
       continue;
     }
@@ -36,19 +67,40 @@ function parseArgs(argv) {
       args.install = false;
       continue;
     }
-    if (arg === "--name") {
-      args.name = argv[i + 1];
-      i += 1;
+    if (arg === "--name" || arg.startsWith("--name=")) {
+      const result = readValue(arg, "name", i);
+      args.name = result.value;
+      i = result.nextIndex;
       continue;
     }
-    if (arg === "--locale") {
-      args.locale = argv[i + 1];
-      i += 1;
+    if (arg === "--locale" || arg.startsWith("--locale=")) {
+      const result = readValue(arg, "locale", i);
+      args.locale = result.value;
+      i = result.nextIndex;
       continue;
     }
-    if (arg === "--style") {
-      args.style = argv[i + 1];
-      i += 1;
+    if (arg === "--cycle" || arg.startsWith("--cycle=")) {
+      const result = readValue(arg, "cycle", i);
+      args.cycle = result.value;
+      i = result.nextIndex;
+      continue;
+    }
+    if (arg === "--style" || arg.startsWith("--style=")) {
+      const result = readValue(arg, "style", i);
+      args.style = result.value;
+      i = result.nextIndex;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      args.errors.push(`Unknown option: ${arg}`);
+      continue;
+    }
+    if (!args.name) {
+      args.name = arg;
+      continue;
+    }
+    if (args.name !== arg) {
+      args.errors.push(`Unexpected positional argument: ${arg}`);
       continue;
     }
   }
@@ -56,6 +108,41 @@ function parseArgs(argv) {
   return args;
 }
 
+function getPackageVersion() {
+  const packageJsonPath = path.resolve(__dirname, "..", "package.json");
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  return packageJson.version;
+}
+
+function printHelp() {
+  console.log(`create-apiops ${getPackageVersion()}
+
+Scaffold a new APIOps project with method guidance, API design artifacts,
+OpenAPI linting, and APIOps Cycles audit scaffolding.
+
+Usage:
+  create-apiops [project-name] [options]
+  npm create apiops@latest -- [project-name] [options]
+
+Options:
+  --name <name>        Project directory and package name. Same as project-name.
+  --locale <locale>    Default locale for generated method commands. Default: ${DEFAULTS.locale}
+  --cycle <cycle-id>   APIOps cycle for station labels and resources. Default: ${DEFAULTS.cycle}
+  --style <style>      API style focus: REST, Event, GraphQL, or "Not sure yet". Default: ${DEFAULTS.style}
+  --yes, -y            Accept defaults for omitted options and run without prompts.
+                      Use this in non-interactive shells when any prompt answer is omitted.
+  --no-install         Skip npm install and starter canvas generation.
+  --version, -v        Show the create-apiops version.
+  --help, -h           Show this help.
+
+Examples:
+  npm create apiops@latest
+  npm create apiops@latest my-api
+  npm create apiops@latest -- --name my-api --locale en --cycle api-productization-cycle --style REST --yes
+  npm create apiops@latest -- my-api --locale en --cycle api-productization-cycle --style REST --yes --no-install
+`);
+}
+
 function normalizeStyle(style) {
   const value = String(style || "").trim().toLowerCase();
   const map = {
@@ -119,29 +206,75 @@ function runCommand(command, args, options = {}) {
   });
 }
 
-function hasMissingFlagValue(args) {
-  return ["name", "locale", "style"].some((key) => args[key] === undefined && process.argv.includes(`--${key}`));
+function hasCompleteNonInteractiveConfig(args) {
+  return args.name && args.locale && args.cycle && args.style && args.install !== undefined;
+}
+
+async function loadMethodEngine() {
+  try {
+    return await import("apiops-cycles-method-data/method-engine");
+  } catch (error) {
+    if (error?.code !== "ERR_MODULE_NOT_FOUND") {
+      throw error;
+    }
+    return import("../../../src/lib/method-engine.js");
+  }
+}
+
+async function getSupportedCycleIds() {
+  const { getCycles } = await loadMethodEngine();
+  return getCycles().flatMap((cycle) => [cycle.id, cycle.slug].filter(Boolean));
+}
+
+async function validateCycle(cycle) {
+  const supportedCycleIds = await getSupportedCycleIds();
+  if (supportedCycleIds.includes(cycle)) {
+    return;
+  }
+
+  console.error(`Unknown APIOps cycle: ${cycle}`);
+  console.error(`Supported cycles: ${supportedCycleIds.join(", ")}`);
+  process.exit(1);
 }
 
 async function getScaffoldConfig() {
   const args = parseArgs(process.argv.slice(2));
 
-  if (hasMissingFlagValue(args)) {
-    console.error("Missing value for one of --name, --locale, or --style.");
+  if (args.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (args.version) {
+    console.log(getPackageVersion());
+    process.exit(0);
+  }
+
+  if (args.errors.length > 0) {
+    console.error(args.errors.join("\n"));
+    console.error("\nRun `create-apiops --help` for usage.");
     process.exit(1);
   }
 
   const initial = {
     projectName: args.name || DEFAULTS.name,
     locale: args.locale || DEFAULTS.locale,
+    cycle: args.cycle || DEFAULTS.cycle,
     apiStyle: normalizeStyle(args.style || DEFAULTS.style),
     installNow: args.install === undefined ? DEFAULTS.install : args.install
   };
 
-  if (args.yes || (args.name && args.locale && args.style && args.install !== undefined)) {
+  if (args.yes || hasCompleteNonInteractiveConfig(args)) {
     return initial;
   }
 
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    console.error("create-apiops cannot prompt because stdin or stdout is not interactive.");
+    console.error("Pass --yes to accept defaults for omitted options. To skip --yes, pass --name, --locale, --cycle, --style, and --no-install.");
+    console.error("Example: npm create apiops@latest -- --name my-api --locale en --cycle api-productization-cycle --style REST --yes");
+    process.exit(1);
+  }
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
@@ -149,6 +282,7 @@ async function getScaffoldConfig() {
 
   const projectName = args.name || await ask(rl, "Project name", initial.projectName);
   const locale = args.locale || await ask(rl, "Default locale", initial.locale);
+  const cycle = args.cycle || await ask(rl, "APIOps cycle", initial.cycle);
   const apiStyle = normalizeStyle(args.style || await ask(rl, "API style focus [REST/Event/GraphQL/Not sure yet]", initial.apiStyle));
   const installAnswer = args.install === undefined
     ? await ask(rl, "Install dependencies now? [yes/no]", initial.installNow ? "yes" : "no")
@@ -158,13 +292,15 @@ async function getScaffoldConfig() {
   return {
     projectName,
     locale,
+    cycle,
     apiStyle,
     installNow: installAnswer.toLowerCase() === "yes"
   };
 }
 
 async function main() {
-  const { projectName, locale, apiStyle, installNow } = await getScaffoldConfig();
+  const { projectName, locale, cycle, apiStyle, installNow } = await getScaffoldConfig();
+  await validateCycle(cycle);
 
   const targetDir = path.resolve(process.cwd(), projectName);
   if (fs.existsSync(targetDir)) {
@@ -177,6 +313,7 @@ async function main() {
   const replacements = {
     "__PROJECT_NAME__": projectName,
     "__LOCALE__": locale,
+    "__CYCLE__": cycle,
     "__API_TITLE__": projectName.replace(/[-_]/g, " "),
     "__API_STYLE__": apiStyle
   };
@@ -204,6 +341,7 @@ async function main() {
         "./node_modules/apiops-cycles-method-data/bin/method-cli.js",
         "generate-canvases",
         "--preset", "new-api",
+        "--cycle", cycle,
         "--style", apiStyle,
         "--locale", locale,
         "--output", "./specs/canvases"
diff --git a/packages/create-apiops/bin/method-cli.js b/packages/create-apiops/bin/method-cli.js
deleted file mode 100644
index c3f8033..0000000
--- a/packages/create-apiops/bin/method-cli.js
+++ /dev/null
@@ -1,794 +0,0 @@
-#!/usr/bin/env node
-import fs from "node:fs";
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-import readline from "node:readline/promises";
-import { fileURLToPath } from "node:url";
-import * as methodEngine from "../../../src/lib/method-engine.js";
-
-const currentFilePath = fileURLToPath(import.meta.url);
-
-const STATION_SCRIPT_HINTS = {
-  "api-product-strategy": {
-    resources: "npm run method:resources:strategy",
-    canvases: "npm run method:canvases:new-api"
-  },
-  "api-design": {
-    resources: "npm run method -- resources --station api-design --style \"REST\"",
-    canvases: "npm run method -- generate-canvases --station api-design --style \"REST\" --output ./specs/canvases"
-  }
-};
-
-function printUsage() {
-  console.log(`Usage:
-  node packages/create-apiops/bin/method-cli.js start [--locale <locale>] [--default-locale <locale>] [--json] [--list] [--answers <yes,no,...>] [--next-action <resources|canvases|exit>]
-  node packages/create-apiops/bin/method-cli.js resources --station <station-id> [--locale <locale>] [--style <style>] [--json] [--list] [--step-actions <details,next,...>]
-  node packages/create-apiops/bin/method-cli.js generate-canvases [--station <station-id> | --stations <ids> | --preset new-api] [--locale <locale>] [--style <style>] [--output <dir>] [--force] [--json]
-
-Examples:
-  node packages/create-apiops/bin/method-cli.js start --locale en
-  node packages/create-apiops/bin/method-cli.js start --default-locale en
-  node packages/create-apiops/bin/method-cli.js start --locale en --answers yes,no,yes --next-action resources
-  node packages/create-apiops/bin/method-cli.js resources --station api-product-strategy --locale en
-  node packages/create-apiops/bin/method-cli.js generate-canvases --preset new-api --style REST --output ./specs/canvases
-`);
-}
-
-function fail(message) {
-  console.error(message);
-  process.exit(1);
-}
-
-function parseArgs(argv) {
-  if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
-    return { command: "help", options: {} };
-  }
-
-  const [command, ...rest] = argv;
-  const options = {};
-
-  for (let index = 0; index < rest.length; index += 1) {
-    const current = rest[index];
-    if (!current.startsWith("--")) {
-      fail(`Unexpected argument: ${current}`);
-    }
-
-    const key = current.slice(2);
-    if (key === "json" || key === "force" || key === "list") {
-      options[key] = true;
-      continue;
-    }
-
-    const value = rest[index + 1];
-    if (!value || value.startsWith("--")) {
-      fail(`Missing value for --${key}`);
-    }
-
-    options[key] = value;
-    index += 1;
-  }
-
-  return { command, options };
-}
-
-function readJson(filePath) {
-  return JSON.parse(fs.readFileSync(filePath, "utf8"));
-}
-
-function runCommand(command, args, options = {}) {
-  return spawnSync(command, args, {
-    encoding: "utf8",
-    shell: false,
-    ...options
-  });
-}
-
-function getNextStepHints(stationId) {
-  const hints = STATION_SCRIPT_HINTS[stationId];
-  if (hints) {
-    return hints;
-  }
-
-  return {
-    resources: `npm run method -- resources --station ${stationId}`,
-    canvases: `npm run method -- generate-canvases --station ${stationId} --output ./specs/canvases`
-  };
-}
-
-function loadCanvasJson(filePath, canvasId, locale) {
-  if (fs.existsSync(filePath)) {
-    return readJson(filePath);
-  }
-  return methodEngine.buildCanvasTemplate(canvasId, locale);
-}
-
-function formatPaletteHelp() {
-  return Object.entries(methodEngine.getNoteColorPalette())
-    .map(([intent, color]) => `${intent}=${color}`)
-    .join(", ");
-}
-
-async function fillCanvasSectionsInteractive(stationId, step, locale, output, rl) {
-  const outPath = methodEngine.generateCanvasForStationResource(stationId, step.resourceId, locale, output);
-  const canvasJson = loadCanvasJson(outPath, step.canvasId, locale);
-  const canvasMetadata = methodEngine.buildCanvasMetadata(step.canvasId, locale);
-  const starterFileName = path.basename(outPath);
-  const suggestedFileSlug = starterFileName.endsWith(".empty.json")
-    ? step.resourceId
-    : starterFileName.replace(/\.json$/i, "");
-  const requestedFileSlug = await rl.question(`Save filled canvas as file name (${suggestedFileSlug}): `);
-  const finalFileSlug = methodEngine.sanitizeFileSlug(requestedFileSlug, suggestedFileSlug);
-  const finalPath = path.join(path.dirname(outPath), `${finalFileSlug}.json`);
-
-  console.log("");
-  console.log(`Filling ${canvasMetadata.title} section by section.`);
-  console.log("Use `|` to create multiple notes in one section. Leave blank to keep existing notes. Type !clear to remove notes in a section.\n");
-  console.log("Prefix any note with `[benefit]`, `[neutral]`, `[negative]`, `[task]`, `[default]`, or `[color=#RRGGBB]` to set its color explicitly.");
-  console.log(`Palette: ${formatPaletteHelp()}\n`);
-
-  for (const section of canvasMetadata.sections) {
-    const existingSection = canvasJson.sections.find((entry) => entry.sectionId === section.id);
-    const existingNotes = existingSection?.stickyNotes || [];
-    console.log(`${section.title}`);
-    console.log(section.description);
-    console.log(`Default note color here: ${section.defaultNoteIntent} (${section.defaultNoteColor})`);
-    if (existingNotes.length > 0) {
-      console.log(`Current notes: ${existingNotes.map((note) => `${note.content} (${note.color})`).join(" | ")}`);
-    }
-
-    const answer = (await rl.question("Notes: ")).trim();
-    if (!answer) {
-      console.log("");
-      continue;
-    }
-
-    if (answer === "!clear") {
-      existingSection.stickyNotes = [];
-      console.log("");
-      continue;
-    }
-
-    const notes = answer
-      .split("|")
-      .map((entry) => entry.trim())
-      .filter(Boolean)
-      .map((content) => methodEngine.parseStickyNoteInput(content, {
-        canvasId: step.canvasId,
-        sectionId: section.id,
-        defaultIntent: section.defaultNoteIntent
-      }));
-
-    existingSection.stickyNotes = notes;
-    console.log("");
-  }
-
-  fs.writeFileSync(finalPath, `${JSON.stringify(canvasJson, null, 2)}\n`);
-  return finalPath;
-}
-
-function resolveCanvasExportCommand() {
-  const packageRoot = path.resolve(process.cwd(), "node_modules", "canvascreator");
-  if (!fs.existsSync(packageRoot)) {
-    return {
-      ok: false,
-      reason: "SVG export requires CanvasCreator export support, which is not installed in this project.",
-      help: "Run `npm install` to install project dependencies, or `npm install canvascreator` to add CanvasCreator manually."
-    };
-  }
-
-  const packageJsonPath = path.join(packageRoot, "package.json");
-  if (fs.existsSync(packageJsonPath)) {
-    const packageJson = readJson(packageJsonPath);
-    const binEntry = typeof packageJson.bin === "string"
-      ? packageJson.bin
-      : packageJson.bin?.["canvascreator-export"];
-
-    if (binEntry) {
-      const binPath = path.resolve(packageRoot, binEntry);
-      if (fs.existsSync(binPath)) {
-        return {
-          ok: true,
-          command: process.execPath,
-          args: [binPath]
-        };
-      }
-    }
-  }
-
-  const scriptPath = path.resolve(packageRoot, "scripts", "export.js");
-  if (fs.existsSync(scriptPath)) {
-    return {
-      ok: true,
-      command: process.execPath,
-      args: [scriptPath]
-    };
-  }
-
-  return {
-    ok: false,
-    reason: "CanvasCreator is installed, but its export CLI could not be found.",
-    help: "Reinstall `canvascreator` or use the CanvasCreator web app to export SVG from the JSON file."
-  };
-}
-
-function resolveStartLocale(options = {}) {
-  const explicitLocale = options.locale;
-  const defaultLocale = options["default-locale"] || methodEngine.DEFAULT_LOCALE;
-  if (explicitLocale) {
-    return explicitLocale;
-  }
-
-  return methodEngine.getSupportedMethodLocales().includes(defaultLocale)
-    ? defaultLocale
-    : methodEngine.DEFAULT_LOCALE;
-}
-
-async function maybePromptForStartLocale(options = {}) {
-  const selectedLocale = resolveStartLocale(options);
-  if (
-    options.locale ||
-    options.json ||
-    options.list ||
-    options.answers ||
-    !process.stdin.isTTY
-  ) {
-    return selectedLocale;
-  }
-
-  const supportedLocales = methodEngine.getSupportedMethodLocales();
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-
-  try {
-    console.log(`Default method language: ${selectedLocale}`);
-    console.log(`Available languages: ${supportedLocales.join(", ")}`);
-    const answer = (await rl.question("Press Enter to keep the default, or type another locale for this run: "))
-      .trim()
-      .toLowerCase();
-    if (!answer) {
-      console.log("");
-      return selectedLocale;
-    }
-
-    if (supportedLocales.includes(answer)) {
-      console.log("");
-      return answer;
-    }
-
-    console.log(`Unknown locale "${answer}", using ${selectedLocale}.`);
-    console.log("");
-    return selectedLocale;
-  } finally {
-    rl.close();
-  }
-}
-
-function formatCommandFailure(result) {
-  if (result.error?.message) {
-    return result.error.message;
-  }
-
-  const stderr = String(result.stderr || "").trim();
-  if (stderr) {
-    return stderr;
-  }
-
-  const stdout = String(result.stdout || "").trim();
-  if (stdout) {
-    return stdout;
-  }
-
-  return "Canvas export failed.";
-}
-
-function exportCanvasSvgForResource(stationId, step, locale, output) {
-  const jsonPath = methodEngine.generateCanvasForStationResource(stationId, step.resourceId, locale, output);
-  const exportCommand = resolveCanvasExportCommand();
-  if (!exportCommand.ok) {
-    return {
-      ok: false,
-      reason: exportCommand.reason,
-      help: exportCommand.help,
-      jsonPath
-    };
-  }
-
-  const outputDir = path.dirname(jsonPath);
-  const outputFile = path.join(outputDir, `${step.resourceId}.svg`);
-  const result = runCommand(
-    exportCommand.command,
-    [
-      ...exportCommand.args,
-      "--input", jsonPath,
-      "--format", "svg",
-      "--output", outputFile
-    ],
-    {
-      cwd: process.cwd()
-    }
-  );
-
-  if (result.status !== 0) {
-    return {
-      ok: false,
-      reason: formatCommandFailure(result),
-      jsonPath
-    };
-  }
-
-  return {
-    ok: true,
-    jsonPath,
-    outputFile
-  };
-}
-
-function printStartText(data) {
-  console.log(`APIOps starting station check (${data.length} core stations)\n`);
-  for (const station of data) {
-    console.log(`${station.order}. ${station.title} (${station.id})`);
-    console.log(`   ${station.description}`);
-    if (station.suggestedForNewApi) {
-      console.log("   Suggested default for a new API unless later-station criteria are already clearly met.");
-    }
-    console.log("   Criteria to check:");
-    for (const criterion of station.criteria) {
-      console.log(`   - ${criterion.label}`);
-    }
-    console.log("");
-  }
-}
-
-function printMenuOptions(options) {
-  for (const option of options) {
-    console.log(`${option.key}. ${option.label}`);
-  }
-}
-
-async function askMenuChoice(rl, prompt, options, providedChoice) {
-  const validKeys = new Set(options.map((option) => option.key));
-  if (providedChoice) {
-    if (!validKeys.has(providedChoice)) {
-      fail(`Unsupported menu choice: ${providedChoice}`);
-    }
-    console.log(`${prompt} ${providedChoice}`);
-    return providedChoice;
-  }
-
-  while (true) {
-    const answer = (await rl.question(prompt)).trim();
-    if (validKeys.has(answer)) {
-      return answer;
-    }
-    console.log(`Choose one of: ${options.map((option) => option.key).join(", ")}`);
-  }
-}
-
-function printResourceDetails(metadata) {
-  console.log("");
-  console.log(`${metadata.title} (${metadata.id})`);
-  console.log(`Type: ${metadata.category}`);
-  console.log(metadata.description);
-  if (metadata.steps.length > 0) {
-    console.log("How it works:");
-    for (const step of metadata.steps) {
-      console.log(`- ${step}`);
-    }
-  }
-  if (metadata.tips.length > 0) {
-    console.log("Tips:");
-    for (const tip of metadata.tips) {
-      console.log(`- ${tip}`);
-    }
-  }
-  if (metadata.canvasId) {
-    console.log(`Canvas template: ${metadata.canvasId}`);
-  }
-  if (metadata.snippet) {
-    console.log(`Snippet: ${metadata.snippet}`);
-  }
-}
-
-function printCanvasDetails(metadata) {
-  console.log("");
-  console.log(`${metadata.title} (${metadata.id})`);
-  if (metadata.purpose) {
-    console.log(`Purpose: ${metadata.purpose}`);
-  }
-  if (metadata.howToUse) {
-    console.log(`How to use: ${metadata.howToUse}`);
-  }
-  if (metadata.sections.length > 0) {
-    console.log("Sections:");
-    for (const section of metadata.sections) {
-      console.log(`- ${section.title}: ${section.description}`);
-    }
-  }
-}
-
-async function runInteractiveStart(data, options) {
-  const answers = {};
-  const providedAnswers = (options.answers || "")
-    .split(",")
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-  const useProvidedAnswers = providedAnswers.length > 0;
-  const rl = !useProvidedAnswers
-    ? readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    })
-    : null;
-  let answerIndex = 0;
-  let recommendedStation = null;
-  let stoppingCriterion = null;
-
-  console.log(`APIOps guided station check (${data.length} core stations)`);
-  console.log("Answer each criterion with yes, no, or skip.");
-  console.log("The guide stops at the first `no` and recommends that station immediately.\n");
-
-  try {
-    for (const station of data) {
-      console.log(`${station.order}. ${station.title} (${station.id})`);
-      console.log(`   ${station.description}`);
-
-      for (const criterion of station.criteria) {
-        let normalized;
-        const promptPrefix = `   - ${criterion.label}`;
-
-        if (useProvidedAnswers) {
-          const providedAnswer = providedAnswers[answerIndex];
-          if (!providedAnswer) {
-            fail(`Not enough answers in --answers. Stopped at station ${station.id}, criterion ${criterion.id}.`);
-          }
-          normalized = methodEngine.normalizeAnswer(providedAnswer);
-          if (!normalized) {
-            fail(`Unsupported answer in --answers at position ${answerIndex + 1}: ${providedAnswer}`);
-          }
-          console.log(`${promptPrefix} -> ${providedAnswer}`);
-        } else {
-          while (!normalized) {
-            const answer = await rl.question(`${promptPrefix} (yes/no/skip): `);
-            normalized = methodEngine.normalizeAnswer(answer);
-            if (!normalized) {
-              console.log("Please answer yes, no, or skip.");
-            }
-          }
-        }
-
-        answerIndex += 1;
-        answers[criterion.id] = normalized;
-
-        if (normalized === "not-met") {
-          recommendedStation = station;
-          stoppingCriterion = criterion;
-          break;
-        }
-      }
-
-      console.log("");
-
-      if (recommendedStation) {
-        break;
-      }
-    }
-  } finally {
-    rl?.close();
-  }
-
-  const result = recommendedStation
-    ? {
-      recommendedStation: {
-        id: recommendedStation.id,
-        title: recommendedStation.title,
-        unmetCriteria: [stoppingCriterion]
-      }
-    }
-    : methodEngine.evaluateStartRecommendation(data, answers);
-
-  console.log("");
-  console.log(`Recommended start station: ${result.recommendedStation.title} (${result.recommendedStation.id})`);
-  console.log(recommendedStation
-    ? "Reason: this is the first station where a required criterion was marked as not met."
-    : "Reason: all checked core-station criteria were marked as met.");
-
-  if (result.recommendedStation.unmetCriteria.length > 0) {
-    console.log("Criteria still to address here:");
-    for (const criterion of result.recommendedStation.unmetCriteria) {
-      console.log(`- ${criterion.label}`);
-    }
-  }
-
-  const actionOptions = [
-    { key: "1", label: "Review station resources" },
-    { key: "2", label: "Generate empty starter canvases for this station" },
-    { key: "3", label: "Exit" }
-  ];
-  const mappedActions = {
-    resources: "1",
-    canvases: "2",
-    exit: "3"
-  };
-  const providedAction = options["next-action"] ? mappedActions[options["next-action"]] : null;
-  const actionRl = !providedAction
-    ? readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    })
-    : null;
-
-  console.log("");
-  console.log("Next step options:");
-  printMenuOptions(actionOptions);
-
-  const actionChoice = await askMenuChoice(actionRl, "Choose next step (1/2/3): ", actionOptions, providedAction);
-  actionRl?.close();
-
-  if (actionChoice === "1") {
-    await runInteractiveResources({
-      station: result.recommendedStation.id,
-      locale: options.locale || methodEngine.DEFAULT_LOCALE,
-      style: options.style || methodEngine.DEFAULT_STYLE
-    });
-    return;
-  }
-
-  if (actionChoice === "2") {
-    const generateResult = methodEngine.generateCanvases({
-      station: result.recommendedStation.id,
-      locale: options.locale || methodEngine.DEFAULT_LOCALE,
-      style: options.style || methodEngine.DEFAULT_STYLE,
-      output: methodEngine.DEFAULT_OUTPUT_DIR
-    });
-    printGeneratedCanvasText(generateResult);
-    return;
-  }
-
-  const nextHints = getNextStepHints(result.recommendedStation.id);
-  console.log("");
-  console.log("You can continue later with:");
-  console.log(`- ${nextHints.resources}`);
-  console.log(`- ${nextHints.canvases}`);
-}
-
-function printResourceText(data) {
-  console.log(`${data.stationTitle} (${data.stationId})`);
-  console.log(`${data.stationDescription}\n`);
-  for (const step of data.steps) {
-    console.log(`${step.order}. ${step.step}`);
-    if (step.missing) {
-      console.log(`   Missing resource mapping for ${step.resourceId}`);
-      continue;
-    }
-    console.log(`   Resource: ${step.resourceTitle} (${step.resourceId})`);
-    console.log(`   Type: ${step.category}`);
-    if (step.canvasId) {
-      console.log(`   Canvas template: ${step.canvasId}`);
-    }
-    if (step.snippet) {
-      console.log(`   Snippet: ${step.snippet}`);
-    }
-    console.log(`   ${step.resourceDescription}`);
-  }
-}
-
-async function runInteractiveResources(options) {
-  const locale = options.locale || methodEngine.DEFAULT_LOCALE;
-  const style = methodEngine.normalizeStyle(options.style || methodEngine.DEFAULT_STYLE);
-  const output = options.output || methodEngine.DEFAULT_OUTPUT_DIR;
-  const data = methodEngine.buildStationResourceData(options.station, locale, style);
-  const scriptedActions = (options["step-actions"] || "")
-    .split(",")
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-  let scriptedIndex = 0;
-  const useScriptedActions = scriptedActions.length > 0;
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-
-  console.log(`${data.stationTitle} (${data.stationId})`);
-  console.log(`${data.stationDescription}\n`);
-
-  try {
-    for (const step of data.steps) {
-      console.log(`${step.order}. ${step.step}`);
-      if (step.missing) {
-        console.log(`Missing resource mapping for ${step.resourceId}\n`);
-        continue;
-      }
-
-      console.log(`Resource: ${step.resourceTitle} (${step.resourceId})`);
-      console.log(`Type: ${step.category}`);
-
-      while (true) {
-        const menuOptions = [
-          { key: "1", label: "View resource details" },
-          ...(step.canvasId ? [{ key: "2", label: "View related canvas details" }] : []),
-          ...(step.canvasId ? [{ key: "3", label: "Fill the canvas section by section and save JSON" }] : []),
-          ...(step.canvasId ? [{ key: "4", label: "Show CanvasCreator edit URL" }] : []),
-          ...(step.canvasId ? [{ key: "5", label: "Export current canvas JSON to SVG" }] : []),
-          ...(step.canvasId ? [{ key: "6", label: "Create or show starter canvas JSON" }] : []),
-          { key: step.canvasId ? "7" : "2", label: "Continue to next step" },
-          { key: step.canvasId ? "8" : "3", label: "Exit" }
-        ];
-
-        printMenuOptions(menuOptions);
-        const scriptedAction = useScriptedActions ? scriptedActions[scriptedIndex] : null;
-        const choice = await askMenuChoice(
-          rl,
-          `Choose action for step ${step.order}: `,
-          menuOptions,
-          scriptedAction
-        );
-        if (useScriptedActions) {
-          scriptedIndex += 1;
-        }
-
-        if (choice === "1") {
-          printResourceDetails(methodEngine.buildResourceMetadata(step.resourceId, locale));
-          console.log("");
-          continue;
-        }
-
-        if (choice === "2" && step.canvasId) {
-          printCanvasDetails(methodEngine.buildCanvasMetadata(step.canvasId, locale));
-          console.log("");
-          continue;
-        }
-
-        if (choice === "3" && step.canvasId) {
-          const outPath = await fillCanvasSectionsInteractive(data.stationId, step, locale, output, rl);
-          console.log(`Saved canvas JSON: ${outPath}`);
-          console.log("");
-          continue;
-        }
-
-        if (choice === "4" && step.canvasId) {
-          const outPath = methodEngine.generateCanvasForStationResource(data.stationId, step.resourceId, locale, output);
-          console.log("");
-          console.log(`CanvasCreator URL: ${methodEngine.getCanvasCreatorUrl(step.canvasId, locale)}`);
-          console.log(`Import or edit JSON from: ${outPath}`);
-          console.log("After editing in CanvasCreator, export JSON/SVG/PDF/PNG there and copy the files back into this repo.");
-          console.log("");
-          continue;
-        }
-
-        if (choice === "5" && step.canvasId) {
-          const exportResult = exportCanvasSvgForResource(data.stationId, step, locale, output);
-          console.log("");
-          if (exportResult.ok) {
-            console.log(`SVG export: ${exportResult.outputFile}`);
-            console.log(`Source JSON: ${exportResult.jsonPath}`);
-          } else {
-            console.log(`SVG export unavailable: ${exportResult.reason}`);
-            if (exportResult.help) {
-              console.log(exportResult.help);
-            }
-            console.log(`Canvas JSON is still available at: ${exportResult.jsonPath}`);
-            console.log(`CanvasCreator URL: ${methodEngine.getCanvasCreatorUrl(step.canvasId, locale)}`);
-          }
-          console.log("");
-          continue;
-        }
-
-        if (choice === "6" && step.canvasId) {
-          const outPath = methodEngine.generateCanvasForStationResource(data.stationId, step.resourceId, locale, output);
-          console.log("");
-          console.log(`Starter canvas JSON: ${outPath}`);
-          console.log("");
-          continue;
-        }
-
-        const continueKey = step.canvasId ? "7" : "2";
-        const exitKey = step.canvasId ? "8" : "3";
-
-        if (choice === continueKey) {
-          console.log("");
-          break;
-        }
-
-        if (choice === exitKey) {
-          console.log("");
-          console.log("Stopped resource walkthrough.");
-          return;
-        }
-      }
-    }
-  } finally {
-    rl.close();
-  }
-
-  console.log("Reached the end of the station steps.");
-}
-
-function printGeneratedCanvasText(result) {
-  console.log(`Generated empty canvases in ${result.outputRoot}`);
-  if (result.generated.length > 0) {
-    console.log("");
-    for (const entry of result.generated) {
-      console.log(`- ${entry.resourceId} -> ${entry.file}`);
-    }
-  }
-
-  if (result.skipped.length > 0) {
-    console.log("");
-    console.log("Skipped existing files:");
-    for (const entry of result.skipped) {
-      console.log(`- ${entry.resourceId} -> ${entry.file}`);
-    }
-    console.log("\nUse --force to overwrite existing starter files.");
-  }
-}
-
-export async function main() {
-  const { command, options } = parseArgs(process.argv.slice(2));
-
-  if (command === "help") {
-    printUsage();
-    return;
-  }
-
-  if (command === "start") {
-    const locale = await maybePromptForStartLocale(options);
-    const data = methodEngine.buildStartData(locale);
-    if (options.json) {
-      console.log(JSON.stringify(data, null, 2));
-      return;
-    }
-
-    if (options.list || (!process.stdin.isTTY && !options.answers)) {
-      printStartText(data);
-      return;
-    }
-
-    await runInteractiveStart(data, { ...options, locale });
-    return;
-  }
-
-  if (command === "resources") {
-    if (!options.station) {
-      fail("resources requires --station <station-id>");
-    }
-
-    const data = methodEngine.buildStationResourceData(
-      options.station,
-      options.locale || methodEngine.DEFAULT_LOCALE,
-      methodEngine.normalizeStyle(options.style || methodEngine.DEFAULT_STYLE)
-    );
-    if (options.json) {
-      console.log(JSON.stringify(data, null, 2));
-      return;
-    }
-
-    if (!options.list && (process.stdin.isTTY || options["step-actions"])) {
-      await runInteractiveResources(options);
-      return;
-    }
-
-    printResourceText(data);
-    return;
-  }
-
-  if (command === "generate-canvases") {
-    const result = methodEngine.generateCanvases(options);
-    if (options.json) {
-      console.log(JSON.stringify(result, null, 2));
-      return;
-    }
-    printGeneratedCanvasText(result);
-    return;
-  }
-
-  fail(`Unknown command: ${command}`);
-}
-
-if (process.argv[1] && path.resolve(process.argv[1]) === currentFilePath) {
-  main().catch((error) => {
-    console.error(error instanceof Error ? error.message : error);
-    process.exit(1);
-  });
-}
diff --git a/packages/create-apiops/package.json b/packages/create-apiops/package.json
index eca1388..bef6395 100644
--- a/packages/create-apiops/package.json
+++ b/packages/create-apiops/package.json
@@ -8,9 +8,13 @@
     "create-apiops": "./bin/create-apiops-project.js"
   },
   "files": [
-    "bin",
+    "bin/check-node-version.js",
+    "bin/create-apiops-project.js",
     "template"
   ],
+  "optionalDependencies": {
+    "apiops-cycles-method-data": "^4.0.0"
+  },
   "keywords": [
     "apiops",
     "openapi",
diff --git a/packages/create-apiops/template/README.md b/packages/create-apiops/template/README.md
index 248ae79..58ed25f 100644
--- a/packages/create-apiops/template/README.md
+++ b/packages/create-apiops/template/README.md
@@ -68,7 +68,7 @@ Treat `specs/` as the source of truth and `docs/` as generated or review materia
 npm run method:start
 npm run method:resources:strategy
 npm run method:canvases:new-api
-npm run method -- resources --station api-design --style "__API_STYLE__"
+npm run method -- resources --station api-design --cycle "__CYCLE__" --style "__API_STYLE__"
 npm run method:stations
 npm run method:resource:audit
 npm run lint:openapi
@@ -80,7 +80,7 @@ npm run audit:design:full-crud
 ## How to use it
 
 - Use `npm run method:start` to find the right station to begin from. In an interactive terminal it checks criteria one by one and recommends where to start.
-- Use the `method:resources:*` commands or `npm run method -- resources --station ...` to walk the method resources for a station and inspect related canvases or snippets.
+- Use the `method:resources:*` commands or `npm run method -- resources --station ... --cycle "__CYCLE__"` to walk the method resources for a station and inspect related canvases or snippets.
 - Use `npm run method:canvases:new-api` to generate starter canvas JSON files for a new API initiative.
 - Use the generated canvas files to capture scope, business needs, domain understanding, and interface options before going too early into contract details.
 - Use `specs/openapi/api.yaml` when you are ready to produce or review API contract details.
@@ -159,4 +159,5 @@ The skill guidance is meant to keep AI work aligned with the project structure:
 - This project can also be used for an existing API by reviewing the current design against the canvases, style guide, and audit checklist.
 - If you are building your own helper app, agent, or automation, you can also import the shared method logic from `apiops-cycles-method-data/method-engine`.
 - Default locale: `__LOCALE__`
+- Selected APIOps cycle: `__CYCLE__`
 - Selected API style hint: `__API_STYLE__`
diff --git a/packages/create-apiops/template/package.json b/packages/create-apiops/template/package.json
index 187a0d6..0b4183b 100644
--- a/packages/create-apiops/template/package.json
+++ b/packages/create-apiops/template/package.json
@@ -6,7 +6,7 @@
     "node": ">=22"
   },
   "dependencies": {
-    "apiops-cycles-method-data": "^3.4.4",
+    "apiops-cycles-method-data": "^4.0.0",
     "canvascreator": "^1.7.3"
   },
   "devDependencies": {
@@ -16,13 +16,13 @@
   "scripts": {
     "preinstall": "node ./scripts/check-node-version.js",
     "method": "node ./node_modules/apiops-cycles-method-data/bin/method-cli.js",
-    "method:start": "node ./node_modules/apiops-cycles-method-data/bin/method-cli.js start --default-locale __LOCALE__",
-    "method:stations": "node ./scripts/get-core-stations.js",
-    "method:resources:strategy": "node ./node_modules/apiops-cycles-method-data/bin/method-cli.js resources --station api-product-strategy --locale __LOCALE__",
-    "method:resources:architecture": "node ./node_modules/apiops-cycles-method-data/bin/method-cli.js resources --station api-platform-architecture --locale __LOCALE__",
-    "method:resources:design": "node ./node_modules/apiops-cycles-method-data/bin/method-cli.js resources --station api-design --locale __LOCALE__",
-    "method:resources:audit-station": "node ./node_modules/apiops-cycles-method-data/bin/method-cli.js resources --station api-audit --locale __LOCALE__",
-    "method:canvases:new-api": "node ./node_modules/apiops-cycles-method-data/bin/method-cli.js generate-canvases --preset new-api --style \"__API_STYLE__\" --locale __LOCALE__ --output ./specs/canvases",
+    "method:start": "node ./node_modules/apiops-cycles-method-data/bin/method-cli.js start --cycle __CYCLE__ --default-locale __LOCALE__",
+    "method:stations": "node ./scripts/get-core-stations.js __LOCALE__ __CYCLE__",
+    "method:resources:strategy": "node ./node_modules/apiops-cycles-method-data/bin/method-cli.js resources --station api-product-strategy --cycle __CYCLE__ --locale __LOCALE__",
+    "method:resources:architecture": "node ./node_modules/apiops-cycles-method-data/bin/method-cli.js resources --station api-platform-architecture --cycle __CYCLE__ --locale __LOCALE__",
+    "method:resources:design": "node ./node_modules/apiops-cycles-method-data/bin/method-cli.js resources --station api-design --cycle __CYCLE__ --locale __LOCALE__",
+    "method:resources:audit-station": "node ./node_modules/apiops-cycles-method-data/bin/method-cli.js resources --station api-audit --cycle __CYCLE__ --locale __LOCALE__",
+    "method:canvases:new-api": "node ./node_modules/apiops-cycles-method-data/bin/method-cli.js generate-canvases --preset new-api --cycle __CYCLE__ --style \"__API_STYLE__\" --locale __LOCALE__ --output ./specs/canvases",
     "method:canvas": "node ./scripts/get-method-canvas-metadata.js",
     "method:canvas:mappings": "node ./scripts/list-canvas-mappings.js",
     "method:canvas:rest": "node ./scripts/get-method-canvas-metadata.js restCanvas __LOCALE__",
diff --git a/packages/create-apiops/template/scripts/get-core-stations.js b/packages/create-apiops/template/scripts/get-core-stations.js
index edc44a3..9d4e722 100644
--- a/packages/create-apiops/template/scripts/get-core-stations.js
+++ b/packages/create-apiops/template/scripts/get-core-stations.js
@@ -1,18 +1,19 @@
-import { buildStartData } from "apiops-cycles-method-data/method-engine";
+import { DEFAULT_CYCLE_ID, buildStartData } from "apiops-cycles-method-data/method-engine";
 
 function printUsage() {
-  console.error("Usage: node scripts/get-core-stations.js [locale]");
+  console.error("Usage: node scripts/get-core-stations.js [locale] [cycle]");
 }
 
 const locale = process.argv[2] || "en";
+const cycle = process.argv[3] || DEFAULT_CYCLE_ID;
 
-if (process.argv.length > 3) {
+if (process.argv.length > 4) {
   printUsage();
   process.exit(1);
 }
 
 try {
-  console.log(JSON.stringify(buildStartData(locale), null, 2));
+  console.log(JSON.stringify(buildStartData(locale, cycle), null, 2));
 } catch (error) {
   console.error(error instanceof Error ? error.message : error);
   process.exit(1);
diff --git a/packages/create-apiops/template/scripts/get-station-resources.js b/packages/create-apiops/template/scripts/get-station-resources.js
index 939f462..f09da8e 100644
--- a/packages/create-apiops/template/scripts/get-station-resources.js
+++ b/packages/create-apiops/template/scripts/get-station-resources.js
@@ -1,12 +1,13 @@
-import { DEFAULT_STYLE, buildStationResourceData } from "apiops-cycles-method-data/method-engine";
+import { DEFAULT_CYCLE_ID, DEFAULT_STYLE, buildStationResourceData } from "apiops-cycles-method-data/method-engine";
 
 function printUsage() {
-  console.error("Usage: node scripts/get-station-resources.js <station-id> [locale] [style]");
+  console.error("Usage: node scripts/get-station-resources.js <station-id> [locale] [style] [cycle]");
 }
 
 const stationId = process.argv[2];
 const locale = process.argv[3] || "en";
 const style = process.argv[4] || DEFAULT_STYLE;
+const cycle = process.argv[5] || DEFAULT_CYCLE_ID;
 
 if (!stationId) {
   printUsage();
@@ -14,9 +15,10 @@ if (!stationId) {
 }
 
 try {
-  const data = buildStationResourceData(stationId, locale, style);
+  const data = buildStationResourceData(stationId, locale, style, cycle);
   console.log(JSON.stringify({
     stationId: data.stationId,
+    cycleId: data.cycleId,
     locale,
     style: data.style,
     title: data.stationTitle,
diff --git a/public/partners/adorsys.svg b/public/partners/adorsys.svg
new file mode 100644
index 0000000..605e5c8
--- /dev/null
+++ b/public/partners/adorsys.svg
@@ -0,0 +1,21 @@
+<svg width="630" height="107" viewBox="0 0 630 107" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_2411_6303)">
+<g clip-path="url(#clip1_2411_6303)">
+<path d="M344.437 22.0741C343.587 21.177 342.266 20.7944 340.019 20.7944C337.348 20.7944 319.531 20.8425 316.907 20.9782C302.269 21.735 289.356 25.2179 289.356 38.2919V78.9309C289.356 82.0401 290.046 85.2194 295.166 85.2194H299.423C301.764 85.2194 304.554 84.1397 304.554 78.9969V39.7775C304.554 35.7408 305.419 34.4359 315.7 34.4359H339.31C341.996 34.4359 345.566 33.8575 345.566 28.8557L345.57 27.8389C345.585 25.1021 345.594 23.2938 344.437 22.0741Z" fill="#101828"/>
+<path d="M439.147 63.5319C439.146 51.6613 430.668 45.6418 413.949 45.6418H383.747C378.639 45.6418 374.371 45.4682 372.857 45.1963C368.756 44.5235 368.46 43.1941 368.46 41.0845V37.8393C368.46 36.171 370.371 35.0974 374.15 34.6459C375.121 34.5211 397.653 34.4582 402.43 34.4582H403.725C407.799 34.4582 409.615 32.5727 409.615 28.3452V26.9733C409.615 22.7002 407.799 20.7944 403.725 20.7944C388.103 20.7944 373.132 21.5474 369.123 22.418C356.126 25.236 353.398 32.3485 353.398 37.818V41.1931C353.398 52.7451 364.437 59.3704 383.684 59.3704H413.451C423.609 59.3704 423.609 61.6262 423.609 64.015V66.3672C423.609 71.4024 420.903 71.6429 412.35 71.6429H359.538C353.838 71.6429 353.398 74.6932 353.398 79.0019C353.398 83.3603 355.234 85.2193 359.538 85.2193H412.288C434.506 85.2193 439.169 74.955 439.169 66.3367L439.147 63.5319Z" fill="#101828"/>
+<path d="M629.899 63.5319C629.897 51.6613 621.419 45.6418 604.7 45.6418H574.498C569.391 45.6418 565.122 45.4682 563.608 45.1963C559.507 44.5235 559.211 43.1941 559.211 41.0845V37.8393C559.211 36.171 561.123 35.0974 564.901 34.6459C565.872 34.5211 588.404 34.4582 593.182 34.4582H594.476C598.55 34.4582 600.367 32.5727 600.367 28.3452V26.9733C600.367 22.7002 598.55 20.7944 594.476 20.7944C578.854 20.7944 563.884 21.5474 559.874 22.418C546.878 25.236 544.149 32.3485 544.149 37.818V41.1931C544.149 52.7451 555.188 59.3704 574.435 59.3704H604.202C614.36 59.3704 614.36 61.6262 614.36 64.015V66.3672C614.36 71.4024 611.654 71.6429 603.101 71.6429H550.289C544.589 71.6429 544.149 74.6932 544.149 79.0019C544.149 83.3603 545.986 85.2193 550.289 85.2193H603.039C625.257 85.2193 629.92 74.955 629.92 66.3367L629.899 63.5319Z" fill="#101828"/>
+<path d="M528.563 20.7944H524.961C519.815 20.7944 519.121 23.9696 519.121 27.0758V71.643H479.374C469.779 71.643 463.819 68.8717 463.819 64.4118L463.817 26.9957C463.817 22.6495 462.061 20.7945 457.946 20.7945H454.534C449.376 20.7945 448.681 23.9737 448.681 27.0839L448.689 43.0847L448.682 43.2156C448.672 43.3749 448.663 43.5342 448.663 43.7057C448.663 43.7067 448.681 56.7331 448.681 65.4174C448.681 70.3289 450.814 75.2139 454.534 78.8193C457.546 81.7388 463.05 85.2194 472.167 85.2194H519.121V99.7528C519.121 104.132 520.867 106.002 524.961 106.002H528.563C532.678 106.002 534.434 104.147 534.434 99.7781V26.9956C534.434 22.6494 532.678 20.7944 528.563 20.7944Z" fill="#101828"/>
+<path d="M181.294 9.4687L181.29 7.23929C181.29 3.47959 180.673 0 176.195 0H171.27C166.764 0 166.143 3.53032 166.143 7.34482V20.7944H127.832C101.154 20.7944 95.5543 32.0116 95.5543 41.4224C95.5543 47.0077 95.547 52.0266 95.5407 56.52C95.5354 60.1619 95.5305 63.4589 95.5305 66.4322C95.5305 81.96 113.199 85.2194 128.02 85.2194H148.1C155.515 85.2194 162.406 83.8495 168.582 81.1462C177.022 77.4433 181.301 71.9697 181.301 64.8745V9.67675C181.301 9.60468 181.297 9.53669 181.294 9.4687ZM110.856 63.9531V39.7775C110.856 37.7054 115.354 34.4186 127.422 34.4186L166.143 34.4358V64.6107C166.143 70.4232 155.626 71.6429 146.803 71.6429H127.832C122.72 71.6429 118.773 71.3436 116.716 70.7997C112.773 69.7606 110.856 67.521 110.856 63.9531Z" fill="#101828"/>
+<path d="M276.598 41.7309C276.598 27.2513 268.171 20.7944 249.274 20.7944L220.792 20.8188C219.822 20.8188 218.873 20.8117 217.944 20.8046C211.564 20.762 206.054 20.7163 201.415 23.0208C195.048 26.2153 191.098 32.1608 190.848 38.9668V64.3073C190.848 78.7869 199.361 85.2438 218.452 85.2438L249.046 85.2194C256.475 85.1575 262.798 83.8566 267.843 81.3522C275.555 77.4829 276.619 71.1122 276.619 64.8055L276.598 41.7309ZM206.044 40.8907C206.22 38.7719 208.06 37.1391 211.658 35.9062C214.525 34.9168 217.608 34.4358 221.082 34.4358H245.362C253.244 34.4358 261.396 36.8225 261.396 40.8166V64.8055L261.402 65.1464C261.226 67.2663 259.386 68.899 255.79 70.1309H255.788C252.872 71.1365 249.702 71.647 246.364 71.647H222.163C214.243 71.647 206.05 69.244 206.05 65.2215V41.2317L206.044 40.8907Z" fill="#101828"/>
+<path d="M70.4752 20.829C69.3421 20.829 68.0651 20.8523 66.6406 20.8787C63.2574 20.9416 59.0494 21.0197 53.9434 20.829H35.4277C35.3489 20.829 35.2775 20.8351 35.1806 20.8452C30.5295 20.969 29.5533 23.7687 29.5533 26.0966V29.1145C29.5533 31.558 30.5988 34.4704 35.5778 34.4704H54.1975C67.3329 34.4704 70.8805 34.4531 70.8805 45.6763H22.4322C13.6191 45.6763 7.87333 47.351 4.40709 50.6717C4.37962 50.698 4.3496 50.7224 4.32247 50.7489C1.27269 53.7246 0.0222152 58.0029 0.0213753 63.5665L0.00138582 66.1806C0.00138582 66.1806 0.00138582 66.1809 0.00138582 66.1811L0 66.3713C0 74.9897 4.66321 85.2539 26.881 85.2539H58.018C76.4332 85.2539 85.7707 78.6032 85.7707 65.4864V33.4313C85.7707 26.9531 78.3373 20.829 70.4752 20.829ZM68.9445 69.5039C67.8204 70.4953 65.0302 71.6775 58.1215 71.6775H26.8191C24.363 71.6775 22.3903 71.6571 20.8243 71.5095C20.5482 71.4835 20.285 71.4534 20.0338 71.4188C19.4085 71.3328 18.8601 71.2177 18.3806 71.0659C18.1375 70.9891 17.9126 70.9022 17.7046 70.8049C17.6152 70.7632 17.529 70.7192 17.4458 70.6734C17.1465 70.5082 16.8847 70.3176 16.6625 70.094C16.0872 69.5148 15.7603 68.7249 15.629 67.648C15.5827 67.2689 15.5599 66.8554 15.5599 66.4018V64.0496C15.5599 63.2605 15.5623 62.4866 15.9284 61.803C16.665 60.4279 18.8851 59.4215 25.5664 59.4062H25.5679C25.6191 59.406 25.6665 59.4051 25.7181 59.4051H70.9288L70.9375 62.22C70.9375 65.9218 70.271 68.3683 68.9445 69.5039Z" fill="#101828"/>
+</g>
+</g>
+<defs>
+<clipPath id="clip0_2411_6303">
+<rect width="630" height="107" fill="white"/>
+</clipPath>
+<clipPath id="clip1_2411_6303">
+<rect width="629.92" height="106.002" fill="white"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/public/partners/api-evangelist-logo-butterfly-transparent.png b/public/partners/api-evangelist-logo-butterfly-transparent.png
new file mode 100644
index 0000000..d6ae9a8
Binary files /dev/null and b/public/partners/api-evangelist-logo-butterfly-transparent.png differ
diff --git a/public/partners/apisfirst.svg b/public/partners/apisfirst.svg
new file mode 100644
index 0000000..4635b50
--- /dev/null
+++ b/public/partners/apisfirst.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="200" zoomAndPan="magnify" viewBox="0 0 150 52.499999" height="70" preserveAspectRatio="xMidYMid meet" version="1.2"><defs><clipPath id="7e36e39dfc"><path d="M 14.160156 14.117188 L 133 14.117188 L 133 37 L 14.160156 37 Z M 14.160156 14.117188 "/></clipPath></defs><g id="44adc75107"><g clip-rule="nonzero" clip-path="url(#7e36e39dfc)"><g mask="url(#6a93f00c90)" transform="matrix(0.196801,0,0,0.195175,14.159779,14.116354)"><image width="604" xlink:href="data:image/png;base64,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" height="118" preserveAspectRatio="xMidYMid meet"/><mask id="6a93f00c90"><g transform="matrix(1,0,0,1,0,0)"><image width="604" xlink:href="data:image/png;base64,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" height="118" preserveAspectRatio="xMidYMid meet"/></g></mask></g></g></g></svg>
\ No newline at end of file
diff --git a/public/partners/osaango-black.svg b/public/partners/osaango-black.svg
new file mode 100644
index 0000000..7e1de37
--- /dev/null
+++ b/public/partners/osaango-black.svg
@@ -0,0 +1,286 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   width="708.75"
+   height="285"
+   viewBox="0 0 708.75 285"
+   version="1.2"
+   id="svg39"
+   sodipodi:docname="osaango-black.svg"
+   inkscape:version="1.4.2 (f4327f4, 2025-05-13)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview1"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:zoom="5.2035273"
+     inkscape:cx="458.72729"
+     inkscape:cy="142.49949"
+     inkscape:window-width="3840"
+     inkscape:window-height="2054"
+     inkscape:window-x="-11"
+     inkscape:window-y="-11"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="g39" />
+  <defs
+     id="defs19">
+    <clipPath
+       id="d">
+      <path
+         d="M0 67h93v93H0Zm0 0"
+         id="path1" />
+    </clipPath>
+    <clipPath
+       id="e">
+      <path
+         d="M46.3 67.414q-2.254 0-4.503.223a46.3 46.3 0 0 0-8.832 1.754 47 47 0 0 0-4.246 1.515 46.2 46.2 0 0 0-11.566 6.918 45 45 0 0 0-3.34 3.024 45 45 0 0 0-3.028 3.336 45 45 0 0 0-2.687 3.613 47 47 0 0 0-2.32 3.86 46 46 0 0 0-1.926 4.07 45.5 45.5 0 0 0-2.613 8.602 45.4 45.4 0 0 0-.883 8.945 45.4 45.4 0 0 0 .882 8.949 45 45 0 0 0 1.094 4.363 46.4 46.4 0 0 0 3.445 8.309 47 47 0 0 0 2.32 3.859 45 45 0 0 0 2.688 3.613 45 45 0 0 0 3.028 3.336 45 45 0 0 0 3.34 3.024 46.2 46.2 0 0 0 11.566 6.918 47 47 0 0 0 4.246 1.515 46.3 46.3 0 0 0 13.336 1.977q2.261 0 4.504-.223 2.248-.221 4.46-.66a46 46 0 0 0 4.376-1.094 45.6 45.6 0 0 0 8.32-3.441 45 45 0 0 0 3.867-2.313 46 46 0 0 0 3.625-2.68 46 46 0 0 0 6.367-6.359 45.4 45.4 0 0 0 5.004-7.473 46 46 0 0 0 1.93-4.07 46 46 0 0 0 1.52-4.238q.654-2.155 1.093-4.363a46 46 0 0 0 .664-4.453 47 47 0 0 0 .219-4.497q.001-2.249-.227-4.492a46 46 0 0 0-.664-4.449 45.4 45.4 0 0 0-2.62-8.598 45 45 0 0 0-1.93-4.066 45.4 45.4 0 0 0-5.004-7.473 46.1 46.1 0 0 0-9.989-9.035 47 47 0 0 0-3.863-2.316 46 46 0 0 0-4.074-1.922 45 45 0 0 0-4.246-1.52 45 45 0 0 0-4.371-1.097 46.3 46.3 0 0 0-8.961-.89m0 74.059a28.5 28.5 0 0 1-5.51-.543 28 28 0 0 1-5.3-1.605 28 28 0 0 1-2.506-1.18 28 28 0 0 1-2.379-1.426 28 28 0 0 1-2.226-1.649 27 27 0 0 1-2.055-1.855 27 27 0 0 1-1.863-2.05 28.1 28.1 0 0 1-4.262-7.098 28 28 0 0 1-.937-2.606 28.2 28.2 0 0 1 0-16.371q.406-1.326.933-2.606a28.2 28.2 0 0 1 6.125-9.148 29 29 0 0 1 2.055-1.86 28.1 28.1 0 0 1 7.113-4.254 29 29 0 0 1 2.61-.933 29 29 0 0 1 2.691-.672c.906-.18 1.82-.312 2.742-.406.918-.09 1.844-.133 2.77-.133q1.387-.001 2.77.133 1.376.14 2.742.406 1.358.272 2.687.672 1.331.405 2.61.934a28.2 28.2 0 0 1 9.167 6.113 27.7 27.7 0 0 1 3.512 4.273q.775 1.151 1.426 2.371a28 28 0 0 1 2.12 5.11q.404 1.324.673 2.683a28.2 28.2 0 0 1 .406 8.266 29 29 0 0 1-.41 2.734q-.27 1.36-.676 2.684t-.933 2.602q-.532 1.282-1.188 2.5a28 28 0 0 1-4.937 6.644 29 29 0 0 1-2.055 1.86 28.5 28.5 0 0 1-7.105 4.254 28.4 28.4 0 0 1-5.297 1.609q-1.36.27-2.743.406-1.381.14-2.77.14m0 0"
+         id="path2" />
+    </clipPath>
+    <clipPath
+       id="f">
+      <path
+         d="M616 67h92.5v93H616Zm0 0"
+         id="path3" />
+    </clipPath>
+    <clipPath
+       id="g">
+      <path
+         d="M662.453 67.414a46.5 46.5 0 0 0-8.965.883 46 46 0 0 0-4.375 1.094 46 46 0 0 0-8.32 3.441 45 45 0 0 0-3.867 2.313 46 46 0 0 0-3.625 2.68 46 46 0 0 0-6.367 6.359 45.4 45.4 0 0 0-5.004 7.473 46 46 0 0 0-1.93 4.07 45.5 45.5 0 0 0-2.613 8.602 46 46 0 0 0-.664 4.452 47 47 0 0 0-.22 4.492q.001 2.257.22 4.497a46 46 0 0 0 1.757 8.816 46 46 0 0 0 1.52 4.238 45 45 0 0 0 1.93 4.07 45.4 45.4 0 0 0 5.004 7.473 45 45 0 0 0 3.027 3.336 45 45 0 0 0 3.34 3.024 45.6 45.6 0 0 0 7.492 4.992 45 45 0 0 0 4.074 1.926 47 47 0 0 0 4.246 1.515q2.162.655 4.375 1.094a46.3 46.3 0 0 0 8.965.883q2.256 0 4.5-.223c1.5-.148 2.984-.367 4.461-.66a46 46 0 0 0 4.375-1.094 47 47 0 0 0 4.246-1.515 45 45 0 0 0 4.074-1.926 45.6 45.6 0 0 0 7.493-4.992 45 45 0 0 0 3.34-3.024 45 45 0 0 0 3.027-3.336 45.4 45.4 0 0 0 5.004-7.473 45 45 0 0 0 1.93-4.07 46 46 0 0 0 1.519-4.238q.654-2.155 1.094-4.363a46 46 0 0 0 .664-4.453q.217-2.24.218-4.497a45.5 45.5 0 0 0-.89-8.941 45.4 45.4 0 0 0-2.621-8.598 46 46 0 0 0-1.926-4.066 47 47 0 0 0-2.32-3.86 46 46 0 0 0-2.688-3.613 45 45 0 0 0-3.027-3.332 45 45 0 0 0-3.34-3.023 47 47 0 0 0-3.617-2.68 45 45 0 0 0-3.867-2.312 45 45 0 0 0-4.075-1.926 46 46 0 0 0-4.242-1.52 47 47 0 0 0-4.37-1.097 46.3 46.3 0 0 0-8.962-.89m0 74.059a28.5 28.5 0 0 1-5.512-.543c-.91-.18-1.804-.403-2.691-.672a27 27 0 0 1-2.61-.934 28 28 0 0 1-2.507-1.18q-1.225-.654-2.38-1.425a28 28 0 0 1-2.226-1.649 29 29 0 0 1-2.054-1.855 29 29 0 0 1-1.864-2.05 28.4 28.4 0 0 1-4.261-7.099 28 28 0 0 1-.934-2.605 28 28 0 0 1-.672-2.684 28 28 0 0 1-.41-2.738q-.134-1.377-.133-2.766-.001-1.383.133-2.761c.094-.922.227-1.832.406-2.739a28.7 28.7 0 0 1 1.61-5.289c.355-.855.75-1.687 1.183-2.504.438-.812.914-1.605 1.426-2.37a29 29 0 0 1 1.652-2.223 27 27 0 0 1 1.864-2.051 28 28 0 0 1 4.28-3.508 28 28 0 0 1 2.38-1.422 29 29 0 0 1 2.504-1.183 29 29 0 0 1 2.613-.934 29 29 0 0 1 2.688-.672c.906-.18 1.82-.312 2.742-.406q1.381-.134 2.77-.133 1.387-.001 2.769.133 1.383.14 2.742.406 1.36.272 2.691.672 1.325.405 2.61.934a28.23 28.23 0 0 1 15.289 15.261q.534 1.28.933 2.606.405 1.324.676 2.683a28 28 0 0 1 .543 5.5 28.4 28.4 0 0 1-.55 5.5q-.271 1.36-.676 2.684-.4 1.324-.934 2.602-.532 1.282-1.188 2.5-.651 1.222-1.425 2.375a28 28 0 0 1-3.512 4.27 28.7 28.7 0 0 1-4.277 3.508q-1.155.765-2.38 1.42-1.22.651-2.503 1.184a29 29 0 0 1-5.297 1.61q-1.359.27-2.742.406-1.377.14-2.766.14m0 0"
+         id="path4" />
+    </clipPath>
+    <clipPath
+       id="h">
+      <path
+         d="M191 67h93v93h-93zm0 0"
+         id="path5" />
+    </clipPath>
+    <clipPath
+       id="i">
+      <path
+         d="M237.785 67.414a46 46 0 0 0-4.515.207q-2.254.21-4.473.645-2.224.432-4.39 1.082a46.3 46.3 0 0 0-8.352 3.422 46 46 0 0 0-7.524 4.992 45.5 45.5 0 0 0-6.398 6.36 46 46 0 0 0-8.492 15.808 46 46 0 0 0-1.098 4.375 45.6 45.6 0 0 0 0 17.938q.44 2.215 1.098 4.378a45.7 45.7 0 0 0 5.797 12.187 47 47 0 0 0 2.695 3.622 47 47 0 0 0 3.043 3.336 46 46 0 0 0 6.992 5.703 47 47 0 0 0 3.887 2.308 45 45 0 0 0 4.09 1.918 46 46 0 0 0 4.261 1.508c1.446.434 2.906.793 4.39 1.082q2.22.434 4.474.645 2.251.212 4.515.203c4.078 0 18.09-.961 28.25-13.246v13.246h17.695v-45.86a46.3 46.3 0 0 0-.89-8.941 47 47 0 0 0-1.098-4.363 46.3 46.3 0 0 0-3.453-8.301 45.4 45.4 0 0 0-5.004-7.473 46.1 46.1 0 0 0-9.984-9.035 47 47 0 0 0-3.867-2.312 45 45 0 0 0-4.075-1.926 46 46 0 0 0-4.242-1.52 47 47 0 0 0-4.37-1.097 46.3 46.3 0 0 0-8.962-.89m0 74.059a28.5 28.5 0 0 1-5.512-.543c-.91-.18-1.804-.403-2.691-.672a28 28 0 0 1-2.61-.934 28 28 0 0 1-2.507-1.18q-1.225-.654-2.38-1.425a28 28 0 0 1-2.226-1.649 29 29 0 0 1-2.054-1.855 29 29 0 0 1-1.864-2.05 28.4 28.4 0 0 1-4.261-7.099 30 30 0 0 1-.934-2.605 28 28 0 0 1-.672-2.684 28 28 0 0 1-.41-2.738q-.134-1.377-.133-2.766-.001-1.383.133-2.761c.094-.922.227-1.832.406-2.739a28.7 28.7 0 0 1 1.61-5.289c.355-.855.75-1.687 1.183-2.504.438-.812.914-1.605 1.426-2.37a29 29 0 0 1 1.652-2.223 27 27 0 0 1 1.864-2.051 28 28 0 0 1 4.28-3.508 28 28 0 0 1 2.38-1.422 29 29 0 0 1 2.504-1.183 29 29 0 0 1 2.613-.934 29 29 0 0 1 2.688-.672c.906-.18 1.824-.312 2.742-.406q1.381-.134 2.77-.133 1.387-.001 2.769.133 1.383.14 2.742.406 1.363.272 2.691.672 1.325.405 2.61.934a28.23 28.23 0 0 1 12.68 10.386q.768 1.151 1.425 2.371a28 28 0 0 1 1.184 2.504q.534 1.28.933 2.606.406 1.324.676 2.683a28 28 0 0 1 .543 5.5q0 1.389-.14 2.766-.136 1.376-.407 2.734-.276 1.36-.676 2.684-.404 1.324-.937 2.602-.532 1.282-1.187 2.5-.653 1.222-1.422 2.375a28.7 28.7 0 0 1-3.516 4.27 28 28 0 0 1-6.656 4.929q-1.22.65-2.504 1.183a29 29 0 0 1-5.297 1.61q-1.36.27-2.738.406-1.382.14-2.77.14m0 0"
+         id="path6" />
+    </clipPath>
+    <clipPath
+       id="j">
+      <path
+         d="M295 67h93v93h-93zm0 0"
+         id="path7" />
+    </clipPath>
+    <clipPath
+       id="k">
+      <path
+         d="M341.684 67.414q-2.25.011-4.489.238a46.1 46.1 0 0 0-13.039 3.305 46 46 0 0 0-4.058 1.934 45.6 45.6 0 0 0-7.457 5q-1.74 1.43-3.329 3.02a47 47 0 0 0-3.015 3.331 46 46 0 0 0-2.672 3.61 46 46 0 0 0-2.309 3.855 47 47 0 0 0-1.918 4.059 46 46 0 0 0-2.602 8.586 45 45 0 0 0-.655 4.437 45.3 45.3 0 0 0 0 8.969q.216 2.238.656 4.441a46 46 0 0 0 1.09 4.356 45 45 0 0 0 1.511 4.226 47 47 0 0 0 1.918 4.063 46.3 46.3 0 0 0 4.98 7.46 46 46 0 0 0 9.95 9.04 46 46 0 0 0 3.852 2.316q1.982 1.068 4.058 1.93a47 47 0 0 0 4.23 1.527q2.157.659 4.36 1.106a46 46 0 0 0 4.45.675q2.237.228 4.488.235c4.082 0 18.093-.961 28.253-13.246v13.246h17.696v-45.86q-.002-2.249-.227-4.492a46 46 0 0 0-.664-4.449 47 47 0 0 0-1.097-4.363 45 45 0 0 0-1.524-4.235 45 45 0 0 0-1.93-4.066 45.4 45.4 0 0 0-5.004-7.473 46 46 0 0 0-6.367-6.355 47 47 0 0 0-3.62-2.68 46 46 0 0 0-3.864-2.312 46 46 0 0 0-4.074-1.926 45 45 0 0 0-4.246-1.52 45 45 0 0 0-4.371-1.097 46.3 46.3 0 0 0-8.961-.89m0 17.664c.925 0 1.851.043 2.77.137q1.38.133 2.745.402c.906.184 1.805.406 2.688.676q1.33.4 2.613.93 1.278.533 2.504 1.183 1.225.656 2.379 1.422 1.155.772 2.226 1.649a27 27 0 0 1 2.055 1.859 27 27 0 0 1 1.863 2.05 29 29 0 0 1 1.653 2.223q.771 1.15 1.425 2.375a27.6 27.6 0 0 1 2.122 5.106 28.2 28.2 0 0 1 0 16.371q-.405 1.323-.934 2.605-.533 1.28-1.188 2.5a28.4 28.4 0 0 1-3.074 4.598q-.884 1.072-1.863 2.05-.983.978-2.055 1.856a28 28 0 0 1-2.226 1.649 28 28 0 0 1-4.887 2.61 28 28 0 0 1-2.61.929q-1.328.403-2.687.672a28.4 28.4 0 0 1-8.281.406 27 27 0 0 1-2.742-.406q-1.363-.27-2.692-.672a28 28 0 0 1-5.117-2.113q-1.225-.655-2.379-1.422a29 29 0 0 1-2.226-1.649 28 28 0 0 1-3.914-3.91 28 28 0 0 1-3.078-4.598 28 28 0 0 1-1.188-2.5 29 29 0 0 1-.934-2.605 28.2 28.2 0 0 1-1.078-10.95q.14-1.374.41-2.734.274-1.359.676-2.683a28.4 28.4 0 0 1 3.547-7.477 28.7 28.7 0 0 1 3.512-4.27 29 29 0 0 1 2.054-1.859A29 29 0 0 1 326 89.84a28 28 0 0 1 2.375-1.422 27 27 0 0 1 2.504-1.184 27 27 0 0 1 2.61-.933q1.328-.405 2.687-.676 1.359-.27 2.742-.41c.918-.09 1.844-.137 2.766-.137m0 0"
+         id="path8" />
+    </clipPath>
+    <clipPath
+       id="l">
+      <path
+         d="M101 67h81v93h-81zm0 0"
+         id="path9" />
+    </clipPath>
+    <clipPath
+       id="m">
+      <path
+         d="m148.39 106.2-2.5-.41c-7.027-1.067-12.035-2.177-15.312-3.392-4.973-1.832-6.015-5.351-6.015-7.976 0-2.285.93-5.531 5.382-8.016 3.215-1.804 7.797-2.683 14.008-2.683a56.3 56.3 0 0 1 12.242 1.273 56.2 56.2 0 0 1 11.676 3.887l2.024.933 7.28-15.523-2.066-.934a60.5 60.5 0 0 0-11.941-3.832 89 89 0 0 0-19.215-2.113c-11.629 0-32.156 2.344-38.976 18.035-4.274 9.82-1.711 21.34 6.093 27.395 7.434 5.777 17.715 7.332 26.778 8.703l.46.074c6.684.828 11.54 1.828 14.848 3.047 4.973 1.844 6.02 5.168 6.02 7.637 0 6.984-6.465 10.523-19.211 10.523a68.2 68.2 0 0 1-15.125-1.86 68.4 68.4 0 0 1-14.34-5.152l-2.066-1.046-7.286 15.652 1.915.98a66 66 0 0 0 13.671 4.946 88.7 88.7 0 0 0 22.184 2.785c8.832 0 16.55-1.211 22.937-3.59 8.125-3.031 14.942-9.441 17.793-16.73q.851-2.111 1.227-4.356c.254-1.492.344-3 .266-4.512a21 21 0 0 0-2.363-8.68C173.16 110.2 160 108.076 148.39 106.2m0 0"
+         id="path10" />
+    </clipPath>
+    <clipPath
+       id="n">
+      <path
+         d="M406 67h93v93h-93zm0 0"
+         id="path11" />
+    </clipPath>
+    <clipPath
+       id="o">
+      <path
+         d="M452.48 67.414a46.3 46.3 0 0 0-13.332 1.988 46 46 0 0 0-4.242 1.52 46 46 0 0 0-4.074 1.926 47 47 0 0 0-3.863 2.312 48 48 0 0 0-3.621 2.68 46 46 0 0 0-6.368 6.355 47 47 0 0 0-2.683 3.614 47 47 0 0 0-2.32 3.859 47 47 0 0 0-1.93 4.066 46 46 0 0 0-1.52 4.235 46.3 46.3 0 0 0-1.766 8.813 46 46 0 0 0-.222 4.491v45.86h17.695v-45.86a28 28 0 0 1 .121-2.773 28.3 28.3 0 0 1 1.06-5.441q.397-1.332.925-2.618a28.4 28.4 0 0 1 4.254-7.132 27 27 0 0 1 1.863-2.063 28 28 0 0 1 2.055-1.871 28.7 28.7 0 0 1 4.613-3.09q1.228-.655 2.516-1.187 1.281-.538 2.617-.942c.887-.27 1.785-.492 2.695-.676a28.4 28.4 0 0 1 5.531-.542 28.5 28.5 0 0 1 8.227 1.219q1.33.403 2.617.94 1.285.532 2.512 1.188a28 28 0 0 1 2.383 1.434 28 28 0 0 1 4.289 3.527 28 28 0 0 1 1.86 2.063 28 28 0 0 1 3.074 4.617 28.3 28.3 0 0 1 2.105 5.133q.399 1.33.664 2.695a28.3 28.3 0 0 1 .52 5.52v45.859h17.69v-45.86q.002-2.249-.226-4.492a45 45 0 0 0-.664-4.449 45.4 45.4 0 0 0-2.62-8.598 46 46 0 0 0-1.927-4.066 47 47 0 0 0-2.32-3.86 46.3 46.3 0 0 0-5.711-6.945 47 47 0 0 0-3.34-3.02 47 47 0 0 0-3.62-2.683 46 46 0 0 0-3.868-2.312 45 45 0 0 0-4.07-1.926 46.4 46.4 0 0 0-8.617-2.617 46.3 46.3 0 0 0-8.962-.89m0 0"
+         id="path12" />
+    </clipPath>
+    <clipPath
+       id="p">
+      <path
+         d="M592 45.703h24V70h-24zm0 0"
+         id="path13" />
+    </clipPath>
+    <clipPath
+       id="q">
+      <path
+         d="M610.55 47.79a12 12 0 0 0-2.01-1.118 12 12 0 0 0-2.188-.703 11.8 11.8 0 0 0-4.579-.074q-1.137.204-2.21.632-1.08.422-2.047 1.047c-.649.418-1.25.89-1.805 1.426a12 12 0 0 0-1.484 1.754 11.6 11.6 0 0 0-1.825 4.191 11.8 11.8 0 0 0-.074 4.567c.14.758.348 1.492.633 2.21q.423 1.073 1.05 2.04a12 12 0 0 0 1.43 1.8q.805.827 1.754 1.485a11.6 11.6 0 0 0 2.012 1.113q1.061.458 2.191.703a11.8 11.8 0 0 0 4.575.075 11.6 11.6 0 0 0 2.215-.633 11.5 11.5 0 0 0 2.042-1.047q.973-.627 1.805-1.43a12 12 0 0 0 1.485-1.75q.667-.944 1.128-2.004a11.6 11.6 0 0 0 .715-2.183 11.6 11.6 0 0 0 .266-2.286q.024-1.156-.188-2.289a11.4 11.4 0 0 0-.632-2.21 12 12 0 0 0-1.055-2.044 12 12 0 0 0-1.441-1.796 11.6 11.6 0 0 0-1.762-1.477m0 0"
+         id="path14" />
+    </clipPath>
+    <clipPath
+       id="r">
+      <path
+         d="M512 66h97v173.016h-97zm0 0"
+         id="path15" />
+    </clipPath>
+    <clipPath
+       id="s">
+      <path
+         d="m584.441 153.32-36.726-21.746-2.266-1.363c-7.648-4.598-12.21-12.422-12.21-20.934 0-13.66 11.73-24.777 26.148-24.777 14.422 0 26.148 11.117 26.148 24.781 0 9.223-5.312 17.434-13.734 21.73l17.21 9.946c9.563-8.012 15.208-19.422 15.208-31.676 0-23.43-20.114-42.488-44.832-42.488-24.719 0-44.836 19.055-44.836 42.488 0 15.2 8.691 29.34 22.601 36.871l37.453 22.11 1.797 1.082c8.7 5.23 13.895 14.129 13.895 23.812 0 15.547-13.352 28.196-29.754 28.196-16.406 0-29.75-12.645-29.75-28.196 0-10.988 7.004-21.039 17.52-25.582l-17.704-10.304c-11.59 8.68-18.449 21.793-18.449 35.886 0 25.29 21.703 45.86 48.383 45.86 26.676 0 48.387-20.57 48.387-45.86 0-16.441-9.371-31.664-24.489-39.836m0 0"
+         id="path16" />
+    </clipPath>
+    <linearGradient
+       id="b">
+      <stop
+         style="stop-color:#1f2d2a;stop-opacity:1"
+         offset="0"
+         id="stop16" />
+      <stop
+         style="stop-color:#1f2d2a;stop-opacity:0"
+         offset="1"
+         id="stop17" />
+    </linearGradient>
+    <linearGradient
+       id="a">
+      <stop
+         style="stop-color:#000000;stop-opacity:1;"
+         offset="0"
+         id="stop18" />
+      <stop
+         style="stop-color:#1f2d2a;stop-opacity:1"
+         offset="1"
+         id="stop19" />
+    </linearGradient>
+    <linearGradient
+       xlink:href="#a"
+       id="c"
+       x1=".355"
+       y1="142.361"
+       x2="708.398"
+       y2="142.361"
+       gradientUnits="userSpaceOnUse" />
+    <linearGradient
+       xlink:href="#b"
+       id="t"
+       x1="192.752"
+       y1="113.6"
+       x2="283.141"
+       y2="113.6"
+       gradientUnits="userSpaceOnUse" />
+  </defs>
+  <g
+     style="fill:#000000;fill-opacity:1;stroke:url(#c);stroke-opacity:1"
+     id="g39">
+    <g
+       clip-path="url(#d)"
+       style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-opacity:1"
+       id="g20">
+      <g
+         clip-path="url(#e)"
+         style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-opacity:1"
+         id="g19">
+        <path
+           style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-opacity:1"
+           d="M.355 67.414v91.723H92.25V67.414Zm0 0"
+           id="path19" />
+      </g>
+    </g>
+    <g
+       clip-path="url(#f)"
+       style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-opacity:1"
+       id="g22">
+      <g
+         clip-path="url(#g)"
+         style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-opacity:1"
+         id="g21">
+        <path
+           style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-opacity:1"
+           d="M616.504 67.414v91.723h91.894V67.414Zm0 0"
+           id="path20" />
+      </g>
+    </g>
+    <g
+       clip-path="url(#h)"
+       style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-opacity:1"
+       id="g24">
+      <g
+         clip-path="url(#i)"
+         style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-opacity:1"
+         id="g23">
+        <path
+           style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-opacity:1"
+           d="M191.652 67.41v91.73h92.078V67.41Zm0 0"
+           id="path22" />
+      </g>
+    </g>
+    <g
+       clip-path="url(#j)"
+       style="fill:#000000;fill-opacity:1;stroke:#004d50;stroke-opacity:1"
+       id="g26">
+      <g
+         clip-path="url(#k)"
+         style="fill:#000000;fill-opacity:1;stroke:#004d50;stroke-opacity:1"
+         id="g25">
+        <path
+           style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#004d50;stroke-opacity:1"
+           d="M295.918 67.414v91.719h91.715V67.414Zm0 0"
+           id="path24" />
+      </g>
+    </g>
+    <g
+       clip-path="url(#l)"
+       style="fill:#000000;fill-opacity:1;stroke:#004d50;stroke-opacity:1"
+       id="g28">
+      <g
+         clip-path="url(#m)"
+         style="fill:#000000;fill-opacity:1;stroke:#004d50;stroke-opacity:1"
+         id="g27">
+        <path
+           style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#004d50;stroke-opacity:1"
+           d="M100.703 67.414v91.727h80.516V67.414Zm0 0"
+           id="path26" />
+      </g>
+    </g>
+    <g
+       clip-path="url(#n)"
+       style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-opacity:1"
+       id="g30">
+      <g
+         clip-path="url(#o)"
+         style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-opacity:1"
+         id="g29">
+        <path
+           style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-opacity:1"
+           d="M406.54 67.414v91.719h91.886V67.414Zm0 0"
+           id="path28" />
+      </g>
+    </g>
+    <g
+       clip-path="url(#p)"
+       style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-opacity:1"
+       id="g32">
+      <g
+         clip-path="url(#q)"
+         style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-opacity:1"
+         id="g31">
+        <path
+           style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-opacity:1"
+           d="M592.129 45.703v23.434h23.516V45.703Zm0 0"
+           id="path30" />
+      </g>
+    </g>
+    <g
+       clip-path="url(#r)"
+       style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-opacity:1"
+       id="g34">
+      <g
+         clip-path="url(#s)"
+         style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-opacity:1"
+         id="g33">
+        <path
+           style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-opacity:1"
+           d="M512.16 66.793v172.223h96.77V66.793Zm0 0"
+           id="path32" />
+      </g>
+    </g>
+  </g>
+</svg>
diff --git a/scripts/check-package-contents.mjs b/scripts/check-package-contents.mjs
index 62b7aa8..19514a2 100644
--- a/scripts/check-package-contents.mjs
+++ b/scripts/check-package-contents.mjs
@@ -45,6 +45,15 @@ function assertHasFiles(fileSet, requiredFiles, label) {
   }
 }
 
+function assertDoesNotHaveFiles(fileSet, forbiddenFiles, label) {
+  for (const file of forbiddenFiles) {
+    if (fileSet.has(file)) {
+      console.error(`[${label}] Unexpected packaged file: ${file}`);
+      process.exit(1);
+    }
+  }
+}
+
 const pkg = JSON.parse(readFileSync("package.json", "utf8"));
 if (!Array.isArray(pkg.files) || !pkg.files.includes("src/schemas/")) {
   console.error('package.json files must include "src/schemas/".');
@@ -101,7 +110,6 @@ assertHasFiles(
   createApiopsFiles,
   [
     "bin/create-apiops-project.js",
-    "bin/method-cli.js",
     "bin/check-node-version.js",
     "template/AGENTS.md",
     "template/README.md",
@@ -110,5 +118,6 @@ assertHasFiles(
   ],
   "create-apiops"
 );
+assertDoesNotHaveFiles(createApiopsFiles, ["bin/method-cli.js"], "create-apiops");
 
 console.log("Root and create-apiops package content inspection passed.");
diff --git a/scripts/test-create-apiops-scaffold.mjs b/scripts/test-create-apiops-scaffold.mjs
index dd116a8..65a6c3c 100644
--- a/scripts/test-create-apiops-scaffold.mjs
+++ b/scripts/test-create-apiops-scaffold.mjs
@@ -2,7 +2,7 @@ import { fileURLToPath } from "node:url";
 import { dirname, resolve, join } from "node:path";
 import { mkdtempSync, readFileSync, existsSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -38,6 +38,7 @@ const projectName = "ci-apiops-project";
 const projectDir = join(tempRoot, projectName);
 let localTarball = null;
 const npmCommand = resolveNpmCommand();
+const runInstallIntegration = process.argv.includes("--install-integration");
 
 function assert(condition, message) {
   if (!condition) {
@@ -45,7 +46,105 @@ function assert(condition, message) {
   }
 }
 
+function runStep(label, command, args, options = {}) {
+  const timeout = options.timeout ?? 180000;
+  console.log(`\n[create-apiops test] ${label}`);
+  try {
+    return execFileSync(command, args, {
+      timeout,
+      ...options
+    });
+  } catch (error) {
+    if (error.code === "ETIMEDOUT") {
+      const commandLine = [command, ...args].join(" ");
+      throw new Error(`[create-apiops test] ${label} timed out after ${timeout} ms.\nCommand: ${commandLine}`);
+    }
+    throw error;
+  }
+}
+
 try {
+  const helpOutput = execFileSync(
+    "node",
+    [cliPath, "--help"],
+    { cwd: tempRoot, encoding: "utf8" }
+  );
+  assert(helpOutput.includes("Usage:"), "Expected create-apiops --help to print usage.");
+  assert(
+    helpOutput.includes("npm create apiops@latest -- --name my-api"),
+    "Expected help output to document npm-create flag forwarding."
+  );
+  assert(
+    !existsSync(join(tempRoot, "my-api-project")),
+    "Expected create-apiops --help to exit without creating the default project."
+  );
+
+  const nonInteractivePrompt = spawnSync(
+    "node",
+    [cliPath, "needs-prompt-answers"],
+    { cwd: tempRoot, encoding: "utf8" }
+  );
+  assert(
+    nonInteractivePrompt.status === 1,
+    "Expected omitted answers in a non-interactive shell to fail clearly instead of waiting for prompts."
+  );
+  assert(
+    nonInteractivePrompt.stderr.includes("cannot prompt"),
+    "Expected non-interactive prompt failure to explain the prompt problem."
+  );
+  assert(
+    nonInteractivePrompt.stderr.includes("--yes"),
+    "Expected non-interactive prompt failure to recommend --yes."
+  );
+
+  const invalidCycleProjectName = "invalid-cycle-project";
+  const invalidCycleResult = spawnSync(
+    "node",
+    [
+      cliPath,
+      "--name", invalidCycleProjectName,
+      "--cycle", "not-a-cycle",
+      "--yes",
+      "--no-install"
+    ],
+    { cwd: tempRoot, encoding: "utf8" }
+  );
+  assert(
+    invalidCycleResult.status === 1,
+    "Expected an unknown --cycle value to fail before scaffolding."
+  );
+  assert(
+    invalidCycleResult.stderr.includes("Unknown APIOps cycle: not-a-cycle"),
+    "Expected invalid cycle failure to explain the unknown cycle."
+  );
+  assert(
+    invalidCycleResult.stderr.includes("api-productization-cycle"),
+    "Expected invalid cycle failure to list supported cycles."
+  );
+  assert(
+    !existsSync(join(tempRoot, invalidCycleProjectName)),
+    "Expected invalid cycle failure to avoid creating the project directory."
+  );
+
+  const positionalProjectName = "positional-apiops-project";
+  const positionalProjectDir = join(tempRoot, positionalProjectName);
+  execFileSync(
+    "node",
+    [
+      cliPath,
+      positionalProjectName,
+      "--yes",
+      "--no-install"
+    ],
+    { cwd: tempRoot, stdio: "inherit" }
+  );
+
+  const positionalPkg = JSON.parse(readFileSync(join(positionalProjectDir, "package.json"), "utf8"));
+  assert(
+    positionalPkg.name === positionalProjectName,
+    "Expected first positional argument to set the scaffolded project name."
+  );
+
   execFileSync(
     "node",
     [
@@ -105,7 +204,13 @@ try {
     "Expected scaffolded OpenAPI file to contain the canonical OpenAPI snippet content."
   );
 
-  const packJson = execFileSync(
+  if (!runInstallIntegration) {
+    console.log("create-apiops scaffold fast test passed.");
+    console.log("Install-heavy generated project integration was skipped. Run `npm run test:create-apiops:integration` to include npm install and generated project commands.");
+  } else {
+
+  const packJson = runStep(
+    "Packing apiops-cycles-method-data for generated-project install",
     npmCommand.command,
     [...npmCommand.args, "pack", "--json", "--cache", npmCacheDir],
     { cwd: repoRoot, encoding: "utf8" }
@@ -113,7 +218,8 @@ try {
   localTarball = JSON.parse(packJson)[0]?.filename;
   assert(localTarball, "Failed to create local apiops-cycles-method-data tarball for integration test.");
 
-  execFileSync(
+  runStep(
+    "Installing local package tarball into generated project",
     npmCommand.command,
     [...npmCommand.args, "install", resolve(repoRoot, localTarball), "--cache", npmCacheDir],
     {
@@ -122,7 +228,8 @@ try {
     }
   );
 
-  const engineImportOutput = execFileSync(
+  const engineImportOutput = runStep(
+    "Checking generated project method-engine import",
     process.execPath,
     [
       "--input-type=module",
@@ -139,18 +246,19 @@ try {
     "Expected installed package to expose the reusable method-engine export."
   );
 
-  execFileSync(npmCommand.command, [...npmCommand.args, "run", "method:stations", "--cache", npmCacheDir], {
+  runStep("Running generated project method:stations", npmCommand.command, [...npmCommand.args, "run", "method:stations", "--cache", npmCacheDir], {
     cwd: projectDir,
     stdio: "inherit"
   });
 
-  execFileSync(npmCommand.command, [...npmCommand.args, "run", "method:start", "--cache", npmCacheDir], {
+  runStep("Running generated project method:start", npmCommand.command, [...npmCommand.args, "run", "method:start", "--cache", npmCacheDir], {
     cwd: projectDir,
     stdio: "inherit"
   });
 
   const guidedAnswers = Array.from({ length: 21 }, () => "no").join(",");
-  const guidedStartOutput = execFileSync(
+  const guidedStartOutput = runStep(
+    "Checking generated project guided start flow",
     process.execPath,
     [
       join(projectDir, installedMethodCliPath),
@@ -165,7 +273,7 @@ try {
     }
   );
   assert(
-    guidedStartOutput.includes("Recommended start station: API Product Strategy - Turn APIs Into Strategic Products (api-product-strategy)"),
+    guidedStartOutput.includes("Recommended start station: API Product Strategy (api-product-strategy)"),
     "Expected guided start flow to recommend API Product Strategy when all answers are no."
   );
   assert(
@@ -173,7 +281,8 @@ try {
     "Expected guided start flow to show interactive next-step options."
   );
 
-  const interactiveResourcesOutput = execFileSync(
+  const interactiveResourcesOutput = runStep(
+    "Checking generated project interactive resources flow",
     process.execPath,
     [
       join(projectDir, installedMethodCliPath),
@@ -192,12 +301,12 @@ try {
     "Expected interactive resources flow to create or show starter canvas JSON."
   );
 
-  execFileSync(npmCommand.command, [...npmCommand.args, "run", "method:resources:strategy", "--cache", npmCacheDir], {
+  runStep("Running generated project method:resources:strategy", npmCommand.command, [...npmCommand.args, "run", "method:resources:strategy", "--cache", npmCacheDir], {
     cwd: projectDir,
     stdio: "inherit"
   });
 
-  execFileSync(npmCommand.command, [...npmCommand.args, "run", "method:canvases:new-api", "--cache", npmCacheDir], {
+  runStep("Running generated project method:canvases:new-api", npmCommand.command, [...npmCommand.args, "run", "method:canvases:new-api", "--cache", npmCacheDir], {
     cwd: projectDir,
     stdio: "inherit"
   });
@@ -219,6 +328,7 @@ try {
   }
 
   console.log("create-apiops scaffold integration test passed.");
+  }
 } finally {
   if (localTarball) {
     rmSync(resolve(repoRoot, localTarball), { force: true });
diff --git a/scripts/test-method-content-integrity.mjs b/scripts/test-method-content-integrity.mjs
index 9d8b077..be4d38c 100644
--- a/scripts/test-method-content-integrity.mjs
+++ b/scripts/test-method-content-integrity.mjs
@@ -7,6 +7,7 @@ function readJson(filePath) {
 
 const stationsJson = readJson("src/data/method/stations.json");
 const linesJson = readJson("src/data/method/lines.json");
+const cyclesJson = readJson("src/data/method/cycles.json");
 const resourcesJson = readJson("src/data/method/resources.json");
 const criteriaJson = readJson("src/data/method/criteria.json");
 const stakeholdersJson = readJson("src/data/method/stakeholders.json");
@@ -14,16 +15,18 @@ const stationCriteriaJson = readJson("src/data/method/station-criteria.json");
 const canvasDataJson = readJson("src/data/canvas/canvasData.json");
 const localizedCanvasDataJson = readJson("src/data/canvas/localizedData.json");
 const knownResourceIds = new Set((resourcesJson.resources || []).map((resource) => resource.id));
-const stationGroups = [
-  ...(stationsJson["core-stations"]?.items || []).map((station) => ({ ...station, group: "core-stations" })),
-  ...(stationsJson["sub-stations"]?.items || []).map((station) => ({ ...station, group: "sub-stations" }))
-];
+const knownCriteriaIds = new Set((criteriaJson || []).map((criterion) => criterion.id));
+const knownCycleIds = new Set((cyclesJson.cycles?.items || []).map((cycle) => cycle.id));
+const stationGroups = Object.entries(stationsJson).flatMap(([groupId, group]) => (
+  (group.items || []).map((station) => ({ ...station, group: groupId }))
+));
 const knownStationIds = new Set(stationGroups.map((station) => station.id));
 const knownCanvasIds = new Set(Object.keys(canvasDataJson));
 const localeDirs = readdirSync("src/data/method", { withFileTypes: true })
   .filter((entry) => entry.isDirectory())
   .map((entry) => entry.name);
 const findings = [];
+const warnings = [];
 const lifecycleStages = new Set(["strategy", "architecture", "design", "delivery", "publishing", "improving"]);
 
 function collectMatchingStringValues(node, pattern, results = new Set()) {
@@ -52,12 +55,15 @@ function collectMatchingStringValues(node, pattern, results = new Set()) {
 
 function validateLabelFile(locale, filename, expectedKeys, allowedExtras = []) {
   const filePath = path.join("src", "data", "method", locale, filename);
+  const fallbackFilePath = path.join("src", "data", "method", "en", filename);
   const labels = readJson(filePath);
+  const fallbackLabels = readJson(fallbackFilePath);
   const actualKeys = new Set(Object.keys(labels));
+  const fallbackKeys = new Set(Object.keys(fallbackLabels));
   const allowedExtrasSet = new Set(allowedExtras);
 
   for (const expectedKey of expectedKeys) {
-    if (!actualKeys.has(expectedKey)) {
+    if (!actualKeys.has(expectedKey) && !fallbackKeys.has(expectedKey)) {
       findings.push(`Locale ${locale} is missing label "${expectedKey}" in ${filename}.`);
     }
   }
@@ -93,7 +99,7 @@ for (const station of stationGroups) {
     }
 
     if (seenResources.has(resourceId)) {
-      findings.push(
+      warnings.push(
         `Station ${station.id} contains duplicate resource reference "${resourceId}" at indexes ${seenResources.get(resourceId)} and ${index}.`
       );
     } else {
@@ -122,6 +128,67 @@ for (const station of stationGroups) {
       findings.push(`Core station ${station.id} must define expectedEvidenceTags.`);
     }
   }
+
+  if (station.group === "sub-stations") {
+    const hasCycleSpecificMetadata = Boolean(
+      station.type ||
+      station.applicableCycles ||
+      station.defaultForCycles ||
+      station.cycleSpecificLabels ||
+      station.cycleSpecificDescriptions ||
+      station.cycleSpecificResources
+    );
+
+    if (hasCycleSpecificMetadata && station.type !== "supporting-station") {
+      findings.push(`Substation ${station.id} must have type "supporting-station".`);
+    }
+
+    const applicableCycles = new Set(station.applicableCycles || []);
+    if (hasCycleSpecificMetadata && applicableCycles.size === 0) {
+      findings.push(`Substation ${station.id} must define applicableCycles.`);
+    }
+
+    for (const cycleId of applicableCycles) {
+      if (!knownCycleIds.has(cycleId)) {
+        findings.push(`Substation ${station.id} applicableCycles references unknown cycle "${cycleId}".`);
+      }
+    }
+
+    for (const cycleId of station.defaultForCycles || []) {
+      if (!knownCycleIds.has(cycleId)) {
+        findings.push(`Substation ${station.id} defaultForCycles references unknown cycle "${cycleId}".`);
+      }
+      if (!applicableCycles.has(cycleId)) {
+        findings.push(`Substation ${station.id} defaultForCycles contains "${cycleId}" that is not in applicableCycles.`);
+      }
+    }
+
+    for (const cycleId of Object.keys(station.cycleSpecificLabels || {})) {
+      if (!knownCycleIds.has(cycleId)) {
+        findings.push(`Substation ${station.id} cycleSpecificLabels references unknown cycle "${cycleId}".`);
+      }
+    }
+
+    for (const cycleId of Object.keys(station.cycleSpecificDescriptions || {})) {
+      if (!knownCycleIds.has(cycleId)) {
+        findings.push(`Substation ${station.id} cycleSpecificDescriptions references unknown cycle "${cycleId}".`);
+      }
+    }
+
+    for (const [cycleId, resourceIds] of Object.entries(station.cycleSpecificResources || {})) {
+      if (!knownCycleIds.has(cycleId)) {
+        findings.push(`Substation ${station.id} cycleSpecificResources references unknown cycle "${cycleId}".`);
+      }
+      if (!applicableCycles.has(cycleId)) {
+        findings.push(`Substation ${station.id} cycleSpecificResources contains "${cycleId}" that is not in applicableCycles.`);
+      }
+      for (const resourceId of resourceIds || []) {
+        if (!knownResourceIds.has(resourceId)) {
+          findings.push(`Substation ${station.id} cycleSpecificResources for "${cycleId}" references unknown resource "${resourceId}".`);
+        }
+      }
+    }
+  }
 }
 
 for (const line of linesJson.lines?.items || []) {
@@ -142,6 +209,63 @@ for (const line of linesJson.lines?.items || []) {
   }
 }
 
+for (const cycle of cyclesJson.cycles?.items || []) {
+  const seenStations = new Map();
+
+  for (const [index, stationId] of (cycle.stations || []).entries()) {
+    if (seenStations.has(stationId)) {
+      findings.push(
+        `Cycle ${cycle.id} contains duplicate station "${stationId}" at indexes ${seenStations.get(stationId)} and ${index}.`
+      );
+    } else {
+      seenStations.set(stationId, index);
+    }
+
+    if (!knownStationIds.has(stationId)) {
+      findings.push(`Cycle ${cycle.id} references unknown station "${stationId}" at index ${index}.`);
+    }
+  }
+
+  for (const [stationId, resourceIds] of Object.entries(cycle.recommendedResources || {})) {
+    if (!knownStationIds.has(stationId)) {
+      findings.push(`Cycle ${cycle.id} recommends resources for unknown station "${stationId}".`);
+    }
+    for (const resourceId of resourceIds || []) {
+      if (!knownResourceIds.has(resourceId)) {
+        findings.push(`Cycle ${cycle.id} recommends unknown resource "${resourceId}" for station "${stationId}".`);
+      }
+    }
+  }
+
+  for (const [index, entry] of (cycle.questionnaireResources || []).entries()) {
+    if (!knownStationIds.has(entry.station)) {
+      findings.push(`Cycle ${cycle.id} questionnaire resource at index ${index} references unknown station "${entry.station}".`);
+    }
+    if (!knownResourceIds.has(entry.resource)) {
+      findings.push(`Cycle ${cycle.id} questionnaire resource at index ${index} references unknown resource "${entry.resource}".`);
+    }
+  }
+
+  for (const [index, overlay] of (cycle.overlays || []).entries()) {
+    if (!knownStationIds.has(overlay.station)) {
+      findings.push(`Cycle ${cycle.id} overlay at index ${index} references unknown station "${overlay.station}".`);
+    }
+  }
+
+  for (const criterionId of cycle.entryCriteria || []) {
+    if (!knownCriteriaIds.has(criterionId)) {
+      findings.push(`Cycle ${cycle.id} entryCriteria references unknown criterion "${criterionId}".`);
+    }
+  }
+
+  for (const criterionId of cycle.exitCriteria || []) {
+    if (!knownCriteriaIds.has(criterionId)) {
+      findings.push(`Cycle ${cycle.id} exitCriteria references unknown criterion "${criterionId}".`);
+    }
+  }
+
+}
+
 const stationsUsedInLines = new Set(
   (linesJson.lines?.items || []).flatMap((line) => line.stations || [])
 );
@@ -170,13 +294,23 @@ for (const resource of resourcesJson.resources || []) {
 
 const expectedStationLabels = collectMatchingStringValues(stationsJson, /^(group|station)\./);
 const expectedLineLabels = collectMatchingStringValues(linesJson, /^(lines|line)\./);
+const expectedCycleLabels = collectMatchingStringValues(cyclesJson, /^(cycle|cycles)\./);
 const expectedResourceLabels = collectMatchingStringValues(resourcesJson, /^resource\./);
 const expectedCriteriaLabels = new Set(criteriaJson.map((criterion) => `criterion.${criterion.id}`));
 const expectedStakeholderLabels = collectMatchingStringValues(stakeholdersJson, /^stakeholder\./);
 
 for (const locale of localeDirs) {
-  validateLabelFile(locale, "labels.stations.json", expectedStationLabels);
+  const stationLabelFile = path.join("src", "data", "method", locale, "labels.stations.json");
+  const stationLabelExtras = Object.keys(readJson(stationLabelFile))
+    .filter((key) => key.startsWith("cycle."));
+  validateLabelFile(locale, "labels.stations.json", expectedStationLabels, stationLabelExtras);
   validateLabelFile(locale, "labels.lines.json", expectedLineLabels);
+  if (locale === "en" || existsSync(path.join("src", "data", "method", locale, "labels.cycles.json"))) {
+    const cycleLabelFile = path.join("src", "data", "method", locale, "labels.cycles.json");
+    const cycleLabelExtras = Object.keys(readJson(cycleLabelFile))
+      .filter((key) => key.startsWith("cycle.owner.") || key.startsWith("cycle.audience.") || key.startsWith("cycle.template."));
+    validateLabelFile(locale, "labels.cycles.json", expectedCycleLabels, cycleLabelExtras);
+  }
   validateLabelFile(locale, "labels.resources.json", expectedResourceLabels);
   validateLabelFile(locale, "labels.criteria.json", expectedCriteriaLabels, ["entry_criteria", "exit_criteria"]);
   validateLabelFile(
@@ -236,4 +370,11 @@ if (findings.length > 0) {
   process.exit(1);
 }
 
+if (warnings.length > 0) {
+  console.log("Method content validation warnings:");
+  for (const warning of warnings) {
+    console.log(`- ${warning}`);
+  }
+}
+
 console.log("Method content validation passed.");
diff --git a/scripts/test-method-stakeholders.mjs b/scripts/test-method-stakeholders.mjs
index 311fe77..9df1dc4 100644
--- a/scripts/test-method-stakeholders.mjs
+++ b/scripts/test-method-stakeholders.mjs
@@ -4,49 +4,87 @@ import * as methodEngine from "../src/lib/method-engine.js";
 const stations = methodEngine.getStations();
 const stationIds = new Set(stations.map((station) => station.id));
 const stakeholderIds = new Set(methodEngine.getStakeholders().map((stakeholder) => stakeholder.id));
-const stationStakeholderMap = methodEngine.getStationStakeholderMap();
+const resourceIds = new Set(methodEngine.getResources().map((resource) => resource.id));
+const stationStakeholders = methodEngine.getStationStakeholderMap();
+const stationStakeholdersByCycle = stationStakeholders.stationStakeholdersByCycle || {
+  [methodEngine.DEFAULT_CYCLE_ID]: stationStakeholders
+};
 
-for (const station of stations) {
-  const entries = stationStakeholderMap[station.id];
-  assert.ok(entries, `Missing stakeholder mapping for ${station.id}.`);
-  assert.ok(entries.length > 0, `Expected at least one stakeholder mapping for ${station.id}.`);
+for (const cycle of methodEngine.getCycles()) {
+  const stationStakeholderMap = methodEngine.getStationStakeholderMapForCycle(cycle.id);
+  const cycleStationIds = new Set(cycle.stations || []);
 
-  const seenStakeholders = new Set();
-  const leads = entries.filter((entry) => entry.involvement === "lead");
-  const cores = entries.filter((entry) => entry.involvement === "core");
+  assert.deepEqual(
+    stationStakeholderMap,
+    stationStakeholdersByCycle[cycle.id],
+    `Expected direct cycle stakeholder mapping for ${cycle.id}.`
+  );
 
-  assert.equal(leads.length, 1, `Expected exactly one lead for ${station.id}.`);
-  assert.ok(cores.length > 0, `Expected at least one core stakeholder for ${station.id}.`);
+  for (const stationId of cycleStationIds) {
+    const entries = stationStakeholderMap[stationId];
+    assert.ok(entries, `Missing stakeholder mapping for ${cycle.id}/${stationId}.`);
+    assert.ok(entries.length > 0, `Expected at least one stakeholder mapping for ${cycle.id}/${stationId}.`);
 
-  for (const entry of entries) {
-    assert.ok(stakeholderIds.has(entry.stakeholder), `Unknown stakeholder ${entry.stakeholder} in ${station.id}.`);
-    assert.ok(!seenStakeholders.has(entry.stakeholder), `Duplicate stakeholder ${entry.stakeholder} in ${station.id}.`);
-    seenStakeholders.add(entry.stakeholder);
-  }
+    const seenStakeholders = new Set();
+    const leads = entries.filter((entry) => entry.involvement === "lead");
+    const cores = entries.filter((entry) => entry.involvement === "core");
 
-  const localizedStakeholders = methodEngine.buildStationStakeholderData(station.id, "fi");
-  assert.equal(localizedStakeholders.length, entries.length, `Localized stakeholder count mismatch for ${station.id}.`);
-  assert.ok(localizedStakeholders.every((entry) => entry.title && entry.description && entry.involvementLabel), `Incomplete localized stakeholder data for ${station.id}.`);
-}
+    assert.equal(leads.length, 1, `Expected exactly one lead for ${cycle.id}/${stationId}.`);
+    assert.ok(cores.length > 0, `Expected at least one core stakeholder for ${cycle.id}/${stationId}.`);
+
+    for (const entry of entries) {
+      assert.ok(stakeholderIds.has(entry.stakeholder), `Unknown stakeholder ${entry.stakeholder} in ${cycle.id}/${stationId}.`);
+      assert.ok(!seenStakeholders.has(entry.stakeholder), `Duplicate stakeholder ${entry.stakeholder} in ${cycle.id}/${stationId}.`);
+      seenStakeholders.add(entry.stakeholder);
+
+      for (const responsibility of entry.responsibilities || []) {
+        assert.ok(
+          resourceIds.has(responsibility.resource),
+          `Unknown responsibility resource ${responsibility.resource} in ${cycle.id}/${stationId}.`
+        );
+      }
+    }
 
-for (const stationId of Object.keys(stationStakeholderMap)) {
-  assert.ok(stationIds.has(stationId), `Stakeholder mapping references unknown station ${stationId}.`);
+    const localizedStakeholders = methodEngine.buildStationStakeholderData(stationId, "fi", cycle.id);
+    assert.equal(localizedStakeholders.length, entries.length, `Localized stakeholder count mismatch for ${cycle.id}/${stationId}.`);
+    assert.ok(
+      localizedStakeholders.every((entry) => entry.title && entry.description && entry.involvementLabel && Array.isArray(entry.responsibilities)),
+      `Incomplete localized stakeholder data for ${cycle.id}/${stationId}.`
+    );
+  }
+
+  for (const stationId of Object.keys(stationStakeholderMap)) {
+    assert.ok(stationIds.has(stationId), `Stakeholder mapping references unknown station ${stationId}.`);
+    assert.ok(cycleStationIds.has(stationId), `Stakeholder mapping for ${cycle.id} references station outside the cycle: ${stationId}.`);
+  }
 }
 
-const startData = methodEngine.buildStartData("en");
+const startData = methodEngine.buildStartData("en", methodEngine.DEFAULT_CYCLE_ID);
+assert.ok(startData.every((station) => station.cycleId === methodEngine.DEFAULT_CYCLE_ID), "Expected cycle id in start data.");
 assert.ok(startData.every((station) => Array.isArray(station.stakeholders) && station.stakeholders.length > 0), "Expected stakeholders in start data.");
 
-const designData = methodEngine.buildStationResourceData("api-design", "en");
+const designData = methodEngine.buildStationResourceData("api-design", "en", methodEngine.DEFAULT_STYLE, methodEngine.DEFAULT_CYCLE_ID);
+assert.equal(designData.cycleId, methodEngine.DEFAULT_CYCLE_ID, "Expected cycle id in station resource data.");
 assert.ok(Array.isArray(designData.stakeholders) && designData.stakeholders.length > 0, "Expected stakeholders in station resource data.");
 assert.ok(designData.stakeholders.some((entry) => entry.id === "security-specialist"), "Expected api-design to include security-specialist.");
-assert.ok(designData.stakeholders.some((entry) => entry.id === "compliance-legal-specialist"), "Expected api-design to include compliance-legal-specialist.");
+assert.ok(designData.stakeholders.some((entry) => entry.id === "compliance-specialist"), "Expected api-design to include compliance-specialist.");
 assert.ok(designData.stakeholders.some((entry) => entry.id === "business-owner"), "Expected api-design to include business-owner.");
 
-const architectureData = methodEngine.buildStationResourceData("api-platform-architecture", "en");
+const architectureData = methodEngine.buildStationResourceData("api-platform-architecture", "en", methodEngine.DEFAULT_STYLE, methodEngine.DEFAULT_CYCLE_ID);
 assert.ok(architectureData.stakeholders.some((entry) => entry.id === "security-specialist"), "Expected api-platform-architecture to include security-specialist.");
-assert.ok(architectureData.stakeholders.some((entry) => entry.id === "compliance-legal-specialist"), "Expected api-platform-architecture to include compliance-legal-specialist.");
+assert.ok(architectureData.stakeholders.some((entry) => entry.id === "compliance-specialist"), "Expected api-platform-architecture to include compliance-specialist.");
+
+const capabilityStrategyData = methodEngine.buildStationResourceData("api-product-strategy", "en", methodEngine.DEFAULT_STYLE, "capability-productization-cycle");
+assert.ok(
+  capabilityStrategyData.steps.some((entry) => entry.resourceId === "capabilityValuePropositionCanvas"),
+  "Expected capability cycle strategy resources to use capability value proposition canvas."
+);
+assert.ok(
+  capabilityStrategyData.stakeholders.some((entry) => entry.id === "capability-owner" && entry.involvement === "lead"),
+  "Expected capability cycle strategy lead to be capability-owner."
+);
 
-const fallbackStakeholders = methodEngine.buildStationStakeholderData("api-product-strategy", "sv");
+const fallbackStakeholders = methodEngine.buildStationStakeholderData("api-product-strategy", "sv", methodEngine.DEFAULT_CYCLE_ID);
 assert.ok(fallbackStakeholders.some((entry) => entry.involvementLabel === "Lead"), "Expected missing locale fallback to English stakeholder labels.");
 
 console.log("Method stakeholder regression test passed.");
diff --git a/scripts/validate.mjs b/scripts/validate.mjs
index fd07460..8a6984e 100644
--- a/scripts/validate.mjs
+++ b/scripts/validate.mjs
@@ -50,6 +50,7 @@ async function gatherTemplateFiles() {
 (async () => {
   await validate('src/schemas/criteria.schema.json', ['src/data/method/criteria.json']);
   await validate('src/schemas/lines.schema.json', ['src/data/method/lines.json']);
+  await validate('src/schemas/cycles.schema.json', ['src/data/method/cycles.json']);
   await validate('src/schemas/resources.schema.json', ['src/data/method/resources.json']);
   await validate('src/schemas/stakeholders.schema.json', ['src/data/method/stakeholders.json']);
   await validate('src/schemas/station-criteria.schema.json', ['src/data/method/station-criteria.json']);
diff --git a/src/data/canvas/canvasData.json b/src/data/canvas/canvasData.json
index d3b433a..6be5b7c 100644
--- a/src/data/canvas/canvasData.json
+++ b/src/data/canvas/canvasData.json
@@ -568,5 +568,170 @@
         "fillOrder": 10
       }
     ]
+  },
+  "capabilityValuePropositionCanvas": {
+    "id": "capabilityValuePropositionCanvas",
+    "layout": {
+      "columns": 4,
+      "rows": 3
+    },
+    "metadata": {
+      "source": "APIOps Cycles",
+      "license": "CC-BY-SA 4.0",
+      "authors": ["Osaango Ltd"],
+      "website": "www.apiopscycles.com"
+    },
+    "sections": [
+      {
+        "id": "consumerTasks",
+        "gridPosition": { "column": 0, "row": 0, "colSpan": 4, "rowSpan": 1 },
+        "fillOrder": 1,
+        "highlight": true,
+        "journeySteps": true
+      },
+      {
+        "id": "gainEnablingCapabilities",
+        "gridPosition": { "column": 0, "row": 1, "colSpan": 2, "rowSpan": 1 },
+        "fillOrder": 2
+      },
+      {
+        "id": "painRelievingCapabilities",
+        "gridPosition": { "column": 2, "row": 1, "colSpan": 2, "rowSpan": 1 },
+        "fillOrder": 3
+      },
+      {
+        "id": "reusableCapabilities",
+        "gridPosition": { "column": 0, "row": 2, "colSpan": 4, "rowSpan": 1 },
+        "fillOrder": 4
+      }
+    ]
+  },
+  "capabilityBusinessModelCanvas": {
+    "id": "capabilityBusinessModelCanvas",
+    "layout": {
+      "columns": 5,
+      "rows": 3
+    },
+    "metadata": {
+      "source": "APIOps Cycles",
+      "license": "CC-BY-SA 4.0",
+      "authors": ["Osaango Ltd"],
+      "website": "www.apiopscycles.com"
+    },
+    "sections": [
+      {
+        "id": "keyPartners",
+        "gridPosition": { "column": 0, "row": 0, "colSpan": 1, "rowSpan": 2 },
+        "fillOrder": 7
+      },
+      {
+        "id": "keyActivities",
+        "gridPosition": { "column": 1, "row": 0, "colSpan": 1, "rowSpan": 1 },
+        "fillOrder": 6
+      },
+      {
+        "id": "keyResources",
+        "gridPosition": { "column": 1, "row": 1, "colSpan": 1, "rowSpan": 1 },
+        "fillOrder": 5
+      },
+      {
+        "id": "capabilityValueProposition",
+        "gridPosition": { "column": 2, "row": 0, "colSpan": 1, "rowSpan": 2 },
+        "fillOrder": 1,
+        "highlight": true
+      },
+      {
+        "id": "consumerEngagement",
+        "gridPosition": { "column": 3, "row": 0, "colSpan": 1, "rowSpan": 1 },
+        "fillOrder": 3
+      },
+      {
+        "id": "channels",
+        "gridPosition": { "column": 3, "row": 1, "colSpan": 1, "rowSpan": 1 },
+        "fillOrder": 4
+      },
+      {
+        "id": "capabilityConsumerSegments",
+        "gridPosition": { "column": 4, "row": 0, "colSpan": 1, "rowSpan": 2 },
+        "fillOrder": 2
+      },
+      {
+        "id": "costs",
+        "gridPosition": { "column": 0, "row": 2, "colSpan": 2.5, "rowSpan": 1 },
+        "fillOrder": 9
+      },
+      {
+        "id": "benefits",
+        "gridPosition": { "column": 2.5, "row": 2, "colSpan": 2.5, "rowSpan": 1 },
+        "fillOrder": 8
+      }
+    ]
+  },
+  "consumerExperienceRequirementsCanvas": {
+    "id": "consumerExperienceRequirementsCanvas",
+    "layout": {
+      "columns": 4,
+      "rows": 3
+    },
+    "metadata": {
+      "source": "APIOps Cycles",
+      "license": "CC-BY-SA 4.0",
+      "authors": ["Osaango Ltd"],
+      "website": "www.apiopscycles.com"
+    },
+    "sections": [
+      {
+        "id": "consumerGoals",
+        "gridPosition": { "column": 0, "row": 0, "colSpan": 1, "rowSpan": 1 },
+        "fillOrder": 1,
+        "highlight": true
+      },
+      {
+        "id": "availabilityAndTimeliness",
+        "gridPosition": { "column": 1, "row": 0, "colSpan": 1, "rowSpan": 1 },
+        "fillOrder": 2
+      },
+      {
+        "id": "volumeAndPerformance",
+        "gridPosition": { "column": 2, "row": 0, "colSpan": 1, "rowSpan": 1 },
+        "fillOrder": 3
+      },
+      {
+        "id": "dataQualityAndConsistency",
+        "gridPosition": { "column": 3, "row": 0, "colSpan": 1, "rowSpan": 1 },
+        "fillOrder": 4
+      },
+      {
+        "id": "securityPrivacyAndCompliance",
+        "gridPosition": { "column": 0, "row": 1, "colSpan": 1, "rowSpan": 1 },
+        "fillOrder": 5
+      },
+      {
+        "id": "onboardingAndAccess",
+        "gridPosition": { "column": 1, "row": 1, "colSpan": 1, "rowSpan": 1 },
+        "fillOrder": 6
+      },
+      {
+        "id": "changeAndVersioning",
+        "gridPosition": { "column": 2, "row": 1, "colSpan": 1, "rowSpan": 1 },
+        "fillOrder": 7
+      },
+      {
+        "id": "observabilityAndSupport",
+        "gridPosition": { "column": 3, "row": 1, "colSpan": 1, "rowSpan": 1 },
+        "fillOrder": 8
+      },
+      {
+        "id": "recoveryAndContinuity",
+        "gridPosition": { "column": 0, "row": 2, "colSpan": 2, "rowSpan": 1 },
+        "fillOrder": 9
+      },
+      {
+        "id": "architectureImplications",
+        "gridPosition": { "column": 2, "row": 2, "colSpan": 2, "rowSpan": 1 },
+        "fillOrder": 10,
+        "highlight": true
+      }
+    ]
   }
 }
diff --git a/src/data/canvas/localizedData.json b/src/data/canvas/localizedData.json
index b6892f9..b63c1cb 100644
--- a/src/data/canvas/localizedData.json
+++ b/src/data/canvas/localizedData.json
@@ -11,31 +11,31 @@
         },
         "keyActivities": {
           "section": "Schlüsselaktivitäten",
-          "description": "Was sind die wichtigsten Maßnahmen, die der API-Anbieter ergreifen muss, um erfolgreich zu arbeiten?"
+          "description": "Welche wichtigsten Aktivitäten muss der API-Anbieter ausführen, damit die API erfolgreich betrieben werden kann?"
         },
         "keyResources": {
           "section": "Schlüsselressourcen",
-          "description": "Welche einzigartigen strategischen Vermögenswerte muss der API-Anbieter erwerben oder aufbauen?"
+          "description": "Welche strategischen Ressourcen muss der API-Anbieter beschaffen oder aufbauen?"
         },
         "apiValueProposition": {
           "section": "Wertversprechen der API",
           "description": "Beginnen Sie mit einem Haftzettel, auf dem Sie die API oder die API-Familie benennen, und erfassen Sie dann, welchen Nutzen die API den API-Nutzern bietet."
         },
         "developerRelations": {
-          "section": "Entwicklerbeziehungen",
-          "description": "Wie erreicht und unterstützt der API-Anbieter API-Konsumenten?"
+          "section": "Developer Relations",
+          "description": "Wie erreicht und unterstützt der API-Anbieter die API-Nutzer?"
         },
         "channels": {
           "section": "Kanäle",
-          "description": "Über welche Mechanismen interagieren API-Konsumenten mit der API?"
+          "description": "Über welche Mechanismen interagieren API-Nutzer mit der API?"
         },
         "apiConsumerSegments": {
-          "section": "Konsumenten der API",
+          "section": "API-Nutzersegmente",
           "description": "Wer sind die Zielgruppen für die API?"
         },
         "costs": {
           "section": "Kosten",
-          "description": "Was sind die wesentlichen Kosten für die Erstellung, Bereitstellung und den Betrieb der API?"
+          "description": "Welche wesentlichen Kosten entstehen durch Aufbau, Bereitstellung und Betrieb der API?"
         },
         "benefits": {
           "section": "Vorteile",
@@ -45,20 +45,20 @@
     },
     "apiValuePropositionCanvas": {
       "title": "API Value Proposition Canvas",
-      "purpose": "Wie lässt sich die Customer Journey auf APIs abbilden? Welche Probleme und Vorteile von Endnutzern und API-Nutzern müssen berücksichtigt werden?",
-      "howToUse": "Beschreiben Sie die Perspektive der Endnutzer, beginnend mit ihren Aufgaben, dann die Probleme und Vorteile von Endnutzern und API-Nutzern und schließlich die Produkte und Funktionen der API.",
+      "purpose": "Wie hängt die Customer Journey mit APIs zusammen? Welche Pain Points und Nutzen von Endnutzern und API-Nutzern müssen adressiert werden?",
+      "howToUse": "Beschreiben Sie die Perspektive der Endnutzer: zuerst ihre Aufgaben, dann ihre Pain Points und Nutzen sowie die der API-Nutzer, und schließlich die API-Produkte und API-Funktionen.",
       "sections": {
         "tasks": {
           "section": "Aufgaben",
-          "description": "Was wollen die Kunden (Endnutzer) erreichen?"
+          "description": "Was möchten Kunden oder Endnutzer erreichen?"
         },
         "gainEnablingFeatures": {
-          "section": "Nutzenstiftende Features",
-          "description": "Welche Features ermöglichen es API-Konsumenten ihre Bedürfnisse zu bedienen?"
+          "section": "Nutzenstiftende Funktionen",
+          "description": "Welche Funktionen helfen Endnutzern und API-Nutzern, den gewünschten Nutzen zu erreichen?"
         },
         "painRelievingFeatures": {
-          "section": "Problemlösende Features",
-          "description": "Welche Funktionen helfen Endnutzern und API-Nutzern, Probleme zu überwinden?"
+          "section": "Funktionen zur Reduktion von Pain Points",
+          "description": "Welche Funktionen helfen Endnutzern und API-Nutzern, Pain Points zu reduzieren?"
         },
         "apiProducts": {
           "section": "API-Produkte",
@@ -68,8 +68,8 @@
     },
     "businessImpactCanvas": {
       "title": "Business Impact Canvas",
-      "purpose": "Was sind die potenziellen geschäftlichen Auswirkungen eines Ausfalls einer API?",
-      "howToUse": "Berücksichtigen Sie die potenziellen Auswirkungen auf Verfügbarkeit, Sicherheit und Daten für jede API.",
+      "purpose": "Welche geschäftlichen Auswirkungen kann ein Ausfall oder Fehlverhalten der Capability oder Schnittstelle haben?",
+      "howToUse": "Bewerten Sie mögliche Auswirkungen auf Verfügbarkeit, Sicherheit und Daten, bevor der Implementierungsstil endgültig festgelegt wird.",
       "sections": {
         "availabilityRisks": {
           "section": "Risiken der Verfügbarkeit",
@@ -85,22 +85,22 @@
         },
         "mitigateAvailabilityRisks": {
           "section": "Reduzierung von Risiken der Verfügbarkeit",
-          "description": "Wie kann der API-Anbieter die Risiken der Verfügbarkeit reduzieren?"
+          "description": "Wie lassen sich Verfügbarkeitsrisiken reduzieren?"
         },
         "mitigateSecurityRisks": {
           "section": "Reduktion der Sicherheitsrisiken",
-          "description": "Wie kann der API-Anbieter die Sicherheitsrisiken reduzieren?"
+          "description": "Wie lassen sich Sicherheitsrisiken reduzieren?"
         },
         "mitigateDataRisks": {
           "section": "Reduktion der Datenrisiken",
-          "description": "Wie kann der API-Anbieter die Datenrisiken reduzieren?"
+          "description": "Wie lassen sich Datenrisiken reduzieren?"
         }
       }
     },
     "capacityCanvas": {
       "title": "Capacity Canvas",
-      "purpose": "Welche Anforderungen ergeben sich, um den Konsum der API zu gewährleisten?",
-      "howToUse": "Analysieren Sie die aktuellen und zukünftigen Kapazitätsanforderungen für jede API.",
+      "purpose": "Welche Kapazität ist erforderlich, um die Nutzung der Capability oder Schnittstelle zu unterstützen?",
+      "howToUse": "Analysieren Sie aktuelle und zukünftige Kapazitätsanforderungen für die Capability oder Schnittstelle.",
       "sections": {
         "currentBusinessVolumes": {
           "section": "Aktuelles Geschäftsvolumen",
@@ -119,8 +119,8 @@
           "description": "Welche Caching-Strategien können zur Performanceoptimierung eingesetzt werden?"
         },
         "rateLimitingStrategies": {
-          "section": "Rate-Limiting-Strategien",
-          "description": "Welche Rate-Limiting-Strategien können zur Konsumsteuerung eingesetzt werden?"
+          "section": "Strategien zur Ratenbegrenzung",
+          "description": "Welche Strategien zur Ratenbegrenzung können genutzt werden, um die Nutzung zu steuern?"
         },
         "scalingStrategies": {
           "section": "Strategien zur Skalierung",
@@ -130,8 +130,8 @@
     },
     "customerJourneyCanvas": {
       "title": "Customer Journey Canvas",
-      "purpose": "Welche Reise eines Kunden oder Partners soll mit der API unterstützt werden?",
-      "howToUse": "Beschreiben Sie eine reale Reise eines Kunden oder Nutzers – nicht die API-Nutzung selbst. Diese Reise macht Probleme, Ziele und Kontexte sichtbar, um spätere API-Anforderungen und Nutzen zu definieren.",
+      "purpose": "Welche Customer Journey oder Partner Journey erzeugt den Bedarf für eine Capability oder Schnittstelle?",
+      "howToUse": "Beschreiben Sie eine reale Reise eines Kunden, Partners oder Nutzers - nicht die API-Nutzung selbst. Diese Reise macht Probleme, Ziele und Kontext sichtbar und hilft, spätere Anforderungen an Capability- und Schnittstellendesign zu klären.",
       "sections": {
         "customerDiscoversNeed": {
           "section": "Kunde erkennt Bedarf",
@@ -143,15 +143,15 @@
         },
         "pains": {
           "section": "Probleme",
-          "description": "Was sind die Probleme oder Herausforderungen des Kunden?"
+          "description": "Welche Probleme oder Pain Points erlebt der Kunde oder Nutzer?"
         },
         "journeySteps": {
           "section": "Customer Journey Schritte",
           "description": "Welche Schritte durchläuft der Kunde bei der Reise?"
         },
         "customerNeedIsResolved": {
-          "section": "Kundenbedürfnis wird gelöst",
-          "description": "Wie wird das Bedürfnis des Kunden letztendlich gelöst?"
+          "section": "Kundenbedarf wird erfüllt",
+          "description": "Wie wird der Bedarf des Kunden oder Nutzers letztlich erfüllt?"
         },
         "gains": {
           "section": "Nutzen",
@@ -169,8 +169,8 @@
     },
     "domainCanvas": {
       "title": "Domain Canvas",
-      "purpose": "Was sind die wesentlichen Entitäten und Geschäftsregeln im Zusammenhang mit der API?",
-      "howToUse": "Definieren Sie das Domänenmodell für jede API, einschließlich Entitäten, Attribute und Beziehungen.",
+      "purpose": "Welche wesentlichen Entitäten, Begriffe und Fachregeln muss die Capability oder Schnittstelle respektieren?",
+      "howToUse": "Definieren Sie das Fachdomänenmodell für die Capability oder Schnittstelle, einschließlich Entitäten, Attributen und Beziehungen.",
       "sections": {
         "selectedCustomerJourneySteps": {
           "section": "Ausgewählte Customer Journey Schritte",
@@ -189,8 +189,8 @@
           "description": "Welche Beziehungen bestehen zwischen den Entitäten?"
         },
         "businessComplianceAndIntegrityRules": {
-          "section": "Geschäfts-, Compliance- und Integritätsregeln",
-          "description": "Welche Geschäfts-, Compliance- und Integritätsregeln gelten für die Entitäten?"
+          "section": "Fachregeln, Compliance und Integrität",
+          "description": "Welche Fachregeln sowie Compliance- und Integritätsanforderungen beziehen sich auf die Entitäten?"
         },
         "securityAndPrivacyConsiderations": {
           "section": "Überlegungen zu Sicherheit und Datenschutz",
@@ -200,12 +200,12 @@
     },
     "eventCanvas": {
       "title": "Event Canvas",
-      "purpose": "Welche Events sind für die API relevant, und wie werden sie verarbeitet?",
-      "howToUse": "Definieren Sie die Events, ihre Trigger und die Verarbeitungslogik für jede API.",
+      "purpose": "Welche Ereignisse sind für die Capability oder Schnittstelle relevant und wie werden sie verarbeitet?",
+      "howToUse": "Definieren Sie Ereignisse, Auslöser und Verarbeitungslogik für die Capability oder Schnittstelle.",
       "sections": {
         "userTaskTrigger": {
-          "section": "Nutzeraufgabe / Trigger",
-          "description": "Welche Nutzeraktion oder welches System-Event löst diese Eventoperation aus?"
+          "section": "Nutzeraufgabe / Auslöser",
+          "description": "Welche Nutzeraktion oder welches Systemereignis löst diese Ereignisoperation aus?"
         },
         "inputEventPayload": {
           "section": "Input / Event-Payload",
@@ -213,7 +213,7 @@
         },
         "processingLogic": {
           "section": "Verarbeitung / Logik",
-          "description": "Beschreiben Sie die Backend-Verarbeitungslogik, inklusive Validierungen, Transformationen, oder Routing-Entscheidungen."
+          "description": "Beschreiben Sie die Verarbeitungslogik der Backend-Systeme, einschließlich Validierungen, Transformationen oder Routing-Entscheidungen."
         },
         "outputEventResult": {
           "section": "Output / Event-Ergebnis",
@@ -223,8 +223,8 @@
     },
     "interactionCanvas": {
       "title": "Interaction Canvas",
-      "purpose": "Welche Arten von Interaktionen sollte diese API unterstützen, bevor Sie sich für ein protokollspezifisches Design entscheiden?",
-      "howToUse": "Ermitteln Sie, welche Interaktionsarten für diese API tatsächlich benötigt werden und welche nicht in den Anwendungsbereich fallen. Verwenden Sie diese Arbeitsfläche, um die Absicht zu klären, bevor Sie das Ergebnis auf REST, Events oder GraphQL abbilden.",
+      "purpose": "Welche Arten von Interaktionen muss diese Capability oder Schnittstelle unterstützen, bevor ein konkretes Protokolldesign gewählt wird?",
+      "howToUse": "Identifizieren Sie, welche Interaktionsstile wirklich benötigt werden und welche außerhalb des Umfangs liegen. Nutzen Sie dieses Canvas, um die Absicht zu klären, bevor das Ergebnis auf REST, Events oder GraphQL abgebildet wird.",
       "sections": {
         "crudInteractions": {
           "section": "CRUD Interaktionen",
@@ -240,7 +240,7 @@
         },
         "queryDrivenInteractions": {
           "section": "Abfragegesteuerte Interaktionen",
-          "description": "Welche Lese- oder Abfrageinteraktionen sind erforderlich, um Verbraucherfragen zu beantworten?"
+          "description": "Welche Lese- oder Abfrageinteraktionen sind erforderlich, um Nutzerfragen zu beantworten?"
         },
         "queryDrivenInputOutputModels": {
           "section": "Abfragegesteuerte Input- & Output-Modelle",
@@ -277,9 +277,9 @@
       }
     },
     "locationsCanvas": {
-      "title": "Location Canvas",
-      "purpose": "Welche geopolitischen, regulatorischen, netzwerkbezogenen und vertrauensbezogenen Grenzen wirken sich auf diese API aus?",
-      "howToUse": "Ermitteln Sie, wo API-Nutzer, -Anbieter und abhängige Systeme in internen Netzwerken, Partnernetzwerken, im öffentlichen Internet und in regulierten Regionen operieren. Beschreiben Sie die Auswirkungen auf Latenz, Vertrauen, Compliance und Konnektivität zwischen ihnen.",
+      "title": "Locations Canvas",
+      "purpose": "Welche geopolitischen, regulatorischen, Netzwerk- und Vertrauensgrenzen betreffen diese Capability oder Schnittstelle?",
+      "howToUse": "Identifizieren Sie, wo Nutzer, Anbieter und abhängige Systeme in internen Netzwerken, Partnernetzwerken, im öffentlichen Internet und in regulierten Regionen betrieben werden. Beschreiben Sie die Auswirkungen auf Latenz, Vertrauen, Compliance und Konnektivität.",
       "sections": {
         "locationGroups": {
           "section": "Standort-/Vertrauensgruppen",
@@ -318,7 +318,7 @@
     "restCanvas": {
       "title": "REST Canvas",
       "purpose": "Wie kann die API nach RESTful-Prinzipien gestaltet werden?",
-      "howToUse": "Definieren Sie die API-Ressourcen, HTTP-Methoden und Beispielanfragen und -antworten.",
+      "howToUse": "Definieren Sie Ressourcen, Verben sowie Beispiele für API-Requests und API-Responses.",
       "sections": {
         "apiResources": {
           "section": "API-Ressourcen",
@@ -340,20 +340,20 @@
     },
     "graphqlCanvas": {
       "title": "GraphQL Canvas",
-      "purpose": "Wie kann die API unter Verwendung von GraphQL-Prinzipien gestaltet werden?",
-      "howToUse": "Definieren Sie die Schlüsseltypen, Abfragen, Mutationen und Einschränkungen für Ihre GraphQL-API.",
+      "purpose": "Wie kann die API nach GraphQL-Prinzipien gestaltet werden?",
+      "howToUse": "Definieren Sie zentrale Typen, Queries, Mutations und Einschränkungen für die GraphQL-API.",
       "sections": {
         "apiName": {
           "section": "API-Name",
           "description": "Wie lautet der Name der GraphQL-API oder des Endpunkts?"
         },
         "consumerGoals": {
-          "section": "Ziele der Konsumenten",
-          "description": "Welche Probleme versuchen API-Konsumenten zu lösen? Welche Daten benötigen sie?"
+          "section": "Ziele der API-Nutzer",
+          "description": "Welche Probleme versuchen API-Nutzer zu lösen? Welche Daten benötigen sie?"
         },
         "keyTypes": {
           "section": "Schlüsseltypen",
-          "description": "Welche Kern-Typen werden bereitgestellt (z.B. Benutzer, Bestellung, Produkt)?"
+          "description": "Welche zentralen Typen werden bereitgestellt (z. B. Nutzer, Bestellung, Produkt)?"
         },
         "relationships": {
           "section": "Beziehungen",
@@ -369,14 +369,14 @@
         },
         "subscriptions": {
           "section": "Subscriptions",
-          "description": "Gibt es Echtzeit-Updates oder Ereignisse, die Konsumenten abonnieren können?"
+          "description": "Gibt es Echtzeit-Updates oder Ereignisse, die Nutzer abonnieren können?"
         },
         "authorizationRules": {
           "section": "Autorisierungsregeln",
           "description": "Wer darf auf welche Felder oder Typen zugreifen?"
         },
         "consumerConstraints": {
-          "section": "Einschränkungen für Konsumenten",
+          "section": "Einschränkungen für Nutzer",
           "description": "Gibt es Paginierungs-, Filter- oder Ratenbegrenzungen?"
         },
         "openQuestions": {
@@ -384,6 +384,119 @@
           "description": "Gibt es noch offene Entscheidungen oder Integrationsüberlegungen?"
         }
       }
+    },
+    "capabilityValuePropositionCanvas": {
+      "title": "Capability Value Proposition Canvas",
+      "purpose": "Welche wiederverwendbare Capability würde Nutzern Wert liefern, ohne bereits zu entscheiden, ob sie als API, Event, Datei, Stream, Datenprodukt oder ein anderer Implementierungsstil bereitgestellt werden soll?",
+      "howToUse": "Starten Sie mit Nutzeraufgaben und Ergebnissen. Erfassen Sie nutzenstiftende und Pain-Point-reduzierende Capability-Funktionen und beschreiben Sie mögliche wiederverwendbare Capabilities, ohne die Technologie zu früh festzulegen.",
+      "sections": {
+        "consumerTasks": {
+          "section": "Nutzeraufgaben und Ergebnisse",
+          "description": "Was möchten Nutzer, Partner, Systeme oder Teams erreichen?"
+        },
+        "gainEnablingCapabilities": {
+          "section": "Nutzenstiftende Capability-Funktionen",
+          "description": "Welche Capability-Funktionen helfen Nutzern, bessere Ergebnisse, Geschwindigkeit, Automatisierung, Erkenntnisse, Reichweite oder Compliance zu erreichen?"
+        },
+        "painRelievingCapabilities": {
+          "section": "Pain-Point-reduzierende Capability-Funktionen",
+          "description": "Welche Capability-Funktionen reduzieren Reibung, manuelle Arbeit, Fehler, Verzögerungen, Risiken oder Unsicherheit für Nutzer?"
+        },
+        "reusableCapabilities": {
+          "section": "Wiederverwendbare Capabilities",
+          "description": "Welche wiederverwendbaren Geschäfts- oder Daten-Capabilities könnten diese Aufgaben, Nutzen und Pain Points über mehr als einen Nutzer oder Use Case hinweg unterstützen?"
+        }
+      }
+    },
+    "capabilityBusinessModelCanvas": {
+      "title": "Capability Business Model Canvas",
+      "purpose": "Wie tragfähig, wiederverwendbar, finanziert, verantwortet, unterstützt und auffindbar soll diese Integrations-Capability sein?",
+      "howToUse": "Fassen Sie das Wertversprechen der Capability zusammen, identifizieren Sie Nutzer und Interaktionskanäle und erfassen Sie anschließend Verantwortlichkeiten, Aktivitäten, Ressourcen, Partner, Nutzen und Kosten.",
+      "sections": {
+        "keyPartners": {
+          "section": "Schlüsselpartner",
+          "description": "Welche Partner aus Business, Technologie, Daten, Sicherheit, Recht, Plattform oder externen Organisationen werden benötigt, damit die Capability funktioniert?"
+        },
+        "keyActivities": {
+          "section": "Schlüsselaktivitäten",
+          "description": "Was müssen Capability Owner und Produzenten tun, um die Capability zu gestalten, bereitzustellen, zu steuern, zu unterstützen und zu verbessern?"
+        },
+        "keyResources": {
+          "section": "Schlüsselressourcen",
+          "description": "Welche Systeme, Datenbestände, Plattformen, Personen, Standards, Finanzierungen und operativen Fähigkeiten werden benötigt?"
+        },
+        "capabilityValueProposition": {
+          "section": "Wertversprechen der Capability",
+          "description": "Welchen Wert liefert diese wiederverwendbare Capability für Nutzer und für die Organisation oder das Ökosystem?"
+        },
+        "consumerEngagement": {
+          "section": "Nutzerinteraktion",
+          "description": "Wie werden Nutzer die Capability entdecken, bewerten, anfordern, onboarden, Unterstützung erhalten und Feedback geben?"
+        },
+        "channels": {
+          "section": "Kanäle",
+          "description": "Über welche Kataloge, Portale, Marktplätze, Dokumentationsseiten, Support-Wege oder Governance-Prozesse interagieren Nutzer mit der Capability?"
+        },
+        "capabilityConsumerSegments": {
+          "section": "Nutzersegmente der Capability",
+          "description": "Wer sind die aktuellen und potenziellen Nutzer der Capability, einschließlich Teams, Partnern, Systemen, Produkten oder Datennutzern?"
+        },
+        "costs": {
+          "section": "Kosten",
+          "description": "Welche wesentlichen Kosten entstehen durch Aufbau, Betrieb, Governance, Support und Weiterentwicklung der Capability?"
+        },
+        "benefits": {
+          "section": "Nutzen",
+          "description": "Welcher geschäftliche, operative, ökologische, wiederverwendungsbezogene, Compliance- oder Kostennutzen rechtfertigt die Capability?"
+        }
+      }
+    },
+    "consumerExperienceRequirementsCanvas": {
+      "title": "Consumer Experience Requirements Canvas",
+      "purpose": "Welche Erfahrungs- und nichtfunktionalen Anforderungen benötigen Nutzer, bevor die beste Integrationsarchitektur entschieden wird?",
+      "howToUse": "Nutzen Sie dieses Canvas als technologieunabhängige Anforderungstabelle. Erfassen Sie Erwartungen und Einschränkungen der Nutzer und verwenden Sie anschließend die Architekturimplikationen, um APIs, Events, Dateien, Streams, Datenprodukte oder ein anderes Muster auszuwählen.",
+      "sections": {
+        "consumerGoals": {
+          "section": "Nutzerziele",
+          "description": "Welche Geschäfts-, Workflow-, Entscheidungs-, Automatisierungs- oder Datennutzungsziele haben die Nutzer?"
+        },
+        "availabilityAndTimeliness": {
+          "section": "Verfügbarkeit und Aktualität",
+          "description": "Wann muss die Capability verfügbar sein, wie aktuell müssen Informationen sein und welche Latenz- oder Bereitstellungsfenster sind relevant?"
+        },
+        "volumeAndPerformance": {
+          "section": "Volumen und Performance",
+          "description": "Welche Volumina an Requests, Events, Datensätzen, Dateien, Batches, Nutzern oder Transaktionen muss die Capability heute und künftig unterstützen?"
+        },
+        "dataQualityAndConsistency": {
+          "section": "Datenqualität und Konsistenz",
+          "description": "Welche Erwartungen an Genauigkeit, Vollständigkeit, Konsistenz, Reihenfolge, Deduplizierung, Abstimmung oder Validierung haben Nutzer?"
+        },
+        "securityPrivacyAndCompliance": {
+          "section": "Sicherheit, Datenschutz und Compliance",
+          "description": "Welche Anforderungen an Identität, Autorisierung, Vertraulichkeit, Datenresidenz, Einwilligung, Aufbewahrung, Audit oder Regulierung gelten?"
+        },
+        "onboardingAndAccess": {
+          "section": "Onboarding und Zugriff",
+          "description": "Wie sollen Nutzer die Capability finden, anfordern, testen, freigeben lassen und mit der Nutzung beginnen?"
+        },
+        "changeAndVersioning": {
+          "section": "Änderungen und Versionierung",
+          "description": "Wie viel Änderungstoleranz haben Nutzer und welche Erwartungen an Vorankündigung, Kompatibilität, Migration oder Versionierung gelten?"
+        },
+        "observabilityAndSupport": {
+          "section": "Observability und Support",
+          "description": "Welche Überwachung, Statusinformationen, Nachvollziehbarkeit, Sichtbarkeit der Datenqualität, Unterstützung, Verantwortlichkeiten und Incident-Kommunikation benötigen Nutzer?"
+        },
+        "recoveryAndContinuity": {
+          "section": "Recovery und Kontinuität",
+          "description": "Welche Erwartungen an Replay, Retry, Abstimmung, Backup, Fallback, Kontinuität oder manuelle Wiederherstellung müssen unterstützt werden?"
+        },
+        "architectureImplications": {
+          "section": "Architekturimplikationen",
+          "description": "Was bedeuten diese Anforderungen für mögliche Architekturstile wie APIs, Events, Dateien, Streams, Datenprodukte oder direkte Integration?"
+        }
+      }
     }
   },
   "en": {
@@ -455,16 +568,16 @@
     },
     "businessImpactCanvas": {
       "title": "Business Impact Canvas",
-      "purpose": "What are the potential business impacts of API failure?",
-      "howToUse": "Consider the potential impact on availability, security, and data for each API.",
+      "purpose": "What are the potential business impacts if the capability, integration, or service fails?",
+      "howToUse": "Consider the potential impact on availability, security, and data for each capability, integration, or service.",
       "sections": {
         "availabilityRisks": {
           "section": "Availability Risks",
-          "description": "What are the potential risks to API availability?"
+          "description": "What are the potential risks to capability availability?"
         },
         "securityRisks": {
           "section": "Security Risks",
-          "description": "What are the potential security risks associated with the API?"
+          "description": "What are the potential security risks associated with the capability?"
         },
         "dataRisks": {
           "section": "Data Risks",
@@ -472,22 +585,22 @@
         },
         "mitigateAvailabilityRisks": {
           "section": "Mitigate Availability Risks",
-          "description": "How can the API provider mitigate the availability risks?"
+          "description": "How can the capability owner mitigate the availability risks?"
         },
         "mitigateSecurityRisks": {
           "section": "Mitigate Security Risks",
-          "description": "How can the API provider mitigate the security risks?"
+          "description": "How can the capability owner mitigate the security risks?"
         },
         "mitigateDataRisks": {
           "section": "Mitigate Data Risks",
-          "description": "How can the API provider mitigate the data risks?"
+          "description": "How can the capability owner mitigate the data risks?"
         }
       }
     },
     "capacityCanvas": {
       "title": "Capacity Canvas",
-      "purpose": "How much capacity is needed to support API consumption?",
-      "howToUse": "Analyze the current and future capacity requirements for each API.",
+      "purpose": "How much capacity is needed to support expected capability consumption?",
+      "howToUse": "Analyze the current and future capacity requirements for each capability, integration, or service.",
       "sections": {
         "currentBusinessVolumes": {
           "section": "Current Business Volumes",
@@ -517,8 +630,8 @@
     },
     "customerJourneyCanvas": {
       "title": "Customer Journey Canvas",
-      "purpose": "What is the customer or partner journey that the API is intended to support?",
-      "howToUse": "In API Product Strategy, describe the real-life customer or partner journey, not the API usage, to reveal pain points, goals, and context. In API Consumer Experience, use this canvas for the API consumer journey from discovery and evaluation to onboarding, integration, troubleshooting, and ongoing use.",
+      "purpose": "What customer, partner, or consumer journey is the capability intended to support?",
+      "howToUse": "Describe the real-life customer, partner, or consumer journey, not the solution usage itself, to reveal pain points, goals, context, inputs, outputs, and experience expectations.",
       "sections": {
         "customerDiscoversNeed": {
           "section": "Customer Discovers Need",
@@ -556,8 +669,8 @@
     },
     "domainCanvas": {
       "title": "Domain Canvas",
-      "purpose": "What are the core entities and business rules related to the API?",
-      "howToUse": "Define the domain model for each API, including entities, attributes, and relationships.",
+      "purpose": "What are the core entities and business rules related to this capability or domain?",
+      "howToUse": "Define the domain model, including entities, attributes, relationships, ownership, and business rules.",
       "sections": {
         "selectedCustomerJourneySteps": {
           "section": "Selected Customer Journey Steps",
@@ -610,8 +723,8 @@
     },
     "interactionCanvas": {
       "title": "Interaction Canvas",
-      "purpose": "What kinds of interactions should this API support before choosing a protocol-specific design?",
-      "howToUse": "Identify which interaction styles are actually needed for this API, and which are out of scope. Use this canvas to clarify intent before mapping the result to REST, events, or GraphQL.",
+      "purpose": "What kinds of interactions should this capability support before choosing a protocol-specific design?",
+      "howToUse": "Identify which interaction styles are actually needed for this capability, and which are out of scope. Use this canvas to clarify intent before mapping the result to REST, events, GraphQL, or another selected implementation style.",
       "sections": {
         "crudInteractions": {
           "section": "CRUD Interactions",
@@ -665,8 +778,8 @@
     },
     "locationsCanvas": {
       "title": "Locations Canvas",
-      "purpose": "What geopolitical, regulatory, network, and trust boundaries affect this API?",
-      "howToUse": "Identify where API consumers, providers, and dependent systems operate across internal networks, partner networks, public internet, and regulated regions. Describe the latency, trust, compliance, and connectivity implications between them.",
+      "purpose": "What geopolitical, regulatory, network, and trust boundaries affect this capability or integration?",
+      "howToUse": "Identify where consumers, producers, and dependent systems operate across internal networks, partner networks, public internet, and regulated regions. Describe the latency, trust, compliance, and connectivity implications between them.",
       "sections": {
         "locationGroups": {
           "section": "Location / Trust Groups",
@@ -771,13 +884,126 @@
           "description": "Any pending decisions or integration considerations?"
         }
       }
+    },
+    "capabilityValuePropositionCanvas": {
+      "title": "Capability Value Proposition Canvas",
+      "purpose": "Which reusable capability would create value for consumers without deciding yet whether it should be delivered as an API, event, file, stream, data product, or another implementation style?",
+      "howToUse": "Start from consumer tasks and outcomes. Capture gain-enabling and pain-relieving capability features, then describe candidate reusable capabilities without naming the technology too early.",
+      "sections": {
+        "consumerTasks": {
+          "section": "Consumer tasks and outcomes",
+          "description": "What are consumers, partners, users, systems, or teams trying to achieve?"
+        },
+        "gainEnablingCapabilities": {
+          "section": "Gain-enabling capability features",
+          "description": "What capability features would help consumers achieve better outcomes, speed, automation, insight, reach, or compliance?"
+        },
+        "painRelievingCapabilities": {
+          "section": "Pain-relieving capability features",
+          "description": "What capability features would remove friction, manual work, errors, delays, risk, or uncertainty for consumers?"
+        },
+        "reusableCapabilities": {
+          "section": "Reusable capabilities",
+          "description": "What reusable business or data capabilities could serve these tasks, gains, and pains across more than one consumer or use case?"
+        }
+      }
+    },
+    "capabilityBusinessModelCanvas": {
+      "title": "Capability Business Model Canvas",
+      "purpose": "How viable, reusable, funded, owned, supported, and discoverable should this integration capability be?",
+      "howToUse": "Summarize the capability value proposition, identify consumers and engagement channels, then map ownership, activities, resources, partners, benefits, and costs.",
+      "sections": {
+        "keyPartners": {
+          "section": "Key partners",
+          "description": "Which business, technology, data, security, legal, platform, or external partners are needed to make the capability work?"
+        },
+        "keyActivities": {
+          "section": "Key activities",
+          "description": "What must the capability owner and producers do to design, deliver, govern, support, and improve the capability?"
+        },
+        "keyResources": {
+          "section": "Key resources",
+          "description": "Which systems, data assets, platforms, people, standards, funding, and operational capabilities are required?"
+        },
+        "capabilityValueProposition": {
+          "section": "Capability value proposition",
+          "description": "What value does this reusable capability provide to consumers and to the organization or ecosystem?"
+        },
+        "consumerEngagement": {
+          "section": "Consumer engagement",
+          "description": "How will consumers discover, evaluate, request, onboard, get support for, and provide feedback on the capability?"
+        },
+        "channels": {
+          "section": "Channels",
+          "description": "Through which catalogs, portals, marketplaces, documentation sites, support paths, or governance processes will consumers interact with the capability?"
+        },
+        "capabilityConsumerSegments": {
+          "section": "Capability consumer segments",
+          "description": "Who are the current and potential consumers of the capability, including teams, partners, systems, products, or data users?"
+        },
+        "costs": {
+          "section": "Costs",
+          "description": "What are the significant costs of building, operating, governing, supporting, and evolving the capability?"
+        },
+        "benefits": {
+          "section": "Benefits",
+          "description": "What business, operational, ecosystem, reuse, compliance, or cost benefits justify the capability?"
+        }
+      }
+    },
+    "consumerExperienceRequirementsCanvas": {
+      "title": "Consumer Experience Requirements Canvas",
+      "purpose": "What experience and non-functional requirements do consumers need before deciding the best integration architecture?",
+      "howToUse": "Use this as a technology-agnostic requirements table. Capture consumer expectations and constraints, then use the architecture implications to choose APIs, events, files, streams, data products, or another implementation style.",
+      "sections": {
+        "consumerGoals": {
+          "section": "Consumer goals",
+          "description": "What are the consumer's business goals, workflow goals, decision goals, automation goals, or data usage goals?"
+        },
+        "availabilityAndTimeliness": {
+          "section": "Availability and timeliness",
+          "description": "When must the capability be available, how fresh must information be, and what latency or delivery windows matter?"
+        },
+        "volumeAndPerformance": {
+          "section": "Volume and performance",
+          "description": "What request, event, record, file, batch, user, or transaction volumes must the capability support now and later?"
+        },
+        "dataQualityAndConsistency": {
+          "section": "Data quality and consistency",
+          "description": "What accuracy, completeness, consistency, ordering, deduplication, reconciliation, or validation expectations do consumers have?"
+        },
+        "securityPrivacyAndCompliance": {
+          "section": "Security, privacy, and compliance",
+          "description": "What identity, authorization, confidentiality, residency, consent, retention, audit, or regulatory constraints apply?"
+        },
+        "onboardingAndAccess": {
+          "section": "Onboarding and access",
+          "description": "How should consumers find, request, test, get approved for, and start using the capability?"
+        },
+        "changeAndVersioning": {
+          "section": "Change and versioning",
+          "description": "How much change tolerance do consumers have, and what notice, compatibility, migration, or versioning expectations apply?"
+        },
+        "observabilityAndSupport": {
+          "section": "Observability and support",
+          "description": "What monitoring, status, traceability, data quality visibility, support, ownership, and incident communication do consumers need?"
+        },
+        "recoveryAndContinuity": {
+          "section": "Recovery and continuity",
+          "description": "What replay, retry, reconciliation, backup, fallback, continuity, or manual recovery expectations must be supported?"
+        },
+        "architectureImplications": {
+          "section": "Architecture implications",
+          "description": "What do these requirements imply for possible architecture styles, such as APIs, events, files, streams, data products, or direct integration?"
+        }
+      }
     }
   },
   "fi": {
     "apiBusinessModelCanvas": {
-      "title": "API Business Model Canvas",
-      "purpose": "Kuinka toteuttamiskelpoinen ja uudelleenkäytettävä API on? Onko meillä liiketoimintaperuste kustannus-hyötynäkökulmasta?",
-      "howToUse": "Yhteenveto APIn arvolupauksesta API Value Proposition Canvasin pohjalta, ja etene sitten numeroidussa järjestyksessä.",
+      "title": "API-liiketoimintamallikanvas",
+      "purpose": "Kuinka elinkelpoinen ja uudelleenkäytettävä tämä API on? Onko sille kustannus-hyötynäkökulmasta perusteltu liiketoimintamalli?",
+      "howToUse": "Tiivistä API-rajapinnan arvolupaus API-arvolupauskanvas -kanvaksesta ja etene numeroidussa järjestyksessä.",
       "sections": {
         "keyPartners": {
           "section": "Keskeiset kumppanit",
@@ -793,7 +1019,7 @@
         },
         "apiValueProposition": {
           "section": "APIn arvolupaus",
-          "description": "Aloita yhdellä tarralapulla, jossa nimeät APIn tai API-perheen, kerro sitten mitä arvoa API tarjoaa API-käyttäjille."
+          "description": "Aloita yhdellä tarralapulla, jossa nimeät APIn tai API-perheen, kerro sitten mitä arvoa API tarjoaa API-hyödyntäjille."
         },
         "developerRelations": {
           "section": "Suhde kehittäjiin",
@@ -804,7 +1030,7 @@
           "description": "Minkä kanavien kautta APIn käyttäjät ovat vuorovaikutuksessa APIn kanssa?"
         },
         "apiConsumerSegments": {
-          "section": "APIn kohderyhmät",
+          "section": "API-hyödyntäjäsegmentit",
           "description": "Keitä ovat APIn kohdeyleisöt?"
         },
         "costs": {
@@ -818,21 +1044,21 @@
       }
     },
     "apiValuePropositionCanvas": {
-      "title": "API Value Proposition Canvas",
-      "purpose": "Miten asiakaspolku liittyy API-rajapintoihin? Mitä loppukäyttäjien ja API-käyttäjien ongelmia ja hyötyjä on käsiteltävä?",
-      "howToUse": "Kuvaile loppukäyttäjien näkökulmaa aloittaen heidän tehtävistään, sitten heidän ja API-käyttäjien ongelmista ja hyödyistä ja lopuksi API:n tuotteista ja ominaisuuksista.",
+      "title": "API-arvolupauskanvas",
+      "purpose": "Miten asiakaspolku liittyy API-rajapintoihin? Mitkä loppukäyttäjien ja API-hyödyntäjien kipupisteet ja tavoitellut hyödyt täytyy huomioida?",
+      "howToUse": "Kuvaa loppukäyttäjien näkökulma aloittamalla heidän tehtävistään, kipupisteistään ja hyödyistään. Lisää sen jälkeen API-hyödyntäjien vastaavat tarpeet sekä API-tuotteet ja API-ominaisuudet.",
       "sections": {
         "tasks": {
           "section": "Tehtävät",
-          "description": "Mitä asiakkaat (loppukäyttäjät) yrittävät saavuttaa?"
+          "description": "Mitä asiakkaat tai loppukäyttäjät yrittävät saavuttaa?"
         },
         "gainEnablingFeatures": {
-          "section": "Hyötyä mahdollistavat ominaisuudet",
-          "description": "Mitkä ominaisuudet mahdollistavat loppukäyttäjien ja API-käyttäjien hyötyjen saavuttamisen?"
+          "section": "Hyötyjä mahdollistavat ominaisuudet",
+          "description": "Mitkä ominaisuudet auttavat loppukäyttäjiä ja API-hyödyntäjiä saavuttamaan tavoitellut hyödyt?"
         },
         "painRelievingFeatures": {
-          "section": "Kipua lievittävät ominaisuudet",
-          "description": "Mitkä ominaisuudet auttavat loppukäyttäjiä ja API-käyttäjiä voittamaan ongelmia?"
+          "section": "Kipupisteitä vähentävät ominaisuudet",
+          "description": "Mitkä ominaisuudet auttavat loppukäyttäjiä ja API-hyödyntäjiä vähentämään kipupisteitä?"
         },
         "apiProducts": {
           "section": "APIn tuotteet",
@@ -841,9 +1067,9 @@
       }
     },
     "businessImpactCanvas": {
-      "title": "Business Impact Canvas",
-      "purpose": "Mitkä ovat mahdolliset liiketoiminnalliset vaikutukset APIn virhetilanteissa?",
-      "howToUse": "Ota huomioon mahdolliset vaikutukset saatavuuteen, tietoturvaan ja dataan kullekin APIlle.",
+      "title": "Liiketoimintavaikutuskanvas",
+      "purpose": "Mitkä ovat kyvykkyyden tai rajapinnan epäonnistumisen mahdolliset liiketoimintavaikutukset?",
+      "howToUse": "Arvioi vaikutukset saatavuuteen, turvallisuuteen, dataan ja operointiin ennen toteutustyylin lukitsemista.",
       "sections": {
         "availabilityRisks": {
           "section": "Saatavuuteen liittyvät riskit",
@@ -851,7 +1077,7 @@
         },
         "securityRisks": {
           "section": "Tietoturvariskit",
-          "description": "Mitkä ovat APIin liittyvät mahdolliset tietoturvariskit?"
+          "description": "Mitkä ovat API-rajapintaan liittyvät mahdolliset tietoturvariskit?"
         },
         "dataRisks": {
           "section": "Tietoriskit",
@@ -872,9 +1098,9 @@
       }
     },
     "capacityCanvas": {
-      "title": "Capacity Canvas",
-      "purpose": "Kuinka paljon kapasiteettia tarvitaan APIn käytön tukemiseksi?",
-      "howToUse": "Analysoi kunkin APIn nykyiset ja tulevat kapasiteettitarpeet.",
+      "title": "Kapasiteettikanvas",
+      "purpose": "Kuinka paljon kapasiteettia kyvykkyyden tai rajapinnan käytön tukeminen edellyttää?",
+      "howToUse": "Analysoi nykyiset ja tulevat kapasiteettivaatimukset kyvykkyydelle tai rajapinnalle.",
       "sections": {
         "currentBusinessVolumes": {
           "section": "Nykyinen liiketoimintavolyymi",
@@ -903,9 +1129,9 @@
       }
     },
     "customerJourneyCanvas": {
-      "title": "Customer Journey Canvas",
-      "purpose": "Mikä on se asiakkaan tai kumppanin asiakaspolku, jota API:n tulisi tukea?",
-      "howToUse": "Kuvaa oikea asiakkaan tai käyttäjän polku, ei API:n käyttöpolkua. Tunnista kipupisteet, tavoitteet ja konteksti. Tämä toimii pohjana API-tarpeiden ja arvolupausten muotoilulle.",
+      "title": "Asiakaspolkukanvas",
+      "purpose": "Mikä asiakkaan tai kumppanin polku synnyttää tarpeen kyvykkyydelle tai rajapinnalle?",
+      "howToUse": "Kuvaa todellinen asiakkaan, kumppanin tai käyttäjän polku, ei API-rajapinnan käyttöä. Polku tuo näkyviin kipupisteet, tavoitteet ja kontekstin, jotka auttavat määrittämään kyvykkyyden ja rajapinnan vaatimukset.",
       "sections": {
         "customerDiscoversNeed": {
           "section": "Asiakas havaitsee tarpeen",
@@ -942,9 +1168,9 @@
       }
     },
     "domainCanvas": {
-      "title": "Domain Canvas",
-      "purpose": "Mitkä ovat APIn keskeiset entiteetit ja liiketoimintasäännöt?",
-      "howToUse": "Määrittele kunkin APIn toimialuemalli, mukaan lukien entiteetit, attribuutit ja suhteet.",
+      "title": "Toimialuekanvas",
+      "purpose": "Mitkä keskeiset käsitteet, entiteetit ja toimialueen säännöt kyvykkyyden tai rajapinnan täytyy huomioida?",
+      "howToUse": "Määritä toimialuemalli kyvykkyydelle tai rajapinnalle, mukaan lukien entiteetit, attribuutit ja suhteet.",
       "sections": {
         "selectedCustomerJourneySteps": {
           "section": "Valitut asiakaspolun vaiheet",
@@ -973,9 +1199,9 @@
       }
     },
     "eventCanvas": {
-      "title": "Event Canvas",
-      "purpose": "Mitkä tapahtumat liittyvät APIin ja miten ne käsitellään?",
-      "howToUse": "Määrittele tapahtumat, niiden laukaisijat ja käsittelylogiikka kullekin APIlle.",
+      "title": "Tapahtumakanvas",
+      "purpose": "Mitkä tapahtumat ovat olennaisia kyvykkyydelle tai rajapinnalle ja miten ne käsitellään?",
+      "howToUse": "Määritä tapahtumat, niiden laukaisijat ja käsittelylogiikka kyvykkyydelle tai rajapinnalle.",
       "sections": {
         "userTaskTrigger": {
           "section": "Käyttäjän tehtävä / Laukaisija",
@@ -996,9 +1222,9 @@
       }
     },
     "interactionCanvas": {
-      "title": "Interaction Canvas",
-      "purpose": "Minkälaisia vuorovaikutustapoja tämän APIn tulisi tukea ennen protokollakohtaisen suunnittelun valitsemista?",
-      "howToUse": "Määritä, mitkä vuorovaikutustavat ovat tämän APIn kannalta todella tarpeellisia ja mitkä eivät kuulu sen piiriin. Käytä tätä kankaata tarkentamaan tarkoitusta ennen tuloksen kartoittamista RESTiin, eventeihin tai GraphQLään.",
+      "title": "Vuorovaikutuskanvas",
+      "purpose": "Minkä tyyppisiä vuorovaikutuksia kyvykkyyden tai rajapinnan täytyy tukea ennen protokollakohtaisen suunnittelun valintaa?",
+      "howToUse": "Tunnista, mitä vuorovaikutustyylejä todella tarvitaan ja mitkä jäävät rajauksen ulkopuolelle. Käytä kanvasta tarkoituksen selkeyttämiseen ennen kuin ratkaisu mallinnetaan REST-, tapahtuma- tai GraphQL-toteutukseksi.",
       "sections": {
         "crudInteractions": {
           "section": "CRUD-vuorovaikutukset",
@@ -1014,7 +1240,7 @@
         },
         "queryDrivenInteractions": {
           "section": "Kyselyohjatut vuorovaikutukset",
-          "description": "Mitä luku- tai kyselyvuorovaikutuksia tarvitaan vastaamaan kuluttajien kysymyksiin?"
+          "description": "Mitä luku- tai kyselyvuorovaikutuksia tarvitaan vastaamaan hyödyntäjien kysymyksiin?"
         },
         "queryDrivenInputOutputModels": {
           "section": "Kyselyohjatut syötteet ja vastaukset",
@@ -1051,9 +1277,9 @@
       }
     },
     "locationsCanvas": {
-      "title": "Locations Canvas",
-      "purpose": "”Mitkä geopoliittiset, sääntely-, verkko- ja luottamusrajat vaikuttavat tähän APIin?",
-      "howToUse": "Tunnista, missä APIn käyttäjät, tarjoajat ja riippuvaiset järjestelmät toimivat sisäisissä verkoissa, kumppaniverkoissa, julkisessa internetissä ja säännellyillä alueilla. Kuvaile niiden välisiä viive-, luottamus-, vaatimustenmukaisuus- ja yhteysvaikutuksia.",
+      "title": "Sijaintikanvas",
+      "purpose": "Mitkä geopoliittiset, sääntelyyn liittyvät, verkko- ja luottamusrajat vaikuttavat tähän kyvykkyyteen tai rajapintaan?",
+      "howToUse": "Tunnista, missä hyödyntäjät, tuottajat ja riippuvat järjestelmät toimivat sisäverkoissa, kumppaniverkoissa, julkisessa internetissä ja säännellyillä alueilla. Kuvaa vaikutukset latenssiin, luottamukseen, vaatimustenmukaisuuteen ja yhteyksiin.",
       "sections": {
         "locationGroups": {
           "section": "Sijainti-/luottamusryhmät",
@@ -1090,7 +1316,7 @@
       }
     },
     "restCanvas": {
-      "title": "REST Canvas",
+      "title": "REST-kanvas",
       "purpose": "Miten API voidaan suunnitella REST-periaatteiden mukaisesti?",
       "howToUse": "Määrittele APIn resurssit, verbit sekä esimerkkipyynnöt ja -vastaukset.",
       "sections": {
@@ -1113,9 +1339,9 @@
       }
     },
     "graphqlCanvas": {
-      "title": "GraphQL Canvas",
-      "purpose": "Kuinka API voidaan suunnitella GraphQL-periaatteiden mukaisesti?",
-      "howToUse": "Määrittele keskeiset tyypit, kyselyt, mutaatiot ja rajoitukset GraphQL-API:a varten.",
+      "title": "GraphQL-kanvas",
+      "purpose": "Miten API voidaan suunnitella GraphQL-periaatteiden mukaisesti?",
+      "howToUse": "Määritä GraphQL-API-rajapinnan keskeiset tyypit, kyselyt, mutaatiot ja rajoitteet.",
       "sections": {
         "apiName": {
           "section": "APIn nimi",
@@ -1158,13 +1384,126 @@
           "description": "Onko keskeneräisiä päätöksiä tai integraatioon liittyviä huomioita?"
         }
       }
+    },
+    "capabilityValuePropositionCanvas": {
+      "title": "Kyvykkyyden arvolupauskanvas",
+      "purpose": "Mikä uudelleenkäytettävä kyvykkyys loisi arvoa hyödyntäjille ilman, että vielä päätetään toteutetaanko se API-rajapintana, tapahtumana, tiedostona, streamina, datatuotteena tai muuna integraatiotyylinä?",
+      "howToUse": "Aloita hyödyntäjien tehtävistä ja lopputuloksista. Kuvaa hyödyt mahdollistavat ja kipupisteitä vähentävät kyvykkyyden ominaisuudet. Määritä sen jälkeen mahdolliset uudelleenkäytettävät kyvykkyydet nimeämättä teknologiaa liian aikaisin.",
+      "sections": {
+        "consumerTasks": {
+          "section": "Hyödyntäjien tehtävät ja lopputulokset",
+          "description": "Mitä hyödyntäjät, kumppanit, käyttäjät, järjestelmät tai tiimit yrittävät saavuttaa?"
+        },
+        "gainEnablingCapabilities": {
+          "section": "Hyötyjä mahdollistavat kyvykkyyden ominaisuudet",
+          "description": "Mitkä kyvykkyyden ominaisuudet auttaisivat hyödyntäjiä saavuttamaan parempia tuloksia, nopeutta, automaatiota, oivalluksia, kattavuutta tai vaatimustenmukaisuutta?"
+        },
+        "painRelievingCapabilities": {
+          "section": "Kipupisteitä vähentävät kyvykkyyden ominaisuudet",
+          "description": "Mitkä kyvykkyyden ominaisuudet poistaisivat kitkaa, manuaalista työtä, virheitä, viiveitä, riskejä tai epävarmuutta hyödyntäjiltä?"
+        },
+        "reusableCapabilities": {
+          "section": "Uudelleenkäytettävät kyvykkyydet",
+          "description": "Mitkä uudelleenkäytettävät liiketoiminta- tai datakyvykkyydet voisivat palvella näitä tehtäviä, hyötyjä ja kipupisteitä useamman kuin yhden hyödyntäjän tai käyttötapauksen tarpeisiin?"
+        }
+      }
+    },
+    "capabilityBusinessModelCanvas": {
+      "title": "Kyvykkyyden liiketoimintamallikanvas",
+      "purpose": "Kuinka elinkelpoinen, uudelleenkäytettävä, rahoitettu, omistettu, tuettu ja löydettävä tämän integraatiokyvykkyyden tulisi olla?",
+      "howToUse": "Tiivistä kyvykkyyden arvolupaus, tunnista hyödyntäjät ja osallistamiskanavat sekä kartoita omistajuus, toiminnot, resurssit, kumppanit, hyödyt ja kustannukset.",
+      "sections": {
+        "keyPartners": {
+          "section": "Keskeiset kumppanit",
+          "description": "Mitä liiketoiminnan, teknologian, datan, turvallisuuden, juridiikan, alustan tai ulkoisia kumppaneita tarvitaan, jotta kyvykkyys toimii?"
+        },
+        "keyActivities": {
+          "section": "Keskeiset toiminnot",
+          "description": "Mitä kyvykkyyden omistajan ja tuottajien täytyy tehdä kyvykkyyden suunnittelemiseksi, toimittamiseksi, hallitsemiseksi, tukemiseksi ja parantamiseksi?"
+        },
+        "keyResources": {
+          "section": "Keskeiset resurssit",
+          "description": "Mitä järjestelmiä, data-aineistoja, alustoja, ihmisiä, standardeja, rahoitusta ja operatiivisia kyvykkyyksiä tarvitaan?"
+        },
+        "capabilityValueProposition": {
+          "section": "Kyvykkyyden arvolupaus",
+          "description": "Mitä arvoa tämä uudelleenkäytettävä kyvykkyys tuottaa hyödyntäjille sekä organisaatiolle tai ekosysteemille?"
+        },
+        "consumerEngagement": {
+          "section": "Hyödyntäjien osallistaminen",
+          "description": "Miten hyödyntäjät löytävät, arvioivat, pyytävät käyttöönsä, ottavat käyttöön, saavat tukea ja antavat palautetta kyvykkyydestä?"
+        },
+        "channels": {
+          "section": "Kanavat",
+          "description": "Minkä katalogien, portaalien, markkinapaikkojen, dokumentaatiosivustojen, tukikanavien tai governance-prosessien kautta hyödyntäjät ovat vuorovaikutuksessa kyvykkyyden kanssa?"
+        },
+        "capabilityConsumerSegments": {
+          "section": "Kyvykkyyden hyödyntäjäsegmentit",
+          "description": "Ketkä ovat kyvykkyyden nykyisiä ja mahdollisia hyödyntäjiä, mukaan lukien tiimit, kumppanit, järjestelmät, tuotteet tai datan käyttäjät?"
+        },
+        "costs": {
+          "section": "Kustannukset",
+          "description": "Mitkä ovat kyvykkyyden rakentamisen, operoinnin, governancen, tuen ja kehittämisen merkittävät kustannukset?"
+        },
+        "benefits": {
+          "section": "Hyödyt",
+          "description": "Mitkä liiketoiminnalliset, operatiiviset, ekosysteemiin, uudelleenkäyttöön, vaatimustenmukaisuuteen tai kustannuksiin liittyvät hyödyt perustelevat kyvykkyyden?"
+        }
+      }
+    },
+    "consumerExperienceRequirementsCanvas": {
+      "title": "Hyödyntäjäkokemuksen vaatimuskanvas",
+      "purpose": "Mitä kokemukseen liittyviä ja ei-toiminnallisia vaatimuksia hyödyntäjillä on ennen parhaan integraatioarkkitehtuurin valintaa?",
+      "howToUse": "Käytä tätä teknologiariippumattomana vaatimuskanvaksena. Kuvaa hyödyntäjien odotukset ja rajoitteet ja käytä arkkitehtuurivaikutuksia API-rajapintojen, tapahtumien, tiedostojen, streamien, datatuotteiden tai muun mallin valintaan.",
+      "sections": {
+        "consumerGoals": {
+          "section": "Hyödyntäjien tavoitteet",
+          "description": "Mitkä ovat hyödyntäjien liiketoiminta-, työnkulku-, päätöksenteko-, automaatio- tai datankäyttötavoitteet?"
+        },
+        "availabilityAndTimeliness": {
+          "section": "Saatavuus ja ajantasaisuus",
+          "description": "Milloin kyvykkyyden täytyy olla saatavilla, kuinka ajantasaista tiedon täytyy olla ja millä latenssi- tai toimitusikkunoilla on merkitystä?"
+        },
+        "volumeAndPerformance": {
+          "section": "Volyymi ja suorituskyky",
+          "description": "Mitä pyyntö-, tapahtuma-, tietue-, tiedosto-, eräajo-, käyttäjä- tai transaktiovolyymeja kyvykkyyden täytyy tukea nyt ja myöhemmin?"
+        },
+        "dataQualityAndConsistency": {
+          "section": "Datan laatu ja yhdenmukaisuus",
+          "description": "Mitä tarkkuuteen, täydellisyyteen, yhdenmukaisuuteen, järjestykseen, deduplikointiin, täsmäytykseen tai validointiin liittyviä odotuksia hyödyntäjillä on?"
+        },
+        "securityPrivacyAndCompliance": {
+          "section": "Turvallisuus, tietosuoja ja vaatimustenmukaisuus",
+          "description": "Mitä identiteettiin, valtuutukseen, luottamuksellisuuteen, datan sijaintiin, suostumukseen, säilytykseen, auditointiin tai sääntelyyn liittyviä rajoitteita sovelletaan?"
+        },
+        "onboardingAndAccess": {
+          "section": "Käyttöönotto ja pääsy",
+          "description": "Miten hyödyntäjien tulisi löytää, pyytää, testata, saada hyväksyntä ja aloittaa kyvykkyyden käyttö?"
+        },
+        "changeAndVersioning": {
+          "section": "Muutokset ja versiointi",
+          "description": "Kuinka paljon muutoksia hyödyntäjät sietävät ja mitä ennakkoilmoituksiin, yhteensopivuuteen, migraatioon tai versiointiin liittyviä odotuksia sovelletaan?"
+        },
+        "observabilityAndSupport": {
+          "section": "Havainnoitavuus ja tuki",
+          "description": "Mitä monitorointia, tilatietoa, jäljitettävyyttä, datan laadun näkyvyyttä, tukea, omistajuutta ja häiriöviestintää hyödyntäjät tarvitsevat?"
+        },
+        "recoveryAndContinuity": {
+          "section": "Palautuminen ja jatkuvuus",
+          "description": "Mitä uudelleentoistoon, uudelleenyrityksiin, täsmäytykseen, varmuuskopiointiin, varamenettelyihin, jatkuvuuteen tai manuaaliseen palautumiseen liittyviä odotuksia täytyy tukea?"
+        },
+        "architectureImplications": {
+          "section": "Arkkitehtuurivaikutukset",
+          "description": "Mitä nämä vaatimukset tarkoittavat mahdollisille arkkitehtuurityyleille, kuten API-rajapinnoille, tapahtumille, tiedostoille, streameille, datatuotteille tai suoralle integraatiolle?"
+        }
+      }
     }
   },
   "fr": {
     "apiBusinessModelCanvas": {
       "title": "API Business Model Canvas",
-      "purpose": "Dans quelle mesure cette API sera-t-elle viable et réutilisable ? Avons-nous un cas commercial du point de vue coût-bénéfice ?",
-      "howToUse": "Résumez la proposition de valeur d'une API à partir du Canvas de proposition de valeur API, puis suivez la séquence numérotée.",
+      "purpose": "Quelle sera la viabilité et la réutilisabilité de cette API ? Existe-t-il un modèle métier justifié du point de vue coût-bénéfice ?",
+      "howToUse": "Résumer la proposition de valeur d’une API à partir de l’API Value Proposition Canvas, puis suivre la séquence numérotée.",
       "sections": {
         "keyPartners": {
           "section": "Partenaires clés",
@@ -1172,54 +1511,54 @@
         },
         "keyActivities": {
           "section": "Activités clés",
-          "description": "Quelles sont les actions les plus importantes que le fournisseur d'API doit entreprendre pour réussir?"
+          "description": "Quelles sont les actions les plus importantes que le fournisseur d’API doit entreprendre pour réussir?"
         },
         "keyResources": {
           "section": "Ressources clés",
-          "description": "Quels actifs stratégiques uniques le fournisseur d'API doit-il acquérir ou développer?"
+          "description": "Quels actifs stratégiques uniques le fournisseur d’API doit-il acquérir ou développer?"
         },
         "apiValueProposition": {
-          "section": "Proposition de valeur de l'API",
-          "description": "Commencez par une note adhésive indiquant le nom de l'API ou de la famille d'API, puis notez la valeur ajoutée que l'API offre aux consommateurs d'API."
+          "section": "Proposition de valeur de l’API",
+          "description": "Commencez par une note adhésive indiquant le nom de l’API ou de la famille d’API, puis notez la valeur ajoutée que l’API offre aux utilisateurs API."
         },
         "developerRelations": {
           "section": "Relations développeurs",
-          "description": "Comment le fournisseur d'API atteint-il et soutient-il les consommateurs d'API?"
+          "description": "Comment le fournisseur d’API atteint-il et soutient-il les utilisateurs API?"
         },
         "channels": {
           "section": "Canaux",
-          "description": "Par quels mécanismes les consommateurs d'API interagissent-ils avec l'API?"
+          "description": "Par quels mécanismes les utilisateurs API interagissent-ils avec l’API?"
         },
         "apiConsumerSegments": {
-          "section": "Segments de consommateurs de l'API",
-          "description": "Quelles sont les audiences cibles pour l'API?"
+          "section": "Segments d’utilisateurs API",
+          "description": "Quelles sont les audiences cibles pour l’API?"
         },
         "costs": {
           "section": "Coûts",
-          "description": "Quels sont les coûts importants liés à la création, au déploiement et à l'exploitation de l'API?"
+          "description": "Quels sont les coûts importants liés à la création, au déploiement et à l'exploitation de l’API?"
         },
         "benefits": {
           "section": "Avantages",
-          "description": "Quels sont les avantages significatifs ou les sources de revenus générés par l'API?"
+          "description": "Quels sont les avantages significatifs ou les sources de revenus générés par l’API?"
         }
       }
     },
     "apiValuePropositionCanvas": {
       "title": "API Value Proposition Canvas",
-      "purpose": "Comment le parcours client s'articule-t-il avec les API ? Quels sont les problèmes et les avantages rencontrés par les utilisateurs finaux et les consommateurs d'API ?",
-      "howToUse": "Décrire le point de vue des utilisateurs finaux, en commençant par leurs tâches, puis leurs problèmes et avantages ainsi que ceux des consommateurs d'API, et enfin les produits et fonctionnalités de l'API.",
+      "purpose": "Comment le parcours client est-il lié aux API ? Quels irritants et gains des utilisateurs finaux et des utilisateurs API doivent être traités ?",
+      "howToUse": "Décrire la perspective des utilisateurs finaux, en commençant par leurs tâches, puis leurs irritants et gains ainsi que ceux des utilisateurs API, et enfin les produits et fonctionnalités API.",
       "sections": {
         "tasks": {
           "section": "Tâches",
-          "description": "Qu'est-ce que les clients (utilisateurs finaux) cherchent à réaliser ?"
+          "description": "Que cherchent à accomplir les clients ou utilisateurs finaux ?"
         },
         "gainEnablingFeatures": {
           "section": "Fonctionnalités génératrices de gains",
-          "description": "Quelles fonctionnalités permettent aux utilisateurs finaux et aux consommateurs d'API de réaliser des gains ?"
+          "description": "Quelles fonctionnalités aident les utilisateurs finaux et les utilisateurs API à obtenir les gains attendus ?"
         },
         "painRelievingFeatures": {
-          "section": "Fonctionnalités soulageant les peines",
-          "description": "Quelles fonctionnalités aident les utilisateurs finaux et les consommateurs d'API à surmonter les difficultés ?"
+          "section": "Fonctionnalités qui réduisent les irritants",
+          "description": "Quelles fonctionnalités aident les utilisateurs finaux et les utilisateurs API à réduire les irritants ?"
         },
         "apiProducts": {
           "section": "Produits API",
@@ -1229,39 +1568,39 @@
     },
     "businessImpactCanvas": {
       "title": "Business Impact Canvas",
-      "purpose": "Quels sont les impacts commerciaux potentiels d'une défaillance de l'API?",
-      "howToUse": "Considérez l'impact potentiel sur la disponibilité, la sécurité et les données pour chaque API.",
+      "purpose": "Quels impacts métier une défaillance ou un mauvais comportement de la capacité ou de l’interface peut-il avoir ?",
+      "howToUse": "Évaluer les impacts potentiels sur la disponibilité, la sécurité, les données et les opérations avant de figer le mode de mise en œuvre.",
       "sections": {
         "availabilityRisks": {
           "section": "Risques de disponibilité",
-          "description": "Quels sont les risques potentiels pour la disponibilité de l'API?"
+          "description": "Quels sont les risques potentiels pour la disponibilité de l’API?"
         },
         "securityRisks": {
           "section": "Risques de sécurité",
-          "description": "Quels sont les risques de sécurité potentiels associés à l'API?"
+          "description": "Quels sont les risques de sécurité potentiels associés à l’API?"
         },
         "dataRisks": {
           "section": "Risques liés aux données",
-          "description": "Quels sont les risques potententiels pour l'intégrité ou la confidentialité des données?"
+          "description": "Quels sont les risques potententiels pour l'intégrité ou la protection des données?"
         },
         "mitigateAvailabilityRisks": {
           "section": "Atténuer les risques de disponibilité",
-          "description": "Comment le fournisseur d'API peut-il atténuer les risques de disponibilité?"
+          "description": "Comment le fournisseur d’API peut-il atténuer les risques de disponibilité?"
         },
         "mitigateSecurityRisks": {
           "section": "Atténuer les risques de sécurité",
-          "description": "Comment le fournisseur d'API peut-il atténuer les risques de sécurité?"
+          "description": "Comment le fournisseur d’API peut-il atténuer les risques de sécurité?"
         },
         "mitigateDataRisks": {
           "section": "Atténuer les risques liés aux données",
-          "description": "Comment le fournisseur d'API peut-il atténuer les risques liés aux données?"
+          "description": "Comment le fournisseur d’API peut-il atténuer les risques liés aux données?"
         }
       }
     },
     "capacityCanvas": {
       "title": "Capacity Canvas",
-      "purpose": "Quelle capacité est nécessaire pour soutenir la consommation de l'API?",
-      "howToUse": "Analysez les besoins de capacité actuels et futurs pour chaque API.",
+      "purpose": "Quelle capacité est nécessaire pour soutenir l’usage de la capacité ou de l’interface ?",
+      "howToUse": "Analyser les exigences de capacité actuelles et futures pour la capacité ou l’interface.",
       "sections": {
         "currentBusinessVolumes": {
           "section": "Volumes d'activité actuels",
@@ -1291,8 +1630,8 @@
     },
     "customerJourneyCanvas": {
       "title": "Customer Journey Canvas",
-      "purpose": "Quel est le parcours client ou partenaire que l'API est censée soutenir?",
-      "howToUse": "Décrivez un parcours client ou utilisateur réel — pas l'utilisation de l'API — afin de révéler les points de douleur, les objectifs et le contexte. Ces informations aident à définir le type de support API réellement nécessaire plus tard.",
+      "purpose": "Quel parcours client ou partenaire crée le besoin de capacité ou d’interface ?",
+      "howToUse": "Décrire un parcours réel de client, partenaire ou utilisateur, et non l’usage de l’API elle-même. Ce parcours révèle les irritants, objectifs et contextes qui aident à définir les exigences de capacité et d’interface.",
       "sections": {
         "customerDiscoversNeed": {
           "section": "Le client découvre le besoin",
@@ -1304,7 +1643,7 @@
         },
         "pains": {
           "section": "Douleurs",
-          "description": "Quels sont les points de douleur ou défis du client?"
+          "description": "Quels sont les irritants ou défis du client?"
         },
         "journeySteps": {
           "section": "Étapes du parcours",
@@ -1330,8 +1669,8 @@
     },
     "domainCanvas": {
       "title": "Domain Canvas",
-      "purpose": "Quelles sont les entités principales et les règles métier liées à l'API?",
-      "howToUse": "Définissez le modèle de domaine pour chaque API, incluant entités, attributs et relations.",
+      "purpose": "Quels concepts, entités et règles de domaine métier la capacité ou l’interface doit-elle respecter ?",
+      "howToUse": "Définir le modèle de domaine métier pour la capacité ou l’interface, y compris entités, attributs et relations.",
       "sections": {
         "selectedCustomerJourneySteps": {
           "section": "Étapes du parcours client sélectionnées",
@@ -1361,8 +1700,8 @@
     },
     "eventCanvas": {
       "title": "Event Canvas",
-      "purpose": "Quels événements sont pertinents pour l'API et comment sont-ils traités?",
-      "howToUse": "Définissez les événements, leurs déclencheurs et la logique de traitement pour chaque API.",
+      "purpose": "Quels événements sont pertinents pour la capacité ou l’interface, et comment sont-ils traités ?",
+      "howToUse": "Définir les événements, leurs déclencheurs et la logique de traitement pour la capacité ou l’interface.",
       "sections": {
         "userTaskTrigger": {
           "section": "Tâche utilisateur / Déclencheur",
@@ -1374,7 +1713,7 @@
         },
         "processingLogic": {
           "section": "Traitement / Logique",
-          "description": "Décrivez la logique de traitement backend, y compris les validations, transformations ou décisions de routage."
+          "description": "Décrivez la logique de traitement systèmes backend, y compris les validations, transformations ou décisions de routage."
         },
         "outputEventResult": {
           "section": "Sortie / Résultat de l'événement",
@@ -1384,8 +1723,8 @@
     },
     "interactionCanvas": {
       "title": "Interaction Canvas",
-      "purpose": "Quels types d'interactions cette API doit-elle prendre en charge avant de choisir une conception spécifique à un protocole ?",
-      "howToUse": "Identifiez les styles d'interaction réellement nécessaires pour cette API et ceux qui ne relèvent pas de son champ d'application. Utilisez ce canevas pour clarifier l'intention avant de mapper le résultat vers REST, des événements ou GraphQL.",
+      "purpose": "Quels types d’interactions cette capacité ou interface doit-elle prendre en charge avant de choisir une conception propre au protocole ?",
+      "howToUse": "Identifier les styles d’interaction réellement nécessaires et ceux qui sont hors périmètre. Utiliser ce canvas pour clarifier l’intention avant de mapper le résultat vers REST, événements ou GraphQL.",
       "sections": {
         "crudInteractions": {
           "section": "Interactions CRUD",
@@ -1439,8 +1778,8 @@
     },
     "locationsCanvas": {
       "title": "Locations Canvas",
-      "purpose": "Quelles sont les frontières géopolitiques, réglementaires, réseau et de confiance qui affectent cette API ?",
-      "howToUse": "Identifiez où les consommateurs, les fournisseurs et les systèmes dépendants de l'API opèrent sur les réseaux internes, les réseaux partenaires, l'Internet public et les régions réglementées. Décrivez les implications en termes de latence, de confiance, de conformité et de connectivité entre eux.",
+      "purpose": "Quelles frontières géopolitiques, réglementaires, réseau et de confiance affectent cette capacité ou interface ?",
+      "howToUse": "Identifier où les utilisateurs, fournisseurs et systèmes dépendants opèrent dans les réseaux internes, réseaux partenaires, Internet public et régions réglementées. Décrire les implications sur la latence, la confiance, la conformité et la connectivité.",
       "sections": {
         "locationGroups": {
           "section": "Groupes de localisation / de confiance",
@@ -1478,20 +1817,20 @@
     },
     "restCanvas": {
       "title": "REST Canvas",
-      "purpose": "Comment l'API peut-elle être conçue selon les principes REST?",
-      "howToUse": "Définissez les ressources de l'API, les verbes et les exemples de requêtes et réponses.",
+      "purpose": "Comment concevoir l’API selon les principes RESTful ?",
+      "howToUse": "Définissez les ressources de l’API, les verbes et les exemples de requêtes et réponses.",
       "sections": {
         "apiResources": {
           "section": "Ressources API",
-          "description": "Quelles sont les ressources clés exposées par l'API?"
+          "description": "Quelles sont les ressources clés exposées par l’API?"
         },
         "apiResourceModel": {
           "section": "Modèle de ressource API",
-          "description": "Quelle est la structure du modèle de ressources de l'API?"
+          "description": "Quelle est la structure du modèle de ressources de l’API?"
         },
         "apiVerbs": {
           "section": "Verbes API",
-          "description": "Quels verbes HTTP sont utilisés pour interagir avec les ressources de l'API?"
+          "description": "Quels verbes HTTP sont utilisés pour interagir avec les ressources de l’API?"
         },
         "apiVerbExample": {
           "section": "Exemple de verbe API",
@@ -1501,16 +1840,16 @@
     },
     "graphqlCanvas": {
       "title": "GraphQL Canvas",
-      "purpose": "Comment l'API peut-elle être conçue selon les principes GraphQL ?",
-      "howToUse": "Définissez les principaux types, requêtes, mutations et contraintes pour votre API GraphQL.",
+      "purpose": "Comment concevoir l’API selon les principes GraphQL ?",
+      "howToUse": "Définir les types clés, requêtes, mutations et contraintes pour l’API GraphQL.",
       "sections": {
         "apiName": {
-          "section": "Nom de l'API",
-          "description": "Quel est le nom de l'API GraphQL ou du point de terminaison ?"
+          "section": "Nom de l’API",
+          "description": "Quel est le nom de l’API GraphQL ou du point de terminaison ?"
         },
         "consumerGoals": {
-          "section": "Objectifs des consommateurs",
-          "description": "Quels problèmes les consommateurs de l'API cherchent-ils à résoudre ? Quelles données leur sont nécessaires ?"
+          "section": "Objectifs des utilisateurs",
+          "description": "Quels problèmes les utilisateurs de l’API cherchent-ils à résoudre ? Quelles données leur sont nécessaires ?"
         },
         "keyTypes": {
           "section": "Types clés",
@@ -1530,28 +1869,141 @@
         },
         "subscriptions": {
           "section": "Abonnements",
-          "description": "Existe-t-il des mises à jour en temps réel ou des événements auxquels les consommateurs peuvent s'abonner ?"
+          "description": "Existe-t-il des mises à jour en temps réel ou des événements auxquels les utilisateurs peuvent s'abonner ?"
         },
         "authorizationRules": {
           "section": "Règles d'autorisation",
           "description": "Qui peut accéder à quels champs ou types ?"
         },
         "consumerConstraints": {
-          "section": "Contraintes des consommateurs",
+          "section": "Contraintes des utilisateurs",
           "description": "Y a-t-il des contraintes de pagination, de filtrage ou de limitation du débit ?"
         },
         "openQuestions": {
           "section": "Notes / Questions ouvertes",
-          "description": "Y a-t-il des décisions en attente ou des considérations d'intégration ?"
+          "description": "Y a-t-il des décisions en attente ou des considérations d’intégration ?"
+        }
+      }
+    },
+    "capabilityValuePropositionCanvas": {
+      "title": "Capability Value Proposition Canvas",
+      "purpose": "Quelle capacité réutilisable créerait de la valeur pour les utilisateurs sans décider encore si elle doit être mise à disposition sous forme d’API, d’événement, de fichier, de flux, de produit de données ou d’un autre mode de mise en œuvre ?",
+      "howToUse": "Partir des tâches et résultats attendus des utilisateurs. Capturer les fonctionnalités de capacité qui créent des gains et réduisent les irritants, puis décrire les capacités réutilisables candidates sans nommer la technologie trop tôt.",
+      "sections": {
+        "consumerTasks": {
+          "section": "Tâches et résultats des utilisateurs",
+          "description": "Que cherchent à accomplir les utilisateurs, partenaires, systèmes ou équipes ?"
+        },
+        "gainEnablingCapabilities": {
+          "section": "Fonctionnalités de capacité génératrices de gains",
+          "description": "Quelles fonctionnalités de capacité aideraient les utilisateurs à obtenir de meilleurs résultats, plus de rapidité, d’automatisation, d’insights, de portée ou de conformité ?"
+        },
+        "painRelievingCapabilities": {
+          "section": "Fonctionnalités de capacité qui réduisent les irritants",
+          "description": "Quelles fonctionnalités de capacité supprimeraient les frictions, le travail manuel, les erreurs, les retards, les risques ou l’incertitude pour les utilisateurs ?"
+        },
+        "reusableCapabilities": {
+          "section": "Capacités réutilisables",
+          "description": "Quelles capacités métier ou données réutilisables pourraient répondre à ces tâches, gains et irritants pour plusieurs utilisateurs ou cas d’usage ?"
+        }
+      }
+    },
+    "capabilityBusinessModelCanvas": {
+      "title": "Capability Business Model Canvas",
+      "purpose": "Dans quelle mesure cette capacité d’intégration doit-elle être viable, réutilisable, financée, possédée, accompagnée et découvrable ?",
+      "howToUse": "Résumer la proposition de valeur de la capacité, identifier les utilisateurs et canaux d’engagement, puis cartographier propriété, activités, ressources, partenaires, bénéfices et coûts.",
+      "sections": {
+        "keyPartners": {
+          "section": "Partenaires clés",
+          "description": "Quels partenaires métier, technologie, données, sécurité, juridique, plateforme ou externes sont nécessaires pour faire fonctionner la capacité ?"
+        },
+        "keyActivities": {
+          "section": "Activités clés",
+          "description": "Que doivent faire le responsable de la capacité et les producteurs pour concevoir, mettre à disposition, gouverner, accompagner et améliorer la capacité ?"
+        },
+        "keyResources": {
+          "section": "Ressources clés",
+          "description": "Quels systèmes, actifs de données, plateformes, personnes, standards, financements et capacités opérationnelles sont nécessaires ?"
+        },
+        "capabilityValueProposition": {
+          "section": "Proposition de valeur de la capacité",
+          "description": "Quelle valeur cette capacité réutilisable apporte-t-elle aux utilisateurs et à l’organisation ou à l’écosystème ?"
+        },
+        "consumerEngagement": {
+          "section": "Engagement des utilisateurs",
+          "description": "Comment les utilisateurs découvriront-ils, évalueront-ils, demanderont-ils, onboarderont-ils, obtiendront-ils du support et donneront-ils du feedback sur la capacité ?"
+        },
+        "channels": {
+          "section": "Canaux",
+          "description": "Par quels catalogues, portails, marketplaces, sites de documentation, parcours de support ou processus de gouvernance les utilisateurs interagiront-ils avec la capacité ?"
+        },
+        "capabilityConsumerSegments": {
+          "section": "Segments d’utilisateurs de la capacité",
+          "description": "Qui sont les utilisateurs actuels et potentiels de la capacité, y compris équipes, partenaires, systèmes, produits ou utilisateurs de données ?"
+        },
+        "costs": {
+          "section": "Coûts",
+          "description": "Quels sont les coûts significatifs de construction, d’exploitation, de gouvernance, de support et d’évolution de la capacité ?"
+        },
+        "benefits": {
+          "section": "Bénéfices",
+          "description": "Quels bénéfices métier, opérationnels, écosystémiques, de réutilisation, de conformité ou de coût justifient la capacité ?"
+        }
+      }
+    },
+    "consumerExperienceRequirementsCanvas": {
+      "title": "Consumer Experience Requirements Canvas",
+      "purpose": "Quelles exigences d’expérience et non fonctionnelles les utilisateurs doivent-ils préciser avant de décider de la meilleure architecture d’intégration ?",
+      "howToUse": "Utiliser ce canvas comme tableau d’exigences indépendant de la technologie. Capturer les attentes et contraintes des utilisateurs, puis utiliser les implications d’architecture pour choisir API, événements, fichiers, flux, produits de données ou un autre mode de mise en œuvre.",
+      "sections": {
+        "consumerGoals": {
+          "section": "Objectifs des utilisateurs",
+          "description": "Quels sont les objectifs métier, de workflow, de décision, d’automatisation ou d’usage des données des utilisateurs ?"
+        },
+        "availabilityAndTimeliness": {
+          "section": "Disponibilité et fraîcheur",
+          "description": "Quand la capacité doit-elle être disponible, quelle fraîcheur d’information est nécessaire et quelles fenêtres de latence ou de mise à disposition comptent ?"
+        },
+        "volumeAndPerformance": {
+          "section": "Volume et performance",
+          "description": "Quels volumes de requêtes, événements, enregistrements, fichiers, lots, utilisateurs ou transactions la capacité doit-elle supporter aujourd’hui et demain ?"
+        },
+        "dataQualityAndConsistency": {
+          "section": "Qualité et cohérence des données",
+          "description": "Quelles attentes les utilisateurs ont-ils en matière d’exactitude, complétude, cohérence, ordre, déduplication, rapprochement ou validation ?"
+        },
+        "securityPrivacyAndCompliance": {
+          "section": "Sécurité, protection des données et conformité",
+          "description": "Quelles contraintes d’identité, d’autorisation, de confidentialité, de résidence, de consentement, de conservation, d’audit ou de réglementation s’appliquent ?"
+        },
+        "onboardingAndAccess": {
+          "section": "Onboarding et accès",
+          "description": "Comment les utilisateurs doivent-ils trouver, demander, tester, obtenir l’approbation et commencer à utiliser la capacité ?"
+        },
+        "changeAndVersioning": {
+          "section": "Changement et versionnement",
+          "description": "Quelle tolérance au changement les utilisateurs ont-ils, et quelles attentes de préavis, compatibilité, migration ou versionnement s’appliquent ?"
+        },
+        "observabilityAndSupport": {
+          "section": "Observabilité et support",
+          "description": "De quelle surveillance, information de statut, traçabilité, visibilité sur la qualité des données, support, propriété et communication d’incident les utilisateurs ont-ils besoin ?"
+        },
+        "recoveryAndContinuity": {
+          "section": "Reprise et continuité",
+          "description": "Quelles attentes de replay, retry, rapprochement, sauvegarde, fallback, continuité ou reprise manuelle doivent être prises en charge ?"
+        },
+        "architectureImplications": {
+          "section": "Implications d’architecture",
+          "description": "Que signifient ces exigences pour les styles d’architecture possibles, tels que API, événements, fichiers, flux, produits de données ou intégration directe ?"
         }
       }
     }
   },
   "pt": {
     "apiBusinessModelCanvas": {
-      "title": "API Business Model Canvas",
-      "purpose": "Qual será a viabilidade e a reutilização desta API? Temos um caso de negócios do ponto de vista de custo-benefício?",
-      "howToUse": "Resuma a proposta de valor de uma API a partir do API Value Proposition Canvas e siga a sequência numerada.",
+      "title": "Canvas do Modelo de Negócio da API",
+      "purpose": "Qual será a viabilidade e a reutilização desta API? Temos um caso de negócio do ponto de vista de custo-benefício?",
+      "howToUse": "Resuma a proposta de valor de uma API a partir do Canvas da Proposta de Valor da API e siga a sequência numerada.",
       "sections": {
         "keyPartners": {
           "section": "Parceiros-chave",
@@ -1559,31 +2011,31 @@
         },
         "keyActivities": {
           "section": "Atividades-chave",
-          "description": "Quais são as ações mais importantes que o provedor da API deve realizar para operar com sucesso?"
+          "description": "Quais são as ações mais importantes que o fornecedor da API deve realizar para operar com sucesso?"
         },
         "keyResources": {
           "section": "Recursos-chave",
-          "description": "Que ativos estratégicos exclusivos o provedor da API deve adquirir ou construir?"
+          "description": "Que ativos estratégicos exclusivos deve o fornecedor da API adquirir ou construir?"
         },
         "apiValueProposition": {
           "section": "Proposta de valor da API",
-          "description": "Comece com um post-it nomeando a API ou a família de APIs e, em seguida, anote o valor que a API oferece aos seus consumidores."
+          "description": "Comece com uma nota adesiva que nomeie a API ou a família de APIs e, em seguida, anote o valor que a API oferece aos seus utilizadores."
         },
         "developerRelations": {
-          "section": "Relações com desenvolvedores",
-          "description": "Como o provedor da API alcança e oferece suporte aos consumidores da API?"
+          "section": "Relações com programadores",
+          "description": "Como o fornecedor da API alcança e oferece apoio aos utilizadores da API?"
         },
         "channels": {
           "section": "Canais",
-          "description": "Por meio de quais mecanismos os consumidores da API interagem com a API?"
+          "description": "Através de quais mecanismos os utilizadores da API interagem com a API?"
         },
         "apiConsumerSegments": {
-          "section": "Segmentos de consumidores da API",
+          "section": "Segmentos de utilizadores da API",
           "description": "Quem é o público-alvo da API?"
         },
         "costs": {
           "section": "Custos",
-          "description": "Quais são os custos significativos envolvidos na construção, implantação e operação da API?"
+          "description": "Quais são os custos significativos envolvidos na construção, disponibilização e operação da API?"
         },
         "benefits": {
           "section": "Benefícios",
@@ -1592,21 +2044,21 @@
       }
     },
     "apiValuePropositionCanvas": {
-      "title": "API Value Proposition Canvas",
-      "purpose": "Como a jornada do cliente se relaciona com as APIs? Quais dificuldades e benefícios dos usuários finais e consumidores de API precisam ser abordados?",
-      "howToUse": "Descreva a perspectiva dos usuários finais, começando com suas tarefas, depois suas dificuldades e benefícios e os dos consumidores de API e, finalmente, os produtos e recursos da API.",
+      "title": "Canvas da Proposta de Valor da API",
+      "purpose": "Como a percurso do cliente se relaciona com as APIs? Quais dificuldades e benefícios dos utilizadores finais e utilizadores de API precisam /de ser abordados?",
+      "howToUse": "Descreva a perspetiva dos utilizadores finais, começando pelas suas tarefas, depois as suas dificuldades e benefícios e os dos utilizadores de API e, finalmente, os produtos e funcionalidades da API.",
       "sections": {
         "tasks": {
           "section": "Tarefas",
-          "description": "O que os clientes (usuários finais) estão tentando alcançar?"
+          "description": "O que os clientes (utilizadores finais) estão a tentar alcançar?"
         },
         "gainEnablingFeatures": {
           "section": "Recursos que possibilitam ganhos",
-          "description": "Quais recursos permitem que os usuários finais e consumidores de API alcancem ganhos?"
+          "description": "Que funcionalidades permitem que os utilizadores finais e utilizadores de API alcancem ganhos?"
         },
         "painRelievingFeatures": {
           "section": "Recursos que aliviam dificuldades",
-          "description": "Quais recursos ajudam os usuários finais e os consumidores da API a superar dificuldades?"
+          "description": "Que funcionalidades ajudam os utilizadores finais e os utilizadores da API a superar dificuldades?"
         },
         "apiProducts": {
           "section": "Produtos API",
@@ -1615,8 +2067,8 @@
       }
     },
     "businessImpactCanvas": {
-      "title": "Business Impact Canvas",
-      "purpose": "Quais são os possíveis impactos nos negócios da falha da API?",
+      "title": "Canvas de Impacto no Negócio",
+      "purpose": "Quais são os possíveis impactos no negócio da falha da API?",
       "howToUse": "Considere o impacto potencial na disponibilidade, segurança e dados para cada API.",
       "sections": {
         "availabilityRisks": {
@@ -1633,26 +2085,26 @@
         },
         "mitigateAvailabilityRisks": {
           "section": "Mitigar riscos de disponibilidade",
-          "description": "Como o provedor da API pode mitigar os riscos de disponibilidade?"
+          "description": "Como o fornecedor da API pode mitigar os riscos de disponibilidade?"
         },
         "mitigateSecurityRisks": {
           "section": "Mitigar riscos de segurança",
-          "description": "Como o provedor da API pode mitigar os riscos de segurança?"
+          "description": "Como o fornecedor da API pode mitigar os riscos de segurança?"
         },
         "mitigateDataRisks": {
           "section": "Mitigar riscos de dados",
-          "description": "Como o provedor da API pode mitigar os riscos de dados?"
+          "description": "Como o fornecedor da API pode mitigar os riscos de dados?"
         }
       }
     },
     "capacityCanvas": {
-      "title": "Capacity Canvas",
+      "title": "Canvas de Capacidade",
       "purpose": "Quanta capacidade é necessária para suportar o consumo da API?",
       "howToUse": "Analise os requisitos de capacidade atuais e futuros para cada API.",
       "sections": {
         "currentBusinessVolumes": {
-          "section": "Volumes comerciais atuais",
-          "description": "Quais são os volumes comerciais e as taxas de transação atuais?"
+          "section": "Volumes de negócio atuais",
+          "description": "Quais são os volumes de negócio e as taxas de transação atuais?"
         },
         "futureConsumptionTrends": {
           "section": "Tendências de consumo futuro",
@@ -1667,8 +2119,8 @@
           "description": "Quais estratégias de cache podem ser usadas para otimizar o desempenho?"
         },
         "rateLimitingStrategies": {
-          "section": "Estratégias de limitação de taxa",
-          "description": "Que estratégias de limitação de taxa podem ser usadas para gerenciar o consumo?"
+          "section": "Estratégias de limitação de pedidos",
+          "description": "Que estratégias de limitação de pedidos podem ser usadas para gerir o consumo?"
         },
         "scalingStrategies": {
           "section": "Estratégias de dimensionamento",
@@ -1677,9 +2129,9 @@
       }
     },
     "customerJourneyCanvas": {
-      "title": "Customer Journey Canvas",
-      "purpose": "Qual é a jornada do cliente ou parceiro que a API pretende apoiar?",
-      "howToUse": "Descreva uma jornada real de um cliente ou usuário — não o uso da API — para revelar pontos fracos, objetivos e contexto. Essa informação ajuda a definir que tipo de suporte de API será realmente necessário mais tarde.",
+      "title": "Canvas do Percurso do Cliente",
+      "purpose": "Qual é a percurso do cliente ou parceiro que a API pretende apoiar?",
+      "howToUse": "Descreva uma percurso real de um cliente ou utilizador — não o uso da API — para revelar pontos fracos, objetivos e contexto. Esta informação ajuda a definir que tipo de apoio de API será realmente necessário mais tarde.",
       "sections": {
         "customerDiscoversNeed": {
           "section": "O cliente descobre a necessidade",
@@ -1687,15 +2139,15 @@
         },
         "persona": {
           "section": "Persona",
-          "description": "Quem é o cliente típico que passa por essa jornada?"
+          "description": "Quem é o cliente típico que passa por esta percurso?"
         },
         "pains": {
           "section": "Dores",
           "description": "Quais são os pontos fracos ou desafios do cliente?"
         },
         "journeySteps": {
-          "section": "Etapas da jornada",
-          "description": "Quais são as etapas que o cliente percorre em sua jornada?"
+          "section": "Etapas da percurso",
+          "description": "Quais são as etapas que o cliente percorre em sua percurso?"
         },
         "customerNeedIsResolved": {
           "section": "Necessidade do cliente resolvida",
@@ -1716,44 +2168,44 @@
       }
     },
     "domainCanvas": {
-      "title": "Domain Canvas",
-      "purpose": "Quais são as entidades principais e as regras de negócios relacionadas à API?",
+      "title": "Canvas de Domínio",
+      "purpose": "Quais são as entidades principais e as regras de negócio relacionadas com a API?",
       "howToUse": "Defina o modelo de domínio para cada API, incluindo entidades, atributos e relações.",
       "sections": {
         "selectedCustomerJourneySteps": {
-          "section": "Etapas selecionadas da jornada do cliente",
-          "description": "Quais etapas da jornada do cliente são relevantes para este domínio?"
+          "section": "Etapas selecionadas da percurso do cliente",
+          "description": "Quais etapas da percurso do cliente são relevantes para este domínio?"
         },
         "coreEntitiesAndBusinessMeaning": {
-          "section": "Entidades principais e significado comercial",
-          "description": "Quais são as entidades principais e seu significado comercial?"
+          "section": "Entidades principais e significado de negócio",
+          "description": "Quais são as entidades principais e seu significado de negócio?"
         },
         "attributesAndBusinessImportance": {
-          "section": "Atributos e importância comercial",
-          "description": "Quais são os principais atributos de cada entidade e sua importância comercial?"
+          "section": "Atributos e importância de negócio",
+          "description": "Quais são os principais atributos de cada entidade e sua importância de negócio?"
         },
         "relationshipsBetweenEntities": {
           "section": "Relações entre entidades",
           "description": "Quais são as relações entre as entidades?"
         },
         "businessComplianceAndIntegrityRules": {
-          "section": "Regras de negócios, conformidade e integridade",
-          "description": "Quais são as regras de negócios, conformidade e integridade relacionadas às entidades?"
+          "section": "Regras de negócio, conformidade e integridade",
+          "description": "Quais são as regras de negócio, conformidade e integridade relacionadas com as entidades?"
         },
         "securityAndPrivacyConsiderations": {
           "section": "Considerações sobre segurança e privacidade",
-          "description": "Quais são as considerações sobre segurança e privacidade relacionadas às entidades?"
+          "description": "Quais são as considerações sobre segurança e privacidade relacionadas com as entidades?"
         }
       }
     },
     "eventCanvas": {
-      "title": "Event Canvas",
+      "title": "Canvas de Eventos",
       "purpose": "Quais eventos são relevantes para a API e como são processados?",
-      "howToUse": "Defina os eventos, seus gatilhos e a lógica de processamento para cada API.",
+      "howToUse": "Defina os eventos, os seus acionadores e a lógica de processamento para cada API.",
       "sections": {
         "userTaskTrigger": {
-          "section": "Tarefa do usuário/gatilho",
-          "description": "Que ação do usuário ou evento do sistema aciona essa operação de evento?"
+          "section": "Tarefa do utilizador/gatilho",
+          "description": "Que ação do utilizador ou evento do sistema aciona esta operação de evento?"
         },
         "inputEventPayload": {
           "section": "Entrada / Carga útil do evento",
@@ -1761,7 +2213,7 @@
         },
         "processingLogic": {
           "section": "Processamento/Lógica",
-          "description": "Descreva a lógica de processamento de back-end, incluindo validações, transformações ou decisões de roteamento."
+          "description": "Descreva a lógica de processamento de back-end, incluindo validações, transformações ou decisões de encaminhamento."
         },
         "outputEventResult": {
           "section": "Saída/Resultado do evento",
@@ -1770,13 +2222,13 @@
       }
     },
     "interactionCanvas": {
-      "title": "Interaction Canvas",
-      "purpose": "Que tipos de interações esta API deve suportar antes de escolher um projeto específico para o protocolo?",
-      "howToUse": "Identifique quais estilos de interação são realmente necessários para esta API e quais estão fora do escopo. Use esta tela para esclarecer a intenção antes de mapear o resultado para REST, eventos ou GraphQL.",
+      "title": "Canvas de Interação",
+      "purpose": "Que tipos de interações esta API deve suportar antes de escolher uma conceção específica para o protocolo?",
+      "howToUse": "Identifique que estilos de interação são realmente necessários para esta API e quais estão fora do âmbito. Utilize este canvas para esclarecer a intenção antes de mapear o resultado para REST, eventos ou GraphQL.",
       "sections": {
         "crudInteractions": {
           "section": "Interações CRUD",
-          "description": "As interações do tipo CRUD (Criar, Ler, Atualizar, Excluir) são necessárias aqui?"
+          "description": "As interações do tipo CRUD (Criar, Ler, Atualizar, Eliminar) são necessárias aqui?"
         },
         "crudInputOutputModels": {
           "section": "Modelos de entrada e saída CRUD",
@@ -1788,7 +2240,7 @@
         },
         "queryDrivenInteractions": {
           "section": "Interações orientadas por consulta",
-          "description": "Quais interações de leitura ou consulta são necessárias para responder às perguntas dos usuários?"
+          "description": "Quais interações de leitura ou consulta são necessárias para responder às perguntas dos utilizadores?"
         },
         "queryDrivenInputOutputModels": {
           "section": "Modelos de entrada e saída orientados por consulta",
@@ -1812,7 +2264,7 @@
         },
         "eventDrivenInteractions": {
           "section": "Interações orientadas por eventos",
-          "description": "Quais eventos precisam ser publicados ou consumidos, se houver?"
+          "description": "Quais eventos precisam /de ser publicados ou consumidos, se houver?"
         },
         "eventDrivenInputOutputModels": {
           "section": "Modelos de entrada e saída orientados por eventos",
@@ -1825,13 +2277,13 @@
       }
     },
     "locationsCanvas": {
-      "title": "Location Canvas",
-      "purpose": "“Quais limites geopolíticos, regulatórios, de rede e de confiança afetam esta API?",
-      "howToUse": "Identifique onde os consumidores, provedores e sistemas dependentes da API operam em redes internas, redes de parceiros, internet pública e regiões regulamentadas. Descreva as implicações de latência, confiança, conformidade e conectividade entre eles.",
+      "title": "Canvas de Localizações",
+      "purpose": "Que fronteiras geopolíticas, regulamentares, de rede e de confiança afetam esta API?",
+      "howToUse": "Identifique onde os utilizadores, fornecedores e sistemas dependentes da API operam em redes internas, redes de parceiros, internet pública e regiões regulamentadas. Descreva as implicações de latência, confiança, conformidade e conectividade entre eles.",
       "sections": {
         "locationGroups": {
           "section": "Grupos de Localização / Confiança",
-          "description": "Quais são os grupos geopolíticos, regulatórios, de rede ou de confiança relevantes?"
+          "description": "Quais são os grupos geopolíticos, regulamentares, de rede ou de confiança relevantes?"
         },
         "locationGroupCharacteristics": {
           "section": "Características do grupo",
@@ -1839,7 +2291,7 @@
         },
         "locations": {
           "section": "Locais / Zonas Relevantes",
-          "description": "QQuais são os locais, zonas ou ambientes relevantes dentro de cada grupo?"
+          "description": "Quais são os locais, zonas ou ambientes relevantes dentro de cada grupo?"
         },
         "locationCharacteristics": {
           "section": "Características de localização / zona",
@@ -1864,9 +2316,9 @@
       }
     },
     "restCanvas": {
-      "title": "REST Canvas",
-      "purpose": "Como a API pode ser projetada usando os princípios RESTful?",
-      "howToUse": "Defina os recursos, verbos e exemplos de solicitações e respostas da API.",
+      "title": "Canvas REST",
+      "purpose": "Como a API pode ser concebida utilizando os princípios RESTful?",
+      "howToUse": "Defina os recursos, verbos e exemplos de pedidos e respostas da API.",
       "sections": {
         "apiResources": {
           "section": "Recursos da API",
@@ -1882,26 +2334,26 @@
         },
         "apiVerbExample": {
           "section": "Exemplo de verbo da API",
-          "description": "Forneça um exemplo de solicitação e resposta da API para cada verbo."
+          "description": "Forneça um exemplo de pedido e resposta da API para cada verbo."
         }
       }
     },
     "graphqlCanvas": {
-      "title": "GraphQL Canvas",
-      "purpose": "Como a API pode ser projetada usando os princípios do GraphQL?",
-      "howToUse": "Defina os tipos de chave, consultas, mutações e restrições para sua API GraphQL.",
+      "title": "Canvas GraphQL",
+      "purpose": "Como a API pode ser concebida utilizando os princípios do GraphQL?",
+      "howToUse": "Defina os tipos-chave, consultas, mutações e restrições para a sua API GraphQL.",
       "sections": {
         "apiName": {
           "section": "Nome da API",
           "description": "Qual é o nome da API GraphQL ou do endpoint?"
         },
         "consumerGoals": {
-          "section": "Objetivos do consumidor",
-          "description": "Quais problemas os consumidores da API estão tentando resolver? De quais dados eles precisam?"
+          "section": "Objetivos do utilizador",
+          "description": "Que problemas os utilizadores da API estão a tentar resolver? De que dados precisam?"
         },
         "keyTypes": {
           "section": "Tipos de chave",
-          "description": "Quais são os tipos principais expostos (por exemplo, Usuário, Pedido, Produto)?"
+          "description": "Quais são os tipos principais expostos (por exemplo, Utilizador, Pedido, Produto)?"
         },
         "relationships": {
           "section": "Relações",
@@ -1913,25 +2365,138 @@
         },
         "mutations": {
           "section": "Mutações",
-          "description": "Quais operações modificarão os dados (por exemplo, criar, atualizar, excluir)?"
+          "description": "Quais operações modificarão os dados (por exemplo, criar, atualizar, eliminar)?"
         },
         "subscriptions": {
           "section": "Assinaturas",
-          "description": "Existem atualizações em tempo real ou eventos que os consumidores podem assinar?"
+          "description": "Existem atualizações em tempo real ou eventos que os utilizadores podem assinar?"
         },
         "authorizationRules": {
           "section": "Regras de autorização",
-          "description": "Quem pode acessar quais campos ou tipos?"
+          "description": "Quem pode aceder quais campos ou tipos?"
         },
         "consumerConstraints": {
-          "section": "Restrições do consumidor",
-          "description": "Existem restrições de paginação, filtragem ou limitação de taxa?"
+          "section": "Restrições do utilizador",
+          "description": "Existem restrições de paginação, filtragem ou limitação de pedidos?"
         },
         "openQuestions": {
           "section": "Notas/Questões em aberto",
           "description": "Alguma decisão pendente ou considerações sobre integração?"
         }
       }
+    },
+    "capabilityValuePropositionCanvas": {
+      "title": "Canvas da Proposta de Valor da Capacidade",
+      "purpose": "Que capacidade reutilizável criaria valor para os utilizadores sem decidir ainda se deve ser disponibilizada como API, evento, ficheiro, stream, produto de dados ou outro estilo de implementação?",
+      "howToUse": "Comece pelas tarefas e resultados dos utilizadores. Capte funcionalidades da capacidade que permitem ganhos e aliviam dores; depois descreva capacidades reutilizáveis candidatas sem nomear a tecnologia demasiado cedo.",
+      "sections": {
+        "consumerTasks": {
+          "section": "Tarefas e resultados dos utilizadores",
+          "description": "O que os utilizadores, parceiros, utilizadores, sistemas ou equipas estão a tentar alcançar?"
+        },
+        "gainEnablingCapabilities": {
+          "section": "Funcionalidades da capacidade que permitem ganhos",
+          "description": "Que funcionalidades da capacidade ajudariam os utilizadores a alcançar melhores resultados, rapidez, automação, conhecimento, alcance ou conformidade?"
+        },
+        "painRelievingCapabilities": {
+          "section": "Funcionalidades da capacidade que aliviam dores",
+          "description": "Que funcionalidades da capacidade removeriam atrito, trabalho manual, erros, atrasos, risco ou incerteza para os utilizadores?"
+        },
+        "reusableCapabilities": {
+          "section": "Capacidades reutilizáveis",
+          "description": "Que capacidades de negócio ou de dados reutilizáveis poderiam servir estas tarefas, ganhos e dores em mais do que um utilizador ou caso de utilização?"
+        }
+      }
+    },
+    "capabilityBusinessModelCanvas": {
+      "title": "Canvas do Modelo de Negócio da Capacidade",
+      "purpose": "Quão viável, reutilizável, financiada, atribuída, apoiada e detetável deve ser esta capacidade de integração?",
+      "howToUse": "Resuma a proposta de valor da capacidade, identifique utilizadores e canais de envolvimento, e depois mapeie propriedade, atividades, recursos, parceiros, benefícios e custos.",
+      "sections": {
+        "keyPartners": {
+          "section": "Parceiros-chave",
+          "description": "Que parceiros de negócio, tecnologia, dados, segurança, jurídico, plataforma ou externos são necessários para que a capacidade funcione?"
+        },
+        "keyActivities": {
+          "section": "Atividades-chave",
+          "description": "O que o responsável pela capacidade e os produtores devem fazer para conceber, entregar, governar, apoiar e melhorar a capacidade?"
+        },
+        "keyResources": {
+          "section": "Recursos-chave",
+          "description": "Que sistemas, ativos de dados, plataformas, pessoas, normas, financiamento e capacidades operacionais são necessários?"
+        },
+        "capabilityValueProposition": {
+          "section": "Proposta de valor da capacidade",
+          "description": "Que valor esta capacidade reutilizável oferece aos utilizadores e à organização ou ecossistema?"
+        },
+        "consumerEngagement": {
+          "section": "Envolvimento dos utilizadores",
+          "description": "Como irão os utilizadores descobrir, avaliar, solicitar, integrar-se, obter apoio e dar feedback sobre a capacidade?"
+        },
+        "channels": {
+          "section": "Canais",
+          "description": "Através de que catálogos, portais, marketplaces, sites de documentação, caminhos de apoio ou processos de governação os utilizadores irão interagir com a capacidade?"
+        },
+        "capabilityConsumerSegments": {
+          "section": "Segmentos de utilizadores da capacidade",
+          "description": "Quem são os utilizadores atuais e potenciais da capacidade, incluindo equipas, parceiros, sistemas, produtos ou utilizadores de dados?"
+        },
+        "costs": {
+          "section": "Custos",
+          "description": "Quais são os custos significativos de construir, operar, governar, apoiar e evoluir a capacidade?"
+        },
+        "benefits": {
+          "section": "Benefícios",
+          "description": "Que benefícios de negócio, operacionais, de ecossistema, reutilização, conformidade ou custo justificam a capacidade?"
+        }
+      }
+    },
+    "consumerExperienceRequirementsCanvas": {
+      "title": "Canvas de Requisitos da Experiência do Utilizador",
+      "purpose": "Que requisitos de experiência e requisitos não funcionais os utilizadores precisam /de esclarecer antes de decidir a melhor arquitetura de integração?",
+      "howToUse": "Utilize isto como uma tabela de requisitos independente da tecnologia. Capte expectativas e restrições dos utilizadores; depois utilize as implicações de arquitetura para escolher APIs, eventos, ficheiros, streams, produtos de dados ou outro estilo de implementação.",
+      "sections": {
+        "consumerGoals": {
+          "section": "Objetivos dos utilizadores",
+          "description": "Quais são os objetivos de negócio, de fluxo de trabalho, de decisão, de automação ou de utilização de dados dos utilizadores?"
+        },
+        "availabilityAndTimeliness": {
+          "section": "Disponibilidade e atualidade",
+          "description": "Quando é que a capacidade deve estar disponível, quão atualizada deve estar a informação e que latência ou janelas de entrega importam?"
+        },
+        "volumeAndPerformance": {
+          "section": "Volume e desempenho",
+          "description": "Que volumes de pedidos, eventos, registos, ficheiros, lotes, utilizadores ou transações a capacidade deve suportar agora e no futuro?"
+        },
+        "dataQualityAndConsistency": {
+          "section": "Qualidade e consistência dos dados",
+          "description": "Que expectativas de exatidão, completude, consistência, ordenação, deduplicação, reconciliação ou validação têm os utilizadores?"
+        },
+        "securityPrivacyAndCompliance": {
+          "section": "Segurança, privacidade e conformidade",
+          "description": "Que restrições de identidade, autorização, confidencialidade, residência, consentimento, retenção, auditoria ou regulamentação se aplicam?"
+        },
+        "onboardingAndAccess": {
+          "section": "Integração e acesso",
+          "description": "Como devem os utilizadores encontrar, solicitar, testar, obter aprovação e começar a utilizar a capacidade?"
+        },
+        "changeAndVersioning": {
+          "section": "Mudança e controlo de versões",
+          "description": "Que tolerância à mudança têm os utilizadores e que expectativas de aviso prévio, compatibilidade, migração ou controlo de versões se aplicam?"
+        },
+        "observabilityAndSupport": {
+          "section": "Observabilidade e apoio",
+          "description": "Que monitorização, estado, rastreabilidade, visibilidade da qualidade dos dados, apoio, propriedade e comunicação de incidentes os utilizadores precisam?"
+        },
+        "recoveryAndContinuity": {
+          "section": "Recuperação e continuidade",
+          "description": "Que expectativas de repetição, nova tentativa, reconciliação, cópia de segurança, fallback, continuidade ou recuperação manual devem ser suportadas?"
+        },
+        "architectureImplications": {
+          "section": "Implicações de arquitetura",
+          "description": "O que estes requisitos implicam para possíveis estilos de arquitetura, como APIs, eventos, ficheiros, streams, produtos de dados ou integração direta?"
+        }
+      }
     }
   }
 }
diff --git a/src/data/method/criteria.json b/src/data/method/criteria.json
index b3d2820..8ae8826 100644
--- a/src/data/method/criteria.json
+++ b/src/data/method/criteria.json
@@ -55,6 +55,10 @@
     "id": "api-contract-tested",
     "description": "The API contract is tested and meets functional and non-functional requirements."
   },
+  {
+    "id": "automation-workflow-validated",
+    "description": "The workflow, rules, integrations, and relevant interface contracts have been validated and tested."
+  },
   {
     "id": "api-description-available",
     "description": "The API and its exposed capabilities are described clearly enough for review, audit, and onboarding."
diff --git a/src/data/method/cycles.json b/src/data/method/cycles.json
new file mode 100644
index 0000000..b30a973
--- /dev/null
+++ b/src/data/method/cycles.json
@@ -0,0 +1,367 @@
+{
+  "cycles": {
+    "title": "cycles.title",
+    "slug": "cycles",
+    "order": 0,
+    "description": "cycles.description",
+    "items": [
+      {
+        "id": "capability-productization-cycle",
+        "title": "cycle.capability-productization-cycle.title",
+        "slug": "capability-productization-cycle",
+        "description": "cycle.capability-productization-cycle.description",
+        "purpose": "cycle.capability-productization-cycle.purpose",
+        "stations": [
+          "api-product-strategy",
+          "api-consumer-experience",
+          "api-platform-architecture",
+          "api-design",
+          "api-delivery",
+          "api-audit",
+          "api-publishing",
+          "monitoring-and-improving"
+        ],
+        "stationLabels": {
+          "api-product-strategy": "cycle.station.capability-strategy",
+          "api-consumer-experience": "cycle.station.consumer-requirements-onboarding",
+          "api-platform-architecture": "cycle.station.architecture-platform-decisions",
+          "api-design": "cycle.station.solution-interface-design",
+          "api-delivery": "cycle.station.delivery-operations",
+          "api-audit": "cycle.station.quality-readiness-assurance",
+          "api-publishing": "cycle.station.publishing-enablement",
+          "monitoring-and-improving": "cycle.station.monitoring-improvement"
+        },
+        "stationDescriptions": {
+          "api-product-strategy": "cycle.capability-productization-cycle.station.api-product-strategy.description",
+          "api-consumer-experience": "cycle.capability-productization-cycle.station.api-consumer-experience.description",
+          "api-platform-architecture": "cycle.capability-productization-cycle.station.api-platform-architecture.description",
+          "api-design": "cycle.capability-productization-cycle.station.api-design.description",
+          "api-delivery": "cycle.capability-productization-cycle.station.api-delivery.description",
+          "api-audit": "cycle.capability-productization-cycle.station.api-audit.description",
+          "api-publishing": "cycle.capability-productization-cycle.station.api-publishing.description",
+          "monitoring-and-improving": "cycle.capability-productization-cycle.station.monitoring-and-improving.description"
+        },
+        "recommendedResources": {
+          "api-product-strategy": [
+            "customerJourneyCanvas",
+            "domainCanvas",
+            "capabilityValuePropositionCanvas",
+            "capabilityBusinessModelCanvas"
+          ],
+          "api-consumer-experience": [
+            "consumerExperienceRequirementsCanvas",
+            "api-onboarding-best-practices"
+          ],
+          "api-platform-architecture": [
+            "businessImpactCanvas",
+            "locationsCanvas",
+            "capacityCanvas"
+          ],
+          "api-design": [
+            "domainCanvas",
+            "interactionCanvas",
+            "contract-first-design"
+          ],
+          "api-delivery": [
+            "api-development-best-practices",
+            "api-testing-best-practices",
+            "apiops-CI-CD-for-apis"
+          ],
+          "api-audit": [
+            "api-audit-checklist",
+            "api-compliance-best-practices"
+          ],
+          "api-publishing": [
+            "api-onboarding-best-practices",
+            "service-agreement-template"
+          ],
+          "monitoring-and-improving": [
+            "api-metrics-and-analytics",
+            "api-community-engagement-strategies"
+          ]
+        },
+        "entryCriteria": [
+          "business-goals-defined",
+          "stakeholder-approval"
+        ],
+        "exitCriteria": [
+          "value-prop-validated",
+          "architecture-patterns-validated",
+          "audit-passed"
+        ]
+      },
+      {
+        "id": "api-productization-cycle",
+        "title": "cycle.api-productization-cycle.title",
+        "slug": "api-productization-cycle",
+        "description": "cycle.api-productization-cycle.description",
+        "purpose": "cycle.api-productization-cycle.purpose",
+        "stations": [
+          "api-product-strategy",
+          "api-consumer-experience",
+          "api-platform-architecture",
+          "api-design",
+          "api-delivery",
+          "api-audit",
+          "api-publishing",
+          "monitoring-and-improving"
+        ],
+        "stationLabels": {
+          "api-product-strategy": "cycle.station.api-product-strategy",
+          "api-consumer-experience": "cycle.station.api-consumer-experience",
+          "api-platform-architecture": "cycle.station.api-platform-architecture",
+          "api-design": "cycle.station.api-design",
+          "api-delivery": "cycle.station.api-delivery",
+          "api-audit": "cycle.station.api-audit",
+          "api-publishing": "cycle.station.api-publishing",
+          "monitoring-and-improving": "cycle.station.monitoring-and-improving"
+        },
+        "recommendedResources": {
+          "api-product-strategy": [
+            "customerJourneyCanvas",
+            "domainCanvas",
+            "apiValuePropositionCanvas",
+            "apiBusinessModelCanvas"
+          ],
+          "api-consumer-experience": [
+            "apiValuePropositionCanvas",
+            "customerJourneyCanvas",
+            "api-onboarding-best-practices"
+          ],
+          "api-platform-architecture": [
+            "businessImpactCanvas",
+            "locationsCanvas",
+            "capacityCanvas",
+            "api-metrics-and-analytics"
+          ],
+          "api-design": [
+            "domainCanvas",
+            "interactionCanvas",
+            "restCanvas",
+            "eventCanvas",
+            "graphqlCanvas",
+            "api-design-principles",
+            "contract-first-design"
+          ],
+          "api-delivery": [
+            "api-development-best-practices",
+            "api-testing-best-practices",
+            "apiops-CI-CD-for-apis",
+            "api-security-best-practices"
+          ],
+          "api-audit": [
+            "api-audit-checklist",
+            "api-compliance-best-practices"
+          ],
+          "api-publishing": [
+            "apiops-CI-CD-for-apis",
+            "api-onboarding-best-practices",
+            "api-audit-checklist"
+          ],
+          "monitoring-and-improving": [
+            "api-metrics-and-analytics",
+            "api-community-engagement-strategies"
+          ]
+        },
+        "entryCriteria": [
+          "api-opportunity-documented",
+          "consumer-segments-identified"
+        ],
+        "exitCriteria": [
+          "api-contract-tested",
+          "api-ready-for-publishing",
+          "api-documentation-ready"
+        ],
+        "stationDescriptions": {
+          "api-product-strategy": "cycle.api-productization-cycle.station.api-product-strategy.description",
+          "api-consumer-experience": "cycle.api-productization-cycle.station.api-consumer-experience.description",
+          "api-platform-architecture": "cycle.api-productization-cycle.station.api-platform-architecture.description",
+          "api-design": "cycle.api-productization-cycle.station.api-design.description",
+          "api-delivery": "cycle.api-productization-cycle.station.api-delivery.description",
+          "api-audit": "cycle.api-productization-cycle.station.api-audit.description",
+          "api-publishing": "cycle.api-productization-cycle.station.api-publishing.description",
+          "monitoring-and-improving": "cycle.api-productization-cycle.station.monitoring-and-improving.description"
+        }
+      },
+      {
+        "id": "integration-productization-cycle",
+        "title": "cycle.integration-productization-cycle.title",
+        "slug": "integration-productization-cycle",
+        "description": "cycle.integration-productization-cycle.description",
+        "purpose": "cycle.integration-productization-cycle.purpose",
+        "stations": [
+          "api-product-strategy",
+          "api-consumer-experience",
+          "api-platform-architecture",
+          "api-design",
+          "api-delivery",
+          "api-audit",
+          "api-publishing",
+          "monitoring-and-improving"
+        ],
+        "stationLabels": {
+          "api-product-strategy": "cycle.station.integration-capability-strategy",
+          "api-consumer-experience": "cycle.station.integration-consumer-requirements-onboarding",
+          "api-platform-architecture": "cycle.station.integration-architecture-decision",
+          "api-design": "cycle.station.integration-solution-design",
+          "api-delivery": "cycle.station.integration-delivery-operations",
+          "api-audit": "cycle.station.integration-readiness-assurance",
+          "api-publishing": "cycle.station.capability-publishing",
+          "monitoring-and-improving": "cycle.station.integration-monitoring-improvement"
+        },
+        "recommendedResources": {
+          "api-product-strategy": [
+            "customerJourneyCanvas",
+            "domainCanvas",
+            "capabilityValuePropositionCanvas",
+            "capabilityBusinessModelCanvas"
+          ],
+          "api-consumer-experience": [
+            "consumerExperienceRequirementsCanvas",
+            "api-onboarding-best-practices"
+          ],
+          "api-platform-architecture": [
+            "businessImpactCanvas",
+            "locationsCanvas",
+            "capacityCanvas",
+            "partner-integration-guidelines"
+          ],
+          "api-design": [
+            "domainCanvas",
+            "interactionCanvas",
+            "integration-style-selection-guide",
+            "restCanvas",
+            "eventCanvas",
+            "graphqlCanvas",
+            "contract-first-design"
+          ],
+          "api-delivery": [
+            "api-development-best-practices",
+            "api-testing-best-practices",
+            "apiops-CI-CD-for-apis",
+            "api-security-best-practices",
+            "partner-integration-guidelines"
+          ],
+          "api-audit": [
+            "api-audit-checklist",
+            "api-compliance-best-practices"
+          ],
+          "api-publishing": [
+            "api-onboarding-best-practices",
+            "service-agreement-template"
+          ],
+          "monitoring-and-improving": [
+            "api-metrics-and-analytics",
+            "api-community-engagement-strategies"
+          ]
+        },
+        "entryCriteria": [
+          "business-goals-defined",
+          "api-opportunity-documented"
+        ],
+        "exitCriteria": [
+          "architecture-patterns-validated",
+          "api-description-available",
+          "audit-passed"
+        ],
+        "stationDescriptions": {
+          "api-product-strategy": "cycle.integration-productization-cycle.station.api-product-strategy.description",
+          "api-consumer-experience": "cycle.integration-productization-cycle.station.api-consumer-experience.description",
+          "api-platform-architecture": "cycle.integration-productization-cycle.station.api-platform-architecture.description",
+          "api-design": "cycle.integration-productization-cycle.station.api-design.description",
+          "api-delivery": "cycle.integration-productization-cycle.station.api-delivery.description",
+          "api-audit": "cycle.integration-productization-cycle.station.api-audit.description",
+          "api-publishing": "cycle.integration-productization-cycle.station.api-publishing.description",
+          "monitoring-and-improving": "cycle.integration-productization-cycle.station.monitoring-and-improving.description"
+        }
+      },
+      {
+        "id": "automation-cycle",
+        "title": "cycle.automation-cycle.title",
+        "slug": "automation-cycle",
+        "description": "cycle.automation-cycle.description",
+        "purpose": "cycle.automation-cycle.purpose",
+        "stations": [
+          "api-product-strategy",
+          "api-consumer-experience",
+          "api-platform-architecture",
+          "api-design",
+          "api-delivery",
+          "api-audit",
+          "api-publishing",
+          "monitoring-and-improving"
+        ],
+        "stationLabels": {
+          "api-product-strategy": "cycle.station.automation-opportunity-strategy",
+          "api-consumer-experience": "cycle.station.process-user-requirements",
+          "api-platform-architecture": "cycle.station.automation-platform-decision",
+          "api-design": "cycle.station.automation-workflow-design",
+          "api-delivery": "cycle.station.automation-delivery",
+          "api-audit": "cycle.station.automation-readiness-review",
+          "api-publishing": "cycle.station.automation-enablement",
+          "monitoring-and-improving": "cycle.station.automation-monitoring-improvement"
+        },
+        "recommendedResources": {
+          "api-product-strategy": [
+            "customerJourneyCanvas",
+            "domainCanvas",
+            "capabilityValuePropositionCanvas"
+          ],
+          "api-consumer-experience": [
+            "consumerExperienceRequirementsCanvas"
+          ],
+          "api-platform-architecture": [
+            "businessImpactCanvas",
+            "locationsCanvas",
+            "capacityCanvas",
+            "automation-operational-ownership-guide"
+          ],
+          "api-design": [
+            "domainCanvas",
+            "interactionCanvas",
+            "process-workflow-design-guide",
+            "decision-business-rules-guide",
+            "automation-trigger-handoff-exception-guide"
+          ],
+          "api-delivery": [
+            "automation-testing-guide",
+            "automation-operational-ownership-guide",
+            "automation-rollback-supervision-guide"
+          ],
+          "api-audit": [
+            "automation-readiness-checklist",
+            "api-compliance-best-practices"
+          ],
+          "api-publishing": [
+            "automation-rollout-enablement-guide",
+            "service-agreement-template"
+          ],
+          "monitoring-and-improving": [
+            "automation-operational-ownership-guide",
+            "api-metrics-and-analytics"
+          ]
+        },
+        "overlays": [],
+        "entryCriteria": [
+          "business-goals-defined",
+          "stakeholder-approval"
+        ],
+        "exitCriteria": [
+          "design-reflects-business-value",
+          "automation-workflow-validated",
+          "audit-passed"
+        ],
+        "stationDescriptions": {
+          "api-product-strategy": "cycle.automation-cycle.station.api-product-strategy.description",
+          "api-consumer-experience": "cycle.automation-cycle.station.api-consumer-experience.description",
+          "api-platform-architecture": "cycle.automation-cycle.station.api-platform-architecture.description",
+          "api-design": "cycle.automation-cycle.station.api-design.description",
+          "api-delivery": "cycle.automation-cycle.station.api-delivery.description",
+          "api-audit": "cycle.automation-cycle.station.api-audit.description",
+          "api-publishing": "cycle.automation-cycle.station.api-publishing.description",
+          "monitoring-and-improving": "cycle.automation-cycle.station.monitoring-and-improving.description"
+        }
+      }
+    ]
+  }
+}
diff --git a/src/data/method/de/labels.criteria.json b/src/data/method/de/labels.criteria.json
index 4657d51..52311bb 100644
--- a/src/data/method/de/labels.criteria.json
+++ b/src/data/method/de/labels.criteria.json
@@ -1,25 +1,26 @@
 {
   "exit_criteria": "Austrittskriterien",
-  "entry_criteria": "Eintrittskriterien",
-  "criterion.metrics-feedback-available": "Relevante Marktsignale, Feedback oder operative Erkenntnisse sind verfügbar, um diese API-Möglichkeit zu steuern.",
-  "criterion.business-goals-defined": "Geschäftsziele sind definiert",
-  "criterion.market-research-done": "Marktforschung identifiziert API-Möglichkeiten",
-  "criterion.stakeholder-approval": "Relevante Stakeholder stimmen zu, dass diese API-Möglichkeit es wert ist, sie zu erkunden und Priorität einzuräumen.",
-  "criterion.api-opportunity-documented": "Individuelle API-Möglichkeiten werden identifiziert und dokumentiert",
-  "criterion.api-reusability": "Die API erfüllt einen klaren Geschäftsbedarf und ist für mehrere API-Nutzer wiederverwendbar",
-  "criterion.hide-backend-discrepancies": "Die API ist dazu gedacht, Verbraucher vor Backend-Komplexität und Inkonsistenzen zu schützen.",
-  "criterion.value-prop-validated": "Die API-Wert proposition wurde mit den relevanten Geschäft und Verbraucher-Stakeholdern überprüft und validiert.",
-  "criterion.consumer-segments-identified": "API-Nutzersegmente (intern und extern) werden identifiziert.",
-  "criterion.api-roadmap-defined": "Hochrangige Roadmaps für die API-Entwicklung werden erstellt.",
-  "criterion.architecture-patterns-validated": "Die gewählten API-Architektur- und Plattformmuster wurden mit den relevanten Architektur-, Sicherheits- und Plattform-Stakeholdern validiert.",
-  "criterion.design-reflects-business-value": "Die API-Design und die offengelegten Funktionen spiegeln klar den Geschäftswert und die Bedürfnisse der Benutzer wider.",
-  "criterion.api-consistency": "Das API-Design folgt unseren gemeinsamen API-Produkt- und Design-Vorgaben.",
-  "criterion.api-contract-tested": "Der API-Vertrag wurde getestet und erfüllt die funktionalen und nicht-funktionalen Anforderungen.",
-  "criterion.api-description-available": "Die API und ihre offengelegten Funktionen sind ausreichend beschrieben für Überprüfung, Auditierung und Onboarding.",
-  "criterion.audit-passed": "Die API besteht Compliance-, Sicherheits- und Audit-Prüfungen.",
-  "criterion.audit-reports-shared": "API-Auditberichte wurden mit relevanten Stakeholdern geteilt.",
-  "criterion.api-ready-for-publishing": "Die API ist bereit, für Verbraucher verfügbar gemacht zu werden.",
-  "criterion.api-documentation-ready": "Die API-Dokumentation ist vollständig und für die Veröffentlichung und das Onboarding geeignet.",
-  "criterion.consumer-support-ready": "Registrierungs-, Support- und Kommunikationsprozesse sind für API-Nutzer bereit.",
-  "criterion.legal-compliance-clear": "Rechtliche, datenschutzrechtliche und Compliance-Anforderungen für die Veröffentlichung sind definiert und verstanden."
-}
\ No newline at end of file
+  "entry_criteria": "Einstiegskriterien",
+  "criterion.metrics-feedback-available": "Relevante Marktsignale, Feedback oder operative Erkenntnisse liegen vor, um diese Capability-Möglichkeit zu bewerten.",
+  "criterion.business-goals-defined": "Die Geschäftsziele sind definiert.",
+  "criterion.market-research-done": "Die Marktrecherche identifiziert relevante Capability-Möglichkeiten.",
+  "criterion.stakeholder-approval": "Die relevanten Stakeholder stimmen zu, dass diese Capability-Möglichkeit weiter untersucht und priorisiert werden sollte.",
+  "criterion.api-opportunity-documented": "Die Capability-Möglichkeit wurde identifiziert und dokumentiert.",
+  "criterion.api-reusability": "Die Capability erfüllt einen klaren Geschäftsbedarf und kann von den vorgesehenen Nutzern wiederverwendet werden.",
+  "criterion.hide-backend-discrepancies": "Die gewählte Schnittstelle bietet Nutzern eine angemessene Abstraktion.",
+  "criterion.value-prop-validated": "Das Wertversprechen der Capability wurde mit Geschäfts- und Nutzer-Stakeholdern validiert.",
+  "criterion.consumer-segments-identified": "Die Nutzersegmente sind identifiziert.",
+  "criterion.api-roadmap-defined": "Eine übergeordnete Roadmap für die Umsetzung ist definiert.",
+  "criterion.architecture-patterns-validated": "Die gewählte Architektur, Plattform und der Implementierungsstil wurden mit den relevanten Architektur-, Sicherheits- und Plattform-Stakeholdern validiert.",
+  "criterion.design-reflects-business-value": "Das Schnittstellendesign und die offengelegten Capabilities lassen sich klar auf Geschäftswert und Nutzerbedürfnisse zurückführen.",
+  "criterion.api-consistency": "Das Schnittstellendesign folgt den vereinbarten Designstandards und Konventionen.",
+  "criterion.api-contract-tested": "Der Schnittstellenvertrag wurde validiert und gegen funktionale und nicht-funktionale Anforderungen getestet.",
+  "criterion.automation-workflow-validated": "Workflow, Regeln, Integrationen und relevante Schnittstellenverträge wurden validiert und getestet.",
+  "criterion.api-description-available": "Die Schnittstelle und ihre Capabilities sind ausreichend klar für Review, Auditierung und Onboarding dokumentiert.",
+  "criterion.audit-passed": "Die Lösung besteht Qualitäts-, Sicherheits-, Compliance- und Bereitschaftsprüfungen.",
+  "criterion.audit-reports-shared": "Audit-Ergebnisse und Maßnahmenentscheidungen wurden mit den relevanten Stakeholdern geteilt.",
+  "criterion.api-ready-for-publishing": "Die Capability ist bereit, über den gewählten Bereitstellungsmechanismus veröffentlicht oder ausgeliefert zu werden.",
+  "criterion.api-documentation-ready": "Nutzerorientierte Dokumentation und Onboarding-Materialien sind bereit.",
+  "criterion.consumer-support-ready": "Onboarding-, Support- und Kommunikationsprozesse für Nutzer sind bereit.",
+  "criterion.legal-compliance-clear": "Rechtliche, Datenschutz- und Compliance-Anforderungen für Veröffentlichung oder Release sind definiert und verstanden."
+}
diff --git a/src/data/method/de/labels.cycles.json b/src/data/method/de/labels.cycles.json
new file mode 100644
index 0000000..983a00e
--- /dev/null
+++ b/src/data/method/de/labels.cycles.json
@@ -0,0 +1,93 @@
+{
+  "cycles.title": "Zyklusansichten",
+  "cycles.description": "Zielgruppenspezifische Ansichten auf den APIOps-Cycles-Methoden.",
+  "cycle.capability-productization-cycle.title": "Capability-Produktisierungszyklus",
+  "cycle.capability-productization-cycle.description": "Ein Zyklus, um Geschäftsfähigkeiten in wiederverwendbare digitale Capabilities zu überführen, bevor die Umsetzungsweise gewählt wird.",
+  "cycle.capability-productization-cycle.purpose": "Identifizieren und produktisieren Sie wiederverwendbare digitale Capabilities, bevor Sie einen API-, Event-, Datei-, Stream-, Datenprodukt-, KI-Service-, direkte Integrations- oder hybriden Implementierungsstil waehlen.",
+  "cycle.api-productization-cycle.title": "API-Produktisierungszyklus",
+  "cycle.api-productization-cycle.description": "Die API-fokussierte APIOps-Cycles-Journey für Produktisierung, Design, Bereitstellung, Veröffentlichung und Verbesserung von APIs.",
+  "cycle.api-productization-cycle.purpose": "API-fokussierte Method Journey für Teams, die bereits wissen, dass die vorgesehene Umsetzungsweise ein API-Produkt ist.",
+  "cycle.integration-productization-cycle.title": "Integrationszyklus",
+  "cycle.integration-productization-cycle.description": "Ein Zyklus zur Produktisierung wiederverwendbarer Integrations-Capabilities, bevor der Implementierungsstil gewaehlt wird.",
+  "cycle.integration-productization-cycle.purpose": "Unterstuetzt das Design wiederverwendbarer Integrations-Capabilities, bevor ein API-, Event-, Datei-, Stream-, Datenprodukt-, direkte Integrations- oder hybrider Implementierungsstil gewaehlt wird.",
+  "cycle.station.capability-strategy": "Capability-Strategie",
+  "cycle.station.consumer-requirements-onboarding": "Nutzeranforderungen & Onboarding",
+  "cycle.station.architecture-platform-decisions": "Architektur & Plattformentscheidungen",
+  "cycle.station.solution-interface-design": "Lösungs- & Schnittstellendesign",
+  "cycle.station.delivery-operations": "Bereitstellung & Betrieb",
+  "cycle.station.quality-readiness-assurance": "Qualitäts- & Bereitschaftssicherung",
+  "cycle.station.publishing-enablement": "Veroeffentlichung & Enablement",
+  "cycle.station.monitoring-improvement": "Monitoring & Verbesserung",
+  "cycle.station.api-product-strategy": "API-Produktstrategie",
+  "cycle.station.api-consumer-experience": "API Consumer Experience",
+  "cycle.station.api-platform-architecture": "API-Plattformarchitektur",
+  "cycle.station.api-design": "API-Design",
+  "cycle.station.api-delivery": "API-Bereitstellung",
+  "cycle.station.api-audit": "API-Audit",
+  "cycle.station.api-publishing": "API-Veröffentlichung",
+  "cycle.station.monitoring-and-improving": "API-Monitoring & Verbesserung",
+  "cycle.station.integration-capability-strategy": "Integrations-Capability-Strategie",
+  "cycle.station.integration-consumer-requirements-onboarding": "Integrationsnutzeranforderungen & Onboarding",
+  "cycle.station.integration-architecture-decision": "Integrationsarchitektur & Plattformentscheidungen",
+  "cycle.station.integration-solution-design": "Integrationsdesign",
+  "cycle.station.integration-delivery-operations": "Integrationsbereitstellung & Betrieb",
+  "cycle.station.integration-readiness-assurance": "Integrationsbereitschaftssicherung",
+  "cycle.station.capability-publishing": "Integrationsveroeffentlichung & Enablement",
+  "cycle.station.integration-monitoring-improvement": "Integrationsmonitoring & Verbesserung",
+  "cycle.capability-productization-cycle.station.api-product-strategy.description": "Rahmen Sie den Geschaeftsbedarf als wiederverwendbare Capability mit klarem Wert, Nutzern, Ownership und Geschaeftszielen, bevor der Implementierungsstil gewaehlt wird.",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.description": "Erfassen Sie Nutzeranforderungen, Onboarding-Bedarf, Einschränkungen, Serviceerwartungen und Verantwortlichkeiten der Anbieter.",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.description": "Nutzen Sie Anforderungen und Einschraenkungen, um Implementierungsstil, Architekturpattern und ermoeglichende Plattformfaehigkeiten auszuwaehlen.",
+  "cycle.capability-productization-cycle.station.api-design.description": "Entwerfen Sie den Schnittstellenvertrag und das Interaktionsmodell für die gewählte Umsetzungsweise.",
+  "cycle.capability-productization-cycle.station.api-delivery.description": "Bauen, testen, veröffentlichen und betreiben Sie die Capability mit der gewählten Umsetzungsweise und dem validierten Schnittstellenvertrag.",
+  "cycle.capability-productization-cycle.station.api-audit.description": "Validieren Sie Schnittstellenvertrag, Kontrollen, Dokumentation, Supportmodell und operative Bereitschaft vor der Veroeffentlichung.",
+  "cycle.capability-productization-cycle.station.api-publishing.description": "Veroeffentlichen Sie die Capability, damit Nutzer sie finden, bewerten, Zugriff beantragen, das Onboarding abschliessen, sie nutzen und Support erhalten koennen.",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.description": "Überwachen Sie Capability-Gesundheit, Nutzerergebnisse, Zuverlässigkeit, Wiederverwendung und Verbesserungsmöglichkeiten.",
+  "cycle.owner.business-owner": "Business Owner",
+  "cycle.owner.domain-expert": "Domänenexperte",
+  "cycle.owner.capability-owner": "Capability Owner",
+  "cycle.owner.consumer-representative": "Nutzervertreter",
+  "cycle.owner.enterprise-architect": "Enterprise Architect",
+  "cycle.owner.platform-owner": "Platform Owner",
+  "cycle.owner.api-product-owner": "API Product Owner",
+  "cycle.owner.api-platform-owner": "API Platform Owner",
+  "cycle.owner.integration-architect": "Integration Architect",
+  "cycle.owner.solution-architect": "Solution Architect",
+  "cycle.api-productization-cycle.station.api-product-strategy.description": "Rahmen Sie die API als Produkt mit klarem Wertversprechen, Nutzern, Geschäftsmodell, Ownership und Lifecycle-Intention.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.description": "Definieren Sie API-Nutzersegmente, Onboarding-Pfade, Erwartungen und Experience-Anforderungen, bevor Designentscheidungen festgelegt werden.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.description": "Wählen und validieren Sie API-Plattform, Architektur, Governance und betriebliche Einschränkungen, die für das Produkt benötigt werden.",
+  "cycle.api-productization-cycle.station.api-design.description": "Entwerfen Sie API-Schnittstellenvertrag, Interaktionsmodell, Schemas, Policies und Usability-Details vor der Implementierung.",
+  "cycle.api-productization-cycle.station.api-delivery.description": "Implementieren, testen, sichern, automatisieren und betreiben Sie das API-Produkt über die Bereitstellungspipeline.",
+  "cycle.api-productization-cycle.station.api-audit.description": "Validieren Sie API-Qualitaet, Compliance, Nachweise, operative Bereitschaft und Freigabekriterien.",
+  "cycle.api-productization-cycle.station.api-publishing.description": "Veroeffentlichen Sie das API-Produkt, damit Nutzer es finden, bewerten, Zugriff beantragen, das Onboarding abschliessen, es nutzen und Support erhalten koennen.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.description": "Überwachen Sie API-Gesundheit, Adoption, Nutzerergebnisse, Zuverlässigkeit und Verbesserungsmöglichkeiten nach der Veröffentlichung.",
+  "cycle.integration-productization-cycle.station.api-product-strategy.description": "Rahmen Sie die wiederverwendbare Integrations-Capability, den Geschaeftsbedarf, Ownership und erwartete Wiederverwendung, bevor der Implementierungsstil gewaehlt wird.",
+  "cycle.integration-productization-cycle.station.api-consumer-experience.description": "Erfassen Sie Integrationsnutzer, Anbieter-Verantwortlichkeiten, Onboarding-Bedarf, Serviceerwartungen und operative Einschränkungen.",
+  "cycle.integration-productization-cycle.station.api-platform-architecture.description": "Waehlen Sie Integrationsarchitektur, Implementierungsstil und Plattformfaehigkeiten unter Beruecksichtigung von Einschraenkungen und Governance-Modell.",
+  "cycle.integration-productization-cycle.station.api-design.description": "Entwerfen Sie Schnittstellenvertrag, Schemas, Payloads und Interaktionsmuster fuer den gewaehlten Integrationsstil.",
+  "cycle.integration-productization-cycle.station.api-delivery.description": "Bauen, testen, automatisieren, deployen und betreiben Sie die Integrations-Capability mit dem gewaehlten Implementierungsstil und dem validierten Schnittstellenvertrag.",
+  "cycle.integration-productization-cycle.station.api-audit.description": "Sichern Sie Integrationsbereitschaft, Governance, Qualität, Sicherheit, Compliance und operative Nachweise vor der Veröffentlichung ab.",
+  "cycle.integration-productization-cycle.station.api-publishing.description": "Veroeffentlichen Sie die Integrations-Capability, damit Teams sie finden, bewerten, Zugriff beantragen, das Onboarding abschliessen, wiederverwenden und Support erhalten koennen.",
+  "cycle.integration-productization-cycle.station.monitoring-and-improving.description": "Überwachen Sie Integrationszuverlässigkeit, Wiederverwendung, Incidents, Performance, Nutzerergebnisse und Verbesserungsbedarf.",
+  "cycle.automation-cycle.title": "Automatisierungszyklus",
+  "cycle.automation-cycle.description": "Ein Zyklus zum Identifizieren, Entwerfen, Bereitstellen, Enablement und Verbessern von Automatisierungsmöglichkeiten.",
+  "cycle.automation-cycle.purpose": "Produktisieren Sie Automatisierungsmöglichkeiten zu gesteuerten Workflows mit klaren Nutzern, Plattformen, Kontrollen, Bereitstellungspfaden, Enablement und Monitoring.",
+  "cycle.audience.automation-owners": "Automation Owner",
+  "cycle.audience.process-owners": "Prozessverantwortliche",
+  "cycle.audience.automation-teams": "Automatisierungsteams",
+  "cycle.station.automation-opportunity-strategy": "Automatisierungschance & Strategie",
+  "cycle.station.process-user-requirements": "Prozess-/Nutzeranforderungen",
+  "cycle.station.automation-platform-decision": "Automatisierungsplattformentscheidung",
+  "cycle.station.automation-workflow-design": "Automatisierungs-Workflow-Design",
+  "cycle.station.automation-delivery": "Automatisierungsbereitstellung & Betrieb",
+  "cycle.station.automation-readiness-review": "Automatisierungsbereitschaftsprüfung",
+  "cycle.station.automation-enablement": "Automatisierungs-Rollout & Enablement",
+  "cycle.station.automation-monitoring-improvement": "Automatisierungsmonitoring & Verbesserung",
+  "cycle.automation-cycle.station.api-product-strategy.description": "Identifizieren und priorisieren Sie Automatisierungsmöglichkeiten nach Wert, Machbarkeit, Risiko, Ownership und erwarteter Prozesswirkung.",
+  "cycle.automation-cycle.station.api-consumer-experience.description": "Erfassen Sie Prozessnutzer, Rollen, Übergaben, Ausnahmen, Einschränkungen und Serviceerwartungen, bevor die Automatisierung entworfen wird.",
+  "cycle.automation-cycle.station.api-platform-architecture.description": "Waehlen Sie Automatisierungsplattform, Runtime, Integrationsansatz, Governance-Kontrollen und operative Einschraenkungen.",
+  "cycle.automation-cycle.station.api-design.description": "Entwerfen Sie Automatisierungsworkflow, Trigger, Entscheidungspunkte, Integrationen, Datenverarbeitung, relevante Schnittstellenvertraege und Ausnahmefaelle.",
+  "cycle.automation-cycle.station.api-delivery.description": "Bauen, testen, deployen, dokumentieren und betreiben Sie die Automatisierung mit klarer Ownership, Kontrollen und Rollback-Pfaden.",
+  "cycle.automation-cycle.station.api-audit.description": "Prüfen Sie Automatisierungsbereitschaft, Qualität, Risiko, Compliance, menschliche Aufsicht, Nachweise und Freigabekriterien.",
+  "cycle.automation-cycle.station.api-publishing.description": "Befähigen Sie Nutzer und Betreiber mit Auffindbarkeit, Onboarding, Betriebsanweisungen, Supportpfaden und Änderungs kommunikation.",
+  "cycle.automation-cycle.station.monitoring-and-improving.description": "Überwachen Sie Automatisierungsleistung, Ausnahmen, Zuverlässigkeit, Nutzerergebnisse, operative Auswirkungen und Verbesserungsmöglichkeiten."
+}
diff --git a/src/data/method/de/labels.lines.json b/src/data/method/de/labels.lines.json
index 5ccb018..8b0d33b 100644
--- a/src/data/method/de/labels.lines.json
+++ b/src/data/method/de/labels.lines.json
@@ -1,16 +1,16 @@
 {
   "lines.title": "Metro-Linien",
-  "lines.description": "Eine Sammlung von API-Linien, die die Entwicklung und Verwaltung von APIs leiten.",
-  "line.business-opportunities-line.title": "Geschäftsmöglichkeiten Linie",
-  "line.business-opportunities-line.description": "Konzentriert sich auf die Identifizierung und Nutzung von Geschäftsmöglichkeiten durch APIs.",
-  "line.platform-architecture-line.title": "Plattform Architektur Linie",
-  "line.platform-architecture-line.description": "Behandelt die architektonischen Aspekte von API-Plattformen.",
+  "lines.description": "APIOps Cycles-Metrolinien zur Unterstützung der Planung, Umsetzung und Weiterentwicklung von Capabilities, APIs und Integrationen.",
+  "line.business-opportunities-line.title": "Linie Geschäftsmöglichkeiten",
+  "line.business-opportunities-line.description": "Konzentriert sich auf die Identifizierung, Bewertung und Produktisierung von Geschäftsmöglichkeiten als wiederverwendbare Capabilities.",
+  "line.platform-architecture-line.title": "Linie Plattformarchitektur",
+  "line.platform-architecture-line.description": "Behandelt Architekturentscheidungen für Plattformen, Integrationen und Schnittstellen.",
   "line.api-design-line.title": "API-Entwurfslinie",
-  "line.api-design-line.description": "Konzentriert sich auf die Designprinzipien und -praktiken für APIs.",
+  "line.api-design-line.description": "Konzentriert sich auf Entwurfsprinzipien und Best Practices für Schnittstellen und Integrationslösungen.",
   "line.delivery-line.title": "Bereitstellungslinie",
-  "line.delivery-line.description": "Behandelt die Bereitstellungsprozesse und -praktiken für APIs.",
-  "line.publishing-and-adoption-line.title": "Veröffentlichungs- und Adoptionslinie",
-  "line.publishing-and-adoption-line.description": "Der Schwerpunkt liegt auf der Veröffentlichung von APIs und der Gewährleistung ihrer Annahme durch die Verbraucher.",
-  "line.operating-model-line.title": "Betriebsmodell Linie",
-  "line.operating-model-line.description": "Deckt das Betriebsmodell für die API-Verwaltung und -Governance ab."
-}
+  "line.delivery-line.description": "Behandelt Implementierung, Tests, Automatisierung und Bereitstellungspraktiken.",
+  "line.publishing-and-adoption-line.title": "Linie Veröffentlichung & Enablement",
+  "line.publishing-and-adoption-line.description": "Konzentriert sich auf die Veröffentlichung von Capabilities sowie deren Auffindbarkeit, Onboarding und Nutzung.",
+  "line.operating-model-line.title": "Linie Betriebsmodell",
+  "line.operating-model-line.description": "Behandelt Governance, Verantwortlichkeiten und das Betriebsmodell für Capabilities."
+}
\ No newline at end of file
diff --git a/src/data/method/de/labels.resources.json b/src/data/method/de/labels.resources.json
index 9019b39..bb18bc3 100644
--- a/src/data/method/de/labels.resources.json
+++ b/src/data/method/de/labels.resources.json
@@ -13,7 +13,7 @@
   "resource.api-development-best-practices.description": "Implementierungsleitfaden zur Umsetzung eines validierten API-Vertrags in eine konsistente, wartbare API-Codebasis unter Verwendung von Standardbibliotheken, wiederverwendbaren Mustern und aufeinander abgestimmten Entwicklungsabläufen.",
   "resource.api-development-best-practices.outcomes": "Besseres Verständnis der Grundsätze bewährter Verfahren für die API-Entwicklung",
   "resource.api-development-best-practices.steps": "Wenden Sie diese Vorgehensweisen auf den validierten API-Vertrag und den Implementierungsplan an, bevor mit der Programmierung begonnen wird.",
-  "resource.api-development-best-practices.tips": "Verwenden Sie diese Ressource als Implementierungsleitfaden und als Bewertungsinstrument und nicht als obligatorisches eigenständiges Artefakt", 
+  "resource.api-development-best-practices.tips": "Verwenden Sie diese Ressource als Implementierungsleitfaden und als Bewertungsinstrument und nicht als obligatorisches eigenständiges Artefakt",
   "resource.api-metrics-and-analytics.title": "API-Metriken und -Analysen",
   "resource.api-metrics-and-analytics.description": "Eine Ressource zum Definieren, Sammeln und Analysieren von API-Leistungs- und -Nutzungsdaten, um technische KPIs mit den Geschäftsergebnissen in Einklang zu bringen.",
   "resource.api-metrics-and-analytics.outcomes": "Besseres Verständnis von API-Metriken und Analysegrundsätzen",
@@ -403,5 +403,143 @@
   "resource.rest-canvas.steps.2": "Angabe von HTTP-Verben für die Interaktion mit Ressourcen",
   "resource.rest-canvas.steps.3": "Geben Sie Beispiele für Anfragen und Antworten für jedes Verb an.",
   "resource.rest-canvas.tips.1": "Sicherstellen, dass Ressourcen-URIs intuitiv und konsistent sind",
-  "resource.rest-canvas.tips.2": "Fehlerbehandlung und Antwortcodes dokumentieren"
+  "resource.rest-canvas.tips.2": "Fehlerbehandlung und Antwortcodes dokumentieren",
+  "resource.capability-value-proposition-canvas.title": "Capability Value Proposition Canvas",
+  "resource.capability-value-proposition-canvas.description": "Ein technologieunabhängiges Canvas zur Zuordnung von Nutzeraufgaben, Gewinnen, Problemen und möglichen wiederverwendbaren Capabilities, bevor ein Implementierungsstil ausgewählt wird.",
+  "resource.capability-value-proposition-canvas.outcomes": "Klare Wertpositionierung der wiederverwendbaren Capability",
+  "resource.capability-value-proposition-canvas.outcomes.1": "Nutzeraufgaben, Gewinne und Probleme ohne technologische Vorannahme erfasst",
+  "resource.capability-value-proposition-canvas.outcomes.2": "Mögliche wiederverwendbare Capabilities für die Architekturbewertung identifiziert",
+  "resource.capability-value-proposition-canvas.steps": "Listen Sie die Nutzeraufgaben und Ergebnisse auf, die die Capability unterstützen soll.",
+  "resource.capability-value-proposition-canvas.steps.1": "Identifizieren Sie Capability-Merkmale, die Gewinne ermöglichen.",
+  "resource.capability-value-proposition-canvas.steps.2": "Identifizieren Sie Capability-Merkmale, die Probleme reduzieren.",
+  "resource.capability-value-proposition-canvas.steps.3": "Gruppieren Sie die Merkmale zu möglichen wiederverwendbaren Capabilities.",
+  "resource.capability-value-proposition-canvas.tips": "Bleiben Sie technologieunabhängig, bis die Anforderungen auf einen Stil hinweisen.",
+  "resource.capability-value-proposition-canvas.tips.1": "Verwenden Sie dies anstelle des API Value Proposition Canvas, wenn API noch nicht der gewählte Implementierungsstil ist.",
+  "resource.capability-business-model-canvas.title": "Capability Business Model Canvas",
+  "resource.capability-business-model-canvas.description": "Ein Business Model Canvas für wiederverwendbare Integrations-Capabilities, das Wert, Nutzer, Verantwortung, Einbindung, Kosten und Nutzen abdeckt, ohne API-Bereitstellung vorauszusetzen.",
+  "resource.capability-business-model-canvas.outcomes": "Tragfähiges Betriebsmodell für die wiederverwendbare Capability",
+  "resource.capability-business-model-canvas.outcomes.1": "Verantwortung, Nutzer, Kanäle, Partner und Supportbedarf geklärt",
+  "resource.capability-business-model-canvas.outcomes.2": "Kosten und Nutzen vor der Architekturfestlegung sichtbar",
+  "resource.capability-business-model-canvas.steps": "Fassen Sie die Wertpositionierung der Capability zusammen.",
+  "resource.capability-business-model-canvas.steps.1": "Identifizieren Sie Nutzersegmente und Einbindungskanäle.",
+  "resource.capability-business-model-canvas.steps.2": "Definieren Sie Schlüsselaktivitäten, Ressourcen und Partner.",
+  "resource.capability-business-model-canvas.steps.3": "Erfassen Sie Kosten und Nutzen.",
+  "resource.capability-business-model-canvas.steps.4": "Klären Sie Verantwortung, Finanzierung, Support und Lifecycle-Erwartungen.",
+  "resource.capability-business-model-canvas.steps.5": "Validieren Sie das Modell mit Nutzern, Produzenten und Governance-Stakeholdern.",
+  "resource.capability-business-model-canvas.tips": "Verwenden Sie dies anstelle des API Business Model Canvas, wenn der Implementierungsstil noch offen ist.",
+  "resource.capability-business-model-canvas.tips.1": "Fokussieren Sie auf die Tragfähigkeit der wiederverwendbaren Capability, nicht auf eine einmalige Verbindung.",
+  "resource.consumer-experience-requirements-canvas.title": "Consumer Experience Requirements Canvas",
+  "resource.consumer-experience-requirements-canvas.description": "Ein Anforderungen-Canvas für nutzerbezogene Experience- und nichtfunktionale Anforderungen, die die spätere Architekturentscheidung steuern sollen.",
+  "resource.consumer-experience-requirements-canvas.outcomes": "Technologieunabhängige Nutzeranforderungen",
+  "resource.consumer-experience-requirements-canvas.outcomes.1": "Experience- und nichtfunktionale Anforderungen vor Designbeginn erfasst",
+  "resource.consumer-experience-requirements-canvas.outcomes.2": "Architekturauswirkungen für die Stilauswahl dokumentiert",
+  "resource.consumer-experience-requirements-canvas.steps": "Erfassen Sie Nutzerziele und Nutzungskontext.",
+  "resource.consumer-experience-requirements-canvas.steps.1": "Dokumentieren Sie Erwartungen an Verfügbarkeit, Aktualität, Volumen, Performance, Datenqualität und Konsistenz.",
+  "resource.consumer-experience-requirements-canvas.steps.2": "Dokumentieren Sie Erwartungen an Sicherheit, Datenschutz, Onboarding, Änderung, Beobachtbarkeit, Support und Wiederherstellung.",
+  "resource.consumer-experience-requirements-canvas.steps.3": "Fassen Sie zusammen, was die Anforderungen für mögliche Architekturstile bedeuten.",
+  "resource.consumer-experience-requirements-canvas.tips": "Verwenden Sie dies als Brücke zwischen Capability-Wert und Architekturentscheidung.",
+  "resource.consumer-experience-requirements-canvas.tips.1": "Wählen Sie API, Event, Datei, Stream oder Datenprodukt erst aus, wenn die Anforderungen die Passung erkennen lassen.",
+  "resource.integration-style-selection-guide.title": "Leitfaden zur Auswahl des Implementierungsstils",
+  "resource.integration-style-selection-guide.description": "Orientierung zur Auswahl zwischen API, Event, Datei, Stream, Datenprodukt, direkter Integration oder hybriden Implementierungsstilen auf Grundlage von Anforderungen und Rahmenbedingungen.",
+  "resource.integration-style-selection-guide.outcomes": "Begründeter Implementierungsstil für die Integration",
+  "resource.integration-style-selection-guide.outcomes.1": "Abwägungen zwischen den Optionen für den Implementierungsstil dokumentiert",
+  "resource.integration-style-selection-guide.outcomes.2": "Ausgewählter Stil auf Anforderungen von Nutzern, Plattform, Daten und Betrieb zurückführbar",
+  "resource.integration-style-selection-guide.steps": "Vergleichen Sie tragfähige Implementierungsstile anhand von Latenz, Volumen, Kopplung, Datenverantwortung, Aktualität, Governance und Betriebsfähigkeit.",
+  "resource.integration-style-selection-guide.steps.1": "Identifizieren Sie, wann API, Event, Datei, Stream, Datenprodukt, direkte Integration oder hybride Ansätze zum Anwendungsfall passen.",
+  "resource.integration-style-selection-guide.steps.2": "Dokumentieren Sie Einschränkungen, Risiken und Plattformabhängigkeiten für den ausgewählten Implementierungsstil.",
+  "resource.integration-style-selection-guide.steps.3": "Halten Sie fest, warum verworfene Alternativen nicht ausgewählt wurden.",
+  "resource.integration-style-selection-guide.tips": "Verwenden Sie diese Ressource, nachdem die Anforderungen explizit sind und bevor das detaillierte Vertragsdesign beginnt.",
+  "resource.integration-style-selection-guide.tips.1": "Behalten Sie REST-, Event-, GraphQL-, Datei-, Stream- und Datenprodukt-Ressourcen als optionale nachgelagerte Designressourcen bei.",
+  "resource.process-workflow-design-guide.title": "Leitfaden für Prozess- und Workflow-Design",
+  "resource.process-workflow-design-guide.description": "Orientierung zur Modellierung von Prozessschritten, Rollen, Übergaben, Entscheidungspunkten, Zuständen, Eingaben, Ausgaben und Ausnahmen, die einen Automatisierungs-Workflow prägen.",
+  "resource.process-workflow-design-guide.outcomes": "Klares Design des Automatisierungs-Workflows",
+  "resource.process-workflow-design-guide.outcomes.1": "Prozessschritte und Übergaben vor der Implementierung dokumentiert",
+  "resource.process-workflow-design-guide.outcomes.2": "Workflow-Zustände, Eingaben, Ausgaben und Ausnahmewege verstanden",
+  "resource.process-workflow-design-guide.steps": "Modellieren Sie den aktuellen und den Ziel-Prozessfluss einschließlich menschlicher und systemseitiger Verantwortlichkeiten.",
+  "resource.process-workflow-design-guide.steps.1": "Identifizieren Sie Workflow-Auslöser, Zustände, Entscheidungen, Dateneingaben, Ausgaben und Abschlusskriterien.",
+  "resource.process-workflow-design-guide.steps.2": "Dokumentieren Sie Übergaben zwischen Nutzern, Systemen, Betrieb und Supportrollen.",
+  "resource.process-workflow-design-guide.steps.3": "Bestätigen Sie, welche Schritte automatisiert werden sollen und welche menschliches Urteilsvermögen erfordern.",
+  "resource.process-workflow-design-guide.tips": "Halten Sie Prozessdesign vom API- oder Integrationsvertragsdesign getrennt, bis der Workflow klar ist.",
+  "resource.process-workflow-design-guide.tips.1": "Verwenden Sie diese Ressource als primäre Designressource für Automatisierungs-Workflows.",
+  "resource.decision-business-rules-guide.title": "Leitfaden für Entscheidungen und Geschäftsregeln",
+  "resource.decision-business-rules-guide.description": "Orientierung zur Erfassung von Regeln, Schwellenwerten, Entscheidungen, Genehmigungen, Eignungsprüfungen und Regelverantwortung für das Automatisierungsdesign.",
+  "resource.decision-business-rules-guide.outcomes": "Explizite Entscheidungen und Geschäftsregeln",
+  "resource.decision-business-rules-guide.outcomes.1": "Regeln und Schwellenwerte mit Verantwortlichen dokumentiert",
+  "resource.decision-business-rules-guide.outcomes.2": "Automatisierungsentscheidungen auf Richtlinien, Prozesse oder Geschäftsabsicht zurückführbar",
+  "resource.decision-business-rules-guide.steps": "Listen Sie Entscheidungen auf, die die Automatisierung treffen oder unterstützen muss.",
+  "resource.decision-business-rules-guide.steps.1": "Dokumentieren Sie Regelbedingungen, Schwellenwerte, Ausnahmen, Genehmigungen und Eskalationspunkte.",
+  "resource.decision-business-rules-guide.steps.2": "Identifizieren Sie Regelverantwortliche und Änderungsgovernance für jeden Entscheidungsbereich.",
+  "resource.decision-business-rules-guide.tips": "Trennen Sie stabile Geschäftsregeln von konfigurierbaren betrieblichen Parametern.",
+  "resource.decision-business-rules-guide.tips.1": "Nutzen Sie Beispiele und Grenzfälle, um die Regelauslegung zu validieren.",
+  "resource.automation-trigger-handoff-exception-guide.title": "Leitfaden für Automatisierungsauslöser, Übergaben und Ausnahmen",
+  "resource.automation-trigger-handoff-exception-guide.description": "Orientierung zur Definition von Automatisierungsauslösern, menschlichen Übergaben, Ausnahmebehandlung, Wiederholungen, Ausgleichsmaßnahmen und Support-Eskalationswegen.",
+  "resource.automation-trigger-handoff-exception-guide.outcomes": "Definierte Automatisierungsauslöser und Ausnahmewege",
+  "resource.automation-trigger-handoff-exception-guide.outcomes.1": "Menschliche Übergaben und Support-Eskalationen sind explizit",
+  "resource.automation-trigger-handoff-exception-guide.outcomes.2": "Ausnahmen, Wiederholungen und Ausgleichsmaßnahmen sind vor der Bereitstellung entworfen",
+  "resource.automation-trigger-handoff-exception-guide.steps": "Definieren Sie Ereignisse, Zeitpläne, Nutzeraktionen oder Systemzustände, die die Automatisierung auslösen.",
+  "resource.automation-trigger-handoff-exception-guide.steps.1": "Modellieren Sie Übergaben von der Automatisierung an Nutzer, Betreiber oder Supportteams.",
+  "resource.automation-trigger-handoff-exception-guide.steps.2": "Dokumentieren Sie Ausnahmen, Wiederholungsregeln, Timeout-Verhalten und Rückfallwege.",
+  "resource.automation-trigger-handoff-exception-guide.steps.3": "Definieren Sie Warnungen und Eskalationsschwellen für fehlgeschlagene oder uneindeutige Automatisierungsergebnisse.",
+  "resource.automation-trigger-handoff-exception-guide.tips": "Gestalten Sie Ausnahmewege als vollwertiges Workflow-Verhalten, nicht als nachträgliche Ergänzung.",
+  "resource.automation-trigger-handoff-exception-guide.tips.1": "Beziehen Sie Geschäfts- und Betriebsrollen ein, wenn Übergaben validiert werden.",
+  "resource.automation-testing-guide.title": "Leitfaden für Automatisierungstests",
+  "resource.automation-testing-guide.description": "Orientierung zum Testen automatisierter Workflows, Entscheidungen, Integrationen, Ausnahmen, Rollback-Verhalten, Überwachung und Nutzerauswirkungen vor der Veröffentlichung.",
+  "resource.automation-testing-guide.outcomes": "Validiertes Automatisierungsverhalten",
+  "resource.automation-testing-guide.outcomes.1": "Workflow-, Regel-, Ausnahme- und Integrationstests definiert",
+  "resource.automation-testing-guide.outcomes.2": "Veröffentlichungssicherheit für automatisierte und menschlich unterstützte Pfade",
+  "resource.automation-testing-guide.steps": "Erstellen Sie Tests für Standardabläufe, Grenzfälle, Ausnahmen, Wiederholungen und Übergaben.",
+  "resource.automation-testing-guide.steps.1": "Validieren Sie Geschäftsregeln und Entscheidungsergebnisse mit repräsentativen Daten.",
+  "resource.automation-testing-guide.steps.2": "Testen Sie Rollback, Wiederherstellung, Beobachtbarkeit und manuelle Eingriffspfade.",
+  "resource.automation-testing-guide.steps.3": "Beziehen Sie Nutzer und Betreiber in Abnahmetests ein, wenn die Automatisierung Arbeitsweisen verändert.",
+  "resource.automation-testing-guide.tips": "Verwenden Sie produktionsnahe Szenarien und Datenstrukturen, ohne sensible Daten offenzulegen.",
+  "resource.automation-testing-guide.tips.1": "Halten Sie Testnachweise für die Bereitschaftsprüfung verfügbar.",
+  "resource.automation-operational-ownership-guide.title": "Leitfaden für die betriebliche Verantwortung von Automatisierungen",
+  "resource.automation-operational-ownership-guide.description": "Orientierung zur Definition von Verantwortung, Runbooks, Überwachung, Support, Monitoring, Änderungskontrolle und kontinuierlicher Verbesserung für Automatisierungen.",
+  "resource.automation-operational-ownership-guide.outcomes": "Klares Betriebsmodell für die Automatisierung",
+  "resource.automation-operational-ownership-guide.outcomes.1": "Verantwortlichkeiten für Eigentum, Support und Eskalation zugewiesen",
+  "resource.automation-operational-ownership-guide.outcomes.2": "Monitoring- und Änderungspraktiken für den Live-Betrieb bereit",
+  "resource.automation-operational-ownership-guide.steps": "Definieren Sie fachliche, technische und betriebliche Verantwortliche für die Automatisierung.",
+  "resource.automation-operational-ownership-guide.steps.1": "Dokumentieren Sie Runbooks, Supportwege, Monitoring-Signale, Serviceerwartungen und Eskalationsregeln.",
+  "resource.automation-operational-ownership-guide.steps.2": "Legen Sie Änderungskontrolle und Review-Praktiken für Workflow-, Plattform- und Regeländerungen fest.",
+  "resource.automation-operational-ownership-guide.tips": "Veröffentlichen Sie keine Automatisierung ohne benannte verantwortliche Person für Ausnahmen und laufende Verbesserung.",
+  "resource.automation-operational-ownership-guide.tips.1": "Machen Sie Überwachungsbedarf sichtbar, bevor die Bereitstellungsplanung abgeschlossen ist.",
+  "resource.automation-rollback-supervision-guide.title": "Leitfaden für Rollback und Überwachung von Automatisierungen",
+  "resource.automation-rollback-supervision-guide.description": "Orientierung zur Gestaltung von Rollback-, Pausen-, manuellen Übersteuerungs-, Monitoring-, Überwachungs- und Wiederherstellungspfaden für Automatisierungen.",
+  "resource.automation-rollback-supervision-guide.outcomes": "Kontrollierte Wiederherstellungspfade für Automatisierungen",
+  "resource.automation-rollback-supervision-guide.outcomes.1": "Rollback-, Pausen- und Übersteuerungsverhalten dokumentiert",
+  "resource.automation-rollback-supervision-guide.outcomes.2": "Überwachungsbedarf und Wiederherstellungsverantwortlichkeiten definiert",
+  "resource.automation-rollback-supervision-guide.steps": "Identifizieren Sie Aktionen, die rückgängig gemacht, pausiert oder manuell übersteuert werden können müssen.",
+  "resource.automation-rollback-supervision-guide.steps.1": "Definieren Sie Rollback-, Kompensations- und Wiederherstellungsverfahren für fehlgeschlagene oder falsche Automatisierungsergebnisse.",
+  "resource.automation-rollback-supervision-guide.steps.2": "Dokumentieren Sie Überwachungsschwellen, Warnungen und manuelle Entscheidungspunkte.",
+  "resource.automation-rollback-supervision-guide.steps.3": "Validieren Sie Wiederherstellungsverfahren vor der Veröffentlichung.",
+  "resource.automation-rollback-supervision-guide.tips": "Behandeln Sie Rollback und Überwachung als Teil des Workflow-Designs und des Bereitstellungsplans.",
+  "resource.automation-rollback-supervision-guide.tips.1": "Nutzen Sie betriebliche Vorfälle und Beinahe-Vorfälle, um Überwachungskriterien zu verfeinern.",
+  "resource.automation-readiness-checklist.title": "Checkliste zur Automatisierungsbereitschaft",
+  "resource.automation-readiness-checklist.description": "Eine Checkliste zur Validierung von Automatisierungs-Workflow, Kontrollen, Risiko, Compliance, menschlicher Aufsicht, Testnachweisen, Rollback, Betrieb und Veröffentlichungsbereitschaft.",
+  "resource.automation-readiness-checklist.outcomes": "Dokumentierte Automatisierungsbereitschaft",
+  "resource.automation-readiness-checklist.outcomes.1": "Bekannte Bereitschaftslücken und Gegenmaßnahmen vor der Veröffentlichung",
+  "resource.automation-readiness-checklist.outcomes.2": "Nachweise für Qualität, Risiko, Compliance, Aufsicht und betriebliche Freigabe",
+  "resource.automation-readiness-checklist.steps": "Prüfen Sie Workflow-Design, Geschäftsregeln, Kontrollen, Zugriff, Datenverarbeitung und Ausnahmewege.",
+  "resource.automation-readiness-checklist.steps.1": "Überprüfen Sie Testnachweise, Rollback-Verfahren, Überwachungsmodell und Supportbereitschaft.",
+  "resource.automation-readiness-checklist.steps.2": "Bestätigen Sie Verantwortung, Runbooks, Monitoring, Änderungskontrollen und Veröffentlichungsfreigabe.",
+  "resource.automation-readiness-checklist.steps.3": "Dokumentieren Sie ungelöste Lücken, Entscheidungen und akzeptierte Risiken vor der Veröffentlichung.",
+  "resource.automation-readiness-checklist.tips": "Verwenden Sie die Checkliste vor der Veröffentlichung und erneut nach wesentlichen Workflow- oder Regeländerungen.",
+  "resource.automation-readiness-checklist.tips.1": "Machen Sie menschliche Aufsicht und Ausnahmebehandlung in den Nachweisen explizit.",
+  "resource.automation-rollout-enablement-guide.title": "Leitfaden für Rollout und Enablement von Automatisierungen",
+  "resource.automation-rollout-enablement-guide.description": "Orientierung für die Einführung von Automatisierungen mit Nutzerkommunikation, Onboarding, Betriebsanweisungen, Supportwegen, Change Management und Feedback-Schleifen.",
+  "resource.automation-rollout-enablement-guide.outcomes": "Befähigte Automatisierungsnutzer und Betreiber",
+  "resource.automation-rollout-enablement-guide.outcomes.1": "Rollout-Kommunikation, Onboarding und Supportwege vorbereitet",
+  "resource.automation-rollout-enablement-guide.outcomes.2": "Nutzer und Betreiber verstehen, wie sich die Arbeit nach der Veröffentlichung der Automatisierung verändert",
+  "resource.automation-rollout-enablement-guide.steps": "Definieren Sie Rollout-Zielgruppen, Zeitplan, Kommunikationskanäle und Schulungsbedarf.",
+  "resource.automation-rollout-enablement-guide.steps.1": "Veröffentlichen Sie Betriebsanweisungen, Supportwege, Hinweise zur Ausnahmebehandlung und Eskalationskontakte.",
+  "resource.automation-rollout-enablement-guide.steps.2": "Planen Sie Übergangsunterstützung für Nutzer, Betreiber und Prozessverantwortliche.",
+  "resource.automation-rollout-enablement-guide.steps.3": "Sammeln Sie Feedback nach dem Rollout und überführen Sie Verbesserungen in den Backlog.",
+  "resource.automation-rollout-enablement-guide.tips": "Verwenden Sie für Automatisierungen Rollout-Sprache, statt Enablement wie API-Veröffentlichung zu behandeln.",
+  "resource.automation-rollout-enablement-guide.tips.1": "Beziehen Sie sowohl die vom Prozess betroffenen Nutzer als auch die für die Automatisierung verantwortlichen Betreiber ein.",
+  "resource.api-community-engagement-strategies.tips.2": "Verwenden Sie diese Ressource, wenn eine API der ausgewählte Implementierungsstil ist.",
+  "resource.api-development-best-practices.tips.2": "Verwenden Sie diese Ressource, wenn eine API der ausgewählte Implementierungsstil ist.",
+  "resource.api-metrics-and-analytics.tips.2": "Verwenden Sie diese Ressource, wenn eine API der ausgewählte Implementierungsstil ist.",
+  "resource.api-testing-best-practices.tips.2": "Verwenden Sie diese Ressource, wenn eine API der ausgewählte Implementierungsstil ist.",
+  "resource.apiops-CI-CD-for-apis.tips.2": "Verwenden Sie diese Ressource, wenn eine API der ausgewählte Implementierungsstil ist.",
+  "resource.api-audit-checklist.tips.2": "Verwenden Sie diese Ressource, wenn eine API der ausgewählte Implementierungsstil ist."
 }
diff --git a/src/data/method/de/labels.stakeholders.json b/src/data/method/de/labels.stakeholders.json
index 340ccab..2c42cf8 100644
--- a/src/data/method/de/labels.stakeholders.json
+++ b/src/data/method/de/labels.stakeholders.json
@@ -1,35 +1,49 @@
 {
-  "stakeholder.involvement.lead": "Leider",
+  "stakeholder.involvement.lead": "Federführend",
   "stakeholder.involvement.core": "Kern",
-  "stakeholder.involvement.consulted": "Beratung",
-  "stakeholder.business-owner.title": "Geschäftsinhaber",
-  "stakeholder.business-owner.description": "Repräsentiert Geschäftsziele, Finanzierung und erwartete Ergebnisse für das API-Initiative.",
-  "stakeholder.api-program-owner.title": "API Program Owner",
-  "stakeholder.api-program-owner.description": "Koordiniert API-Portfolio-Praktiken, organisatorische Ausrichtung und langfristige API-Fähigkeitsentwicklung.",
+  "stakeholder.involvement.consulted": "Konsultiert",
+  "stakeholder.business-owner.title": "Business Owner",
+  "stakeholder.business-owner.description": "Vertritt Geschäftsziele, Finanzierung und erwartete Ergebnisse der Capability-, API- oder Automatisierungsinitiative.",
+  "stakeholder.api-program-owner.title": "API-Programmverantwortlicher",
+  "stakeholder.api-program-owner.description": "Koordiniert API-Portfolio-Praktiken, organisatorische Ausrichtung und langfristige Entwicklung von API-Capabilities.",
   "stakeholder.api-product-owner.title": "API Product Owner",
-  "stakeholder.api-product-owner.description": "Führt die API-Möglichkeit, Priorisierung und produktniveaubezogene Entscheidungen über den gesamten Lebenszyklus hinweg durch.",
-  "stakeholder.domain-expert.title": "Domain-Experte",
-  "stakeholder.domain-expert.description": "Bringt tiefe Kenntnisse des Geschäftsbereichs, Konzepte, Regeln und Einschränkungen mit, die die API widerspiegeln muss.",
-  "stakeholder.customer-or-partner-representative.title": "Kunden- oder Partnervertreter",
-  "stakeholder.customer-or-partner-representative.description": "Repräsentiert die Perspektive von Kunden oder Partnern für den Reise, Wert und Zusammenarbeitsmodell.",
-  "stakeholder.api-consumer-representative.title": "API-Verbrauchervertreter",
-  "stakeholder.api-consumer-representative.description": "Repräsentiert die Bedürfnisse von Entwicklern, Integratoren oder anderen API-Verbrauchern, die die API direkt verwenden.",
+  "stakeholder.api-product-owner.description": "Steuert API-Chance, Priorisierung und produktbezogene Entscheidungen über den gesamten Lebenszyklus hinweg.",
+  "stakeholder.capability-owner.title": "Capability Owner",
+  "stakeholder.capability-owner.description": "Verantwortet Vision, Wert, Prioritäten, Lebenszyklus und Wiederverwendung der Capability über Nutzer hinweg.",
+  "stakeholder.domain-specialist.title": "Domain-Experte",
+  "stakeholder.domain-specialist.description": "Bringt tiefes Wissen über Geschäftsdomäne, Konzepte, Regeln und Einschränkungen ein, die die Capability oder Schnittstelle widerspiegeln muss.",
+  "stakeholder.customer-specialist.title": "Kunden- oder Partnervertreter",
+  "stakeholder.customer-specialist.description": "Vertritt die Perspektive von Kunden oder Partnern hinsichtlich Journey, Wert und Zusammenarbeitsmodell.",
+  "stakeholder.api-consumer-specialist.title": "Vertreter der API-Nutzer",
+  "stakeholder.api-consumer-specialist.description": "Vertritt die Anforderungen von Entwicklern, Integratoren und anderen Nutzern der API.",
   "stakeholder.platform-architect.title": "Plattform-Architekt",
-  "stakeholder.platform-architect.description": "Leitet Entscheidungen über Plattform, Integration, Skalierbarkeit und Architektur, die beeinflussen, wie die API erstellt und betrieben wird.",
+  "stakeholder.platform-architect.description": "Leitet Entscheidungen zu Plattform, Integration, Skalierbarkeit und Architektur, die beeinflussen, wie die Capability oder API erstellt und betrieben wird.",
+  "stakeholder.api-architect.title": "API-Architekt",
+  "stakeholder.api-architect.description": "Verantwortet API-Architektur, Entwurfsprinzipien und die Qualität der Schnittstellenverträge.",
+  "stakeholder.integration-architect.title": "Integrationsarchitekt",
+  "stakeholder.integration-architect.description": "Entwirft Integrationsansätze und Implementierungsstile, die die Capability oder API mit anderen Systemen verbinden.",
+  "stakeholder.platform-owner.title": "Plattformverantwortlicher",
+  "stakeholder.platform-owner.description": "Verantwortet Plattform-Capabilities, Roadmap, Betriebsmodell und Serviceerwartungen.",
   "stakeholder.api-designer.title": "API-Designer",
-  "stakeholder.api-designer.description": "Formt den API-Vertrag, das Interaktionsmodell, die Konsistenz und die Benutzbarkeit der exponierten Fähigkeiten.",
-  "stakeholder.delivery-engineer.title": "Programmierer",
-  "stakeholder.delivery-engineer.description": "Verantwortlich für Implementierung, Automatisierung, Testing und Release-Flussbedürfnisse, die für die zuverlässige Lieferung der API erforderlich sind.",
+  "stakeholder.api-designer.description": "Gestaltet Schnittstellenvertrag, Interaktionsmodell, Konsistenz, Benutzerfreundlichkeit und bereitgestellte Capabilities.",
+  "stakeholder.api-engineer.title": "API-Entwickler",
+  "stakeholder.api-engineer.description": "Verantwortet Implementierung, Automatisierung, Tests und Release-Abläufe, die für die zuverlässige Bereitstellung der Capability, API oder Automatisierung erforderlich sind.",
+  "stakeholder.automation-owner.title": "Automatisierungsverantwortlicher",
+  "stakeholder.automation-owner.description": "Verantwortet Ziele, Geschäftswert, Prioritäten, Kontrollen und Lebenszyklusergebnisse der Automatisierung.",
+  "stakeholder.process-owner.title": "Prozessverantwortlicher",
+  "stakeholder.process-owner.description": "Verantwortet den zu automatisierenden Geschäftsprozess, einschließlich Ziele, Regeln, Ergebnisse und Verbesserungsprioritäten.",
+  "stakeholder.automation-engineer.title": "Automatisierungsingenieur",
+  "stakeholder.automation-engineer.description": "Implementiert, testet, integriert und betreibt Automatisierungslösungen und unterstützende Workflows.",
   "stakeholder.security-specialist.title": "Sicherheitsspezialist",
-  "stakeholder.security-specialist.description": "Stellt sicher, dass Sicherheitsrisiken, Kontrollen und Vertrauensgrenzen im gesamten API-Lifecycle berücksichtigt werden.",
-  "stakeholder.compliance-legal-specialist.title": "Compliance and Legal Specialist",
-  "stakeholder.compliance-legal-specialist.description": "Klärt rechtliche, datenschutzrechtliche, regulatorische und vertragliche Anforderungen auf, die die API beeinflussen.",
-  "stakeholder.governance-owner.title": "Governance Owner",
-  "stakeholder.governance-owner.description": "Repräsentiert Überprüfung, Auditierung und organisationsweite Governance-Praktiken für API-Qualität und Konformität.",
-  "stakeholder.documentation-devrel-owner.title": "Documentation and DevRel Owner",
-  "stakeholder.documentation-devrel-owner.description": "Verantwortlich für Onboarding-Inhalte, Entwickler-Kommunikation und Dokumentationsqualität für API-Verbraucher.",
-  "stakeholder.support-operations-owner.title": "Support and Operations Owner",
-  "stakeholder.support-operations-owner.description": "Repräsentiert Runtime-Support, Vorfallbehandlung, Beobachtbarkeit und operative Bereitschaft.",
-  "stakeholder.partner-vendor-manager.title": "Partner- oder Vendor-Manager",
-  "stakeholder.partner-vendor-manager.description": "Koordiniert externe Partner-, Lieferanten- oder Vendor-Beziehungen, die die API-Strategie und -Lieferung beeinflussen."
+  "stakeholder.security-specialist.description": "Stellt sicher, dass Sicherheitsrisiken, Kontrollen und Vertrauensgrenzen über den gesamten Lebenszyklus hinweg berücksichtigt werden.",
+  "stakeholder.compliance-specialist.title": "Compliance- und Rechtsexperte",
+  "stakeholder.compliance-specialist.description": "Klärt rechtliche, Datenschutz-, regulatorische und vertragliche Anforderungen, die Capability, API, Schnittstelle oder Automatisierung betreffen.",
+  "stakeholder.governance-specialist.title": "Governance-Verantwortlicher",
+  "stakeholder.governance-specialist.description": "Repräsentiert Überprüfung, Auditierung und organisationsweite Governance-Praktiken für API-Qualität und Konformität.",
+  "stakeholder.api-devrel-specialist.title": "Verantwortlicher für Dokumentation und DevRel",
+  "stakeholder.api-devrel-specialist.description": "Verantwortet Onboarding-Inhalte, Entwicklerkommunikation und Dokumentationsqualität für API-Nutzer.",
+  "stakeholder.operations-specialist.title": "Verantwortlicher für Support und Betrieb",
+  "stakeholder.operations-specialist.description": "Repräsentiert Runtime-Support, Vorfallbehandlung, Beobachtbarkeit und operative Bereitschaft für Capability, API oder Automatisierung.",
+  "stakeholder.partner-specialist.title": "Partner- und Lieferantenmanager",
+  "stakeholder.partner-specialist.description": "Koordiniert externe Partner-, Lieferanten- oder Anbieterbeziehungen, die Capability- oder API-Strategie und Umsetzung beeinflussen."
 }
diff --git a/src/data/method/de/labels.stations.json b/src/data/method/de/labels.stations.json
index e60ba4b..4136edb 100644
--- a/src/data/method/de/labels.stations.json
+++ b/src/data/method/de/labels.stations.json
@@ -1,61 +1,61 @@
 {
-  "group.core-stations.title": "API-Lebenszyklus Kernstationen",
-  "group.core-stations.description": "Die Kernstationen der API Metro, wo Teams lernen können, wie man APIs effektiv erstellt und verwaltet.",
-  "group.sub-stations.title": "API-Lebenszyklus-Unterstationen",
-  "group.sub-stations.description": "Unterstationen, die zusätzliche Ressourcen, Tools und bewährte Verfahren für API-Teams bereitstellen.",
-  "station.api-product-strategy.title": "API-Produktstrategie - APIs in strategische Produkte verwandeln",
-  "station.api-product-strategy.description": "Bevor Sie etwas bauen, sollten Sie von Anfang an den Wert, die Benutzer und die Geschäftsziele Ihrer API definieren.",
-  "station.api-product-strategy.why_it_matters": "Viele Unternehmen betrachten APIs als technische Projekte und nicht als Produkte. Das Ergebnis? Verwirrte Kunden, schlechte Akzeptanz und verschwendeter Aufwand.\n\nDiese Station hilft Ihnen, den Zweck Ihrer API, die Zielgruppe und die Erfolgskriterien zu definieren, damit Teams APIs bereitstellen können, die echte Probleme lösen.",
-  "station.api-product-strategy.apply_in_work": "Bereitstellung von Richtlinien und Vorlagen für die Erstellung von API-Geschäftsmodellen, Wertvorschlägen und Roadmaps.",
-  "station.api-product-strategy.outcomes": "Ein klares API-Wertversprechen und eine klare Zielgruppe",
-  "station.api-product-strategy.how_it_works": "Untersuchen Sie das Kunden- oder Partnerproblem, das Sie mit APIs lösen wollen. Zeichnen Sie die Stakeholder, deren Wege und Ergebnisse mithilfe der Customer Journey Canvas auf.",
-  "station.api-consumer-experience.title": "API Consumer Experience - Design für die echten Benutzer Ihrer API",
-  "station.api-consumer-experience.description": "Stellen Sie sicher, dass Ihre API auffindbar, verständlich und nutzbar ist - vor und nach der Einführung.",
-  "station.api-consumer-experience.why_it_matters": "Großartige APIs funktionieren nicht nur - sie fühlen sich auch intuitiv an. Ganz gleich, ob Ihr Kunde ein interner Entwickler, ein externer Partner oder ein KI-Agent ist, seine Erfahrung entscheidet über die Akzeptanz.\n\nOhne einen klaren Erlebnisplan:\n- Großartige APIs bleiben ungenutzt\n- Teams verschwenden Zeit damit, zu raten, wie sie Ihre API verwenden sollen\n- Feedbackschleifen sind unterbrochen oder fehlen.\n\nDiese Station hilft Ihnen, Ihre API mit den Augen ihrer Nutzer zu sehen.",
-  "station.api-consumer-experience.how_it_works": "Überprüfen Sie das bestehende API Value Proposition Canvаs von der Perspektive des API-Nutzers. Stellen Sie die Stabilität der unterstützten Geschäftsprozesse sicher und ergänzen Sie die Funktionen, die Probleme lösen und Vorteile bieten, um die Bedürfnisse der API-Nutzer zu berücksichtigen, damit diese spätere Designentscheidungen leiten können.",
-   "station.api-consumer-experience.how_it_works.1": "Verwenden Sie das Customer Journey Canvas für die Customer Journey des API-Nutzers von der Entdeckung und Bewertung bis hin zu Onboarding, Integration, Fehlerbehebung und fortlaufender Nutzung.", 
-  "station.api-consumer-experience.how_it_works.2": "Nutzen Sie die daraus resultierende Customer Journey, um Onboarding, Dokumentation, Support und Feedback-Schleifen für den API-Nutzer zu verbessern.",
-  "station.api-consumer-experience.apply_in_work": "Bereitstellung von Richtlinien, Tools und Feedback-Mechanismen für das Verständnis, die Analyse und die Verbesserung der internen und externen Erfahrungen von Entwicklern und Partnern.",
-  "station.api-consumer-experience.outcomes": "Identifizieren und priorisieren Sie Ihre API-Kunden",
-  "station.api-platform-architecture.title": "API-Plattformarchitektur - Architektur von APIs für Skalierbarkeit und Wiederverwendung",
-  "station.api-platform-architecture.description": "Gewährleisten Sie Skalierbarkeit, Wiederverwendung und Governance für Ihre API- und Plattformkomponenten.",
-  "station.api-platform-architecture.why_it_matters": "Wenn APIs teamübergreifend skaliert werden, muss Ihre Plattform Governance und Wiederverwendung ermöglichen, ohne die Geschwindigkeit zu beeinträchtigen. Diese Station zeigt, wie man APIs für Langlebigkeit, Sicherheit und Effizienz entwickelt.",
-  "station.api-platform-architecture.apply_in_work": "Aufbau einer skalierbaren, sicheren und konformen Infrastruktur für den API-Betrieb. Bereitstellung von Leitlinien für bewährte Architekturverfahren.",
-  "station.api-platform-architecture.outcomes": "Redundante APIs abbauen und die Kosten für die Cloud-Plattform senken",
-  "station.api-platform-architecture.how_it_works": "Das Business Impact Canvas hilft dabei, Risiken in Bezug auf API-Verfügbarkeit, -Sicherheit und -Funktionalität zu identifizieren und zu mindern, um fundierte Architekturentscheidungen zu unterstützen.",
-  "station.api-design.title": "API-Design - Entwerfen Sie APIs, die Wert liefern",
-  "station.api-design.description": "Erstellen Sie API-Designs, die konsistent, wiederverwendbar und auf Geschäftszielen und gemeinsamen Standards basieren.",
-  "station.api-design.why_it_matters": "Beim Entwurf von APIs geht es nicht nur um die Benennung von Endpunkten. Gutes Design stellt sicher, dass APIs benutzerfreundlich, konsistent und auf Geschäfts- und technische Ziele ausgerichtet sind. Schlecht gestaltete APIs führen zu enger Kopplung, geringer Wiederverwendung und kostspieligen Nacharbeiten in den Teams.",
-  "station.api-design.apply_in_work": "Bereitstellung von wiederverwendbaren Designmustern, gemeinsamen Standards und Validierungstools für API-Spezifikationen. Sicherstellen, dass Designentscheidungen konsistent, frühzeitig überprüft und auf die Geschäftsabsicht ausgerichtet sind.",
-  "station.api-design.outcomes": "Gut dokumentierte und konsistente API-Designs",
-  "station.api-design.how_it_works": "Definieren Sie zentrale Entitäten, ihre Attribute und Beziehungen, um ein gemeinsames konzeptionelles Verständnis für alle APIs zu schaffen.",
-  "station.api-delivery.title": "API-Bereitstellung - Bereitstellung sicherer und zuverlässiger APIs",
-  "station.api-delivery.description": "Erstellen, Testen und Freigeben von APIs unter Verwendung moderner Bereitstellungspipelines und bewährter technischer Verfahren.",
-  "station.api-delivery.why_it_matters": "Selbst die besten API-Designs scheitern, wenn die Bereitstellung uneinheitlich ist. Diese Station stellt sicher, dass Ihre APIs qualitativ hochwertig erstellt, gründlich getestet und zuverlässig bereitgestellt werden - für schnellere Iterationen und mehr Vertrauen.",
-  "station.api-delivery.apply_in_work": "Bereitstellung von Kodierungsrahmen, Bibliotheken und Standards für die API-Implementierung. Implementierung von CI/CD-Pipelines, Qualitätssicherungs-Frameworks und Tools zur Automatisierung der Bereitstellung.",
-  "station.api-delivery.outcomes": "APIs, die mit getesteten Frameworks und Mustern implementiert werden",
-  "station.api-delivery.how_it_works": "Verwenden Sie Best Practices für die API-Entwicklung als Leitfaden für die Implementierung des validierten Vertrags mit etablierten Frameworks und Bibliotheken, um sicherzustellen, dass das Ergebnis wiederverwendbar und wartbar ist.",
-  "station.api-audit.title": "API-Audit - Prüfung von APIs auf Konformität und Qualität",
-  "station.api-audit.description": "Stellen Sie sicher, dass APIs vor der Veröffentlichung und Bereitstellung den geschäftlichen, gestalterischen und betrieblichen Standards entsprechen.",
-  "station.api-audit.why_it_matters": "APIs sind langlebige Produkte und müssen den Erwartungen hinsichtlich Qualität, Konsistenz und Compliance entsprechen. Das Audit verbindet Designentscheidungen, Implementierung und Betriebsbereitschaft mit definierten Standards und reduziert so Risiken vor der Bereitstellung.",
-  "station.api-audit.apply_in_work": "Richten Sie einen konsistenten Audit-Prozess ein, der die API-Bereitschaft über alle Lebenszyklusphasen hinweg anhand definierter Kriterien, Nachweise und Standards bewertet. Stellen Sie sicher, dass Lücken frühzeitig erkannt und vor der Veröffentlichung behoben werden.",
-  "station.api-audit.outcomes": "APIs erfüllen interne und externe Standards",
-  "station.api-audit.how_it_works": "Führen Sie Audits durch, um sicherzustellen, dass APIs vor der Veröffentlichung organisatorische, technische und rechtliche Standards erfüllen.",
-  "station.api-publishing.title": "API-Veröffentlichung - Veröffentlichen Sie APIs mit Zuversicht",
-  "station.api-publishing.description": "Stellen Sie APIs mit der richtigen Dokumentation und den richtigen Prozessen sicher und klar für die richtige Zielgruppe bereit.",
-  "station.api-publishing.why_it_matters": "Bei der Veröffentlichung geht es nicht nur um die Bereitstellung, sondern auch um die Auffindbarkeit, den Zugang und die Unterstützung. Wenn APIs nicht korrekt veröffentlicht werden, können sie nicht verwendet, wiederverwendet oder effektiv gesichert werden.",
-  "station.api-publishing.apply_in_work": "Ermöglichung der Veröffentlichung von APIs in der jeweiligen Umgebung mit klaren Registrierungs- und Zugriffsmechanismen (z. B. API-Schlüssel, OAuth, Abonnementpläne) je nach den API-Verbrauchersegmenten und den Sicherheits- und Compliance-Anforderungen.",
-  "station.api-publishing.outcomes": "Veröffentlichung von APIs in der richtigen Umgebung (privat, Partner, öffentlich)",
-  "station.api-publishing.how_it_works": "Veröffentlichen Sie APIs in den entsprechenden Gateways und Umgebungen, um die Wiederverwendbarkeit für mehrere API-Kunden zu unterstützen.",
-  "station.monitoring-and-improving.title": "Überwachen und Verbessern - für den API-Wert",
-  "station.monitoring-and-improving.description": "Nutzen Sie Messgrößen und Feedback, um die API-Leistung zu verfolgen und kontinuierliche Verbesserungen voranzutreiben.",
-  "station.monitoring-and-improving.why_it_matters": "Die API-Bereitstellung endet nicht mit dem Start. Ohne Überwachung können Teams weder die Akzeptanz noch die Leistung oder den ROI verbessern. Diese Station stellt sicher, dass APIs nützlich und sicher bleiben und sich mit den Geschäftsanforderungen weiterentwickeln.",
-  "station.monitoring-and-improving.apply_in_work": "Einrichtung von Analyserahmen zur Verfolgung von Leistung und Engagement. Entwickeln Sie Feedbackschleifen, Analysetools und Engagementstrategien für APIs.",
-  "station.monitoring-and-improving.outcomes": "Festlegung und Verfolgung von Leistungs- und Nutzungskennzahlen",
-  "station.monitoring-and-improving.how_it_works": "Überwachen Sie Leistungsmetriken (z. B. API-Aufrufe, Latenz, Fehlerraten) und Akzeptanzmetriken (z. B. NPS).",
+  "group.core-stations.title": "Kernstationen des Capability-Lebenszyklus",
+  "group.core-stations.description": "Die Kernstationen des APIOps-Cycles-Methodengraphen, in denen Teams lernen, wiederverwendbare Capabilities über APIs, Events, Dateien, Streams, Datenprodukte und andere Integrationsstile hinweg zu entwerfen, bereitzustellen, zu steuern und kontinuierlich zu verbessern.",
+  "group.sub-stations.title": "Unterstützende Stationen",
+  "group.sub-stations.description": "Unterstützende Stationen bieten wiederverwendbare Praktiken, Entscheidungspunkte und Ressourcen, die in verschiedenen APIOps-Cycles-Routen genutzt werden können.",
+  "station.api-product-strategy.title": "Strategie",
+  "station.api-product-strategy.description": "Beschreiben Sie den Geschäftsbedarf als wiederverwendbare Capability, bevor Sie die Umsetzungsweise festlegen.",
+  "station.api-product-strategy.why_it_matters": "Integrations- und API-Arbeit springt oft zu früh zu einem technischen Muster. Diese Station hält das Team auf Geschäftsreise, Domänenverständnis, Wert, Wiederverwendungspotenzial, Ownership und Machbarkeit fokussiert, bevor APIs, Events, Dateien, Streams, Datenprodukte oder direkte Integration gewählt werden.",
+  "station.api-product-strategy.apply_in_work": "Nutzen Sie gemeinsame Journey-, Domänen-, Wertversprechen- und Geschäftsmodell-Canvases, um technologieunabhängige Anforderungen zu erfassen und zu entscheiden, ob die Capability wiederverwendbar sein sollte.",
+  "station.api-product-strategy.outcomes": "Eine technologieunabhängige Capability Opportunity",
+  "station.api-product-strategy.how_it_works": "Analysieren Sie die Kunden- oder Partner-Journey, aus der der Capability-Bedarf entsteht, und identifizieren Sie Aufgaben, Pain Points, Gains, Inputs, Outputs und Entscheidungspunkte.",
+  "station.api-consumer-experience.title": "Nutzeranforderungen & Onboarding",
+  "station.api-consumer-experience.description": "Erfassen Sie Nutzeranforderungen, Onboarding, Standards, nicht-funktionale Anforderungen, Serviceerwartungen, Einschränkungen, Sicherheitsbedarf, Protokolle, Datenaktualität, SLAs, Observability, Wiederherstellung, Adoption und Verantwortlichkeiten der Anbieter.",
+  "station.api-consumer-experience.why_it_matters": "Die richtige Architektur hängt von Nutzerzielen, Onboarding-Erwartungen, Service Levels, Datenqualität, Änderungsverträglichkeit, Observability, Support und Anbieterrestriktionen ab.",
+  "station.api-consumer-experience.how_it_works": "Nutzen Sie das Consumer Experience Requirements Canvas, um Nutzerziele, Verfügbarkeit, Aktualität, Volumen, Performance, Datenqualität, Sicherheit, Onboarding, Änderungen, Observability und Wiederherstellungserwartungen festzuhalten.",
+  "station.api-consumer-experience.how_it_works.1": "Verwenden Sie das Customer Journey Canvas für die Customer Journey des Nutzers von der Entdeckung und Bewertung bis hin zu Onboarding, Integration, Fehlerbehebung und fortlaufender Nutzung.",
+  "station.api-consumer-experience.how_it_works.2": "Nutzen Sie die daraus resultierende Customer Journey, um Onboarding, Dokumentation, Support und Feedback-Schleifen für den Nutzer zu verbessern.",
+  "station.api-consumer-experience.apply_in_work": "Nutzen Sie Consumer-Experience- und Onboarding-Guidance, um Erwartungen für Nutzer und Anbieter explizit zu machen.",
+  "station.api-consumer-experience.outcomes": "Explizite Nutzeranforderungen und Onboarding-Erwartungen",
+  "station.api-platform-architecture.title": "Architektur & Plattformentscheidungen",
+  "station.api-platform-architecture.description": "Nutzen Sie Anforderungen und Einschränkungen, um Architektur, Plattformfähigkeiten, Governance und Betriebsmodell zu wählen.",
+  "station.api-platform-architecture.why_it_matters": "Eine wiederverwendbare Capability braucht Architekturentscheidungen, die zu Nutzeranforderungen, Sicherheitsanforderungen, Datenflüssen, Betriebsmodell und Plattformrealität passen.",
+  "station.api-platform-architecture.apply_in_work": "Nutzen Sie Architektur- und Plattformressourcen, um tragfähige Umsetzungsoptionen zu vergleichen und eine nachvollziehbare Entscheidung zu treffen.",
+  "station.api-platform-architecture.outcomes": "Validierte Architektur- und Plattformentscheidung",
+  "station.api-platform-architecture.how_it_works": "Nutzen Sie Business Impact, Capacity, Security und Architecture Decision Ressourcen, um Risiken, Constraints und Alternativen systematisch zu bewerten.",
+  "station.api-design.title": "Lösungs- & Schnittstellendesign",
+  "station.api-design.description": "Entwerfen Sie die gewählte Umsetzungsweise, den Schnittstellenvertrag, Interaktionsmuster, Datenstrukturen und Nutzungsdetails vor der Implementierung.",
+  "station.api-design.why_it_matters": "Gutes Design geht über die Benennung von Endpunkten hinaus. Es stellt sicher, dass die Schnittstelle nutzbar, konsistent, überprüfbar und auf Geschäfts- und Nutzeranforderungen zurückführbar ist.",
+  "station.api-design.apply_in_work": "Nutzen Sie passende Designressourcen für die gewählte Umsetzungsweise, z. B. REST, GraphQL, Events, Dateien, Datenprodukte oder direkte Integration.",
+  "station.api-design.outcomes": "Ein validierter Schnittstellenvertrag für die gewählte Umsetzungsweise",
+  "station.api-design.how_it_works": "Prüfen Sie Domänenobjekte, Begriffe, Regeln und Ownership, bevor Sie den Schnittstellenvertrag entwerfen.",
+  "station.api-delivery.title": "Bereitstellung & Betrieb",
+  "station.api-delivery.description": "Setzen Sie die gewählte Umsetzungsweise mit geeigneten Engineering-, Test-, Sicherheits-, Automatisierungs- und Betriebspraktiken um.",
+  "station.api-delivery.why_it_matters": "Eine wiederverwendbare Capability braucht zuverlässige Bereitstellung und Betrieb, unabhängig davon, ob sie als API, Event-Stream, Dateiaustausch, Datenprodukt oder direkte Integration umgesetzt wird.",
+  "station.api-delivery.apply_in_work": "Wenden Sie Guidance für Umsetzung, Tests, CI/CD, Betrieb und Sicherheit auf die gewählte Umsetzungsweise an.",
+  "station.api-delivery.outcomes": "Eine bereitgestellte Capability, die mit dem validierten Schnittstellenvertrag übereinstimmt",
+  "station.api-delivery.how_it_works": "Nutzen Sie Entwicklungspraktiken, um den validierten Schnittstellenvertrag mit etablierten Frameworks, Bibliotheken und Teamstandards umzusetzen.",
+  "station.api-audit.title": "Qualitäts- & Bereitschaftssicherung",
+  "station.api-audit.description": "Prüfen Sie Schnittstellenvertrag, Kontrollen, Supportmodell, Observability, Dokumentation und Lifecycle-Bereitschaft vor der Veröffentlichung.",
+  "station.api-audit.why_it_matters": "Wiederverwendbare Capabilities erzeugen operative, datenbezogene, sicherheitsrelevante, datenschutzbezogene, Compliance- und Nutzerimpact-Risiken. Bereitschaftsprüfungen reduzieren Überraschungen vor Veröffentlichung oder produktiver Nutzung.",
+  "station.api-audit.apply_in_work": "Nutzen Sie Audit- und Compliance-Ressourcen, um sicherzustellen, dass die Capability kontrolliert veröffentlicht und wiederverwendet werden kann.",
+  "station.api-audit.outcomes": "Dokumentierte Bereitschaft für Veröffentlichung und Wiederverwendung",
+  "station.api-audit.how_it_works": "Nutzen Sie Checklisten, Linters, Tests und Reviews, um Konsistenz, Standards, Sicherheit, Performance und Compliance zu prüfen.",
+  "station.api-publishing.title": "Veröffentlichung & Enablement",
+  "station.api-publishing.description": "Veröffentlichen Sie Capability-Informationen so, dass Nutzer sie finden, bewerten, Zugriff beantragen, onboarden, nutzen und Support erhalten können.",
+  "station.api-publishing.why_it_matters": "Wiederverwendbare Capabilities erzeugen nur dann Wert, wenn Nutzer sie finden, den Schnittstellenvertrag und die Serviceerwartungen verstehen, Zugriff beantragen und Support sowie Lifecycle-Ownership kennen.",
+  "station.api-publishing.apply_in_work": "Veröffentlichen Sie Ownership, Dokumentation, Onboarding, Supportkontakte, Serviceerwartungen, Lifecycle-Status und Zugriffspfade.",
+  "station.api-publishing.outcomes": "Eine auffindbare und nutzbare Capability",
+  "station.api-publishing.how_it_works": "Veröffentlichen Sie Capability-Informationen in passenden Katalogen, Portalen, Gateways oder Umgebungen, damit mehrere Nutzer die Capability wiederverwenden können.",
+  "station.monitoring-and-improving.title": "Monitoring & Verbesserung",
+  "station.monitoring-and-improving.description": "Überwachen Sie Nutzung, Zuverlässigkeit, Datenqualität, Nutzerergebnisse, Betriebskosten und Wiederverwendungsmöglichkeiten nach der Veröffentlichung.",
+  "station.monitoring-and-improving.why_it_matters": "Capabilities brauchen kontinuierliches Feedback, um zuverlässig, wertvoll, kosteneffizient und wiederverwendbar zu bleiben, wenn sich Nutzer, Systeme, Daten und Plattformen ändern.",
+  "station.monitoring-and-improving.apply_in_work": "Nutzen Sie Metriken, Analytics und Feedbackpraktiken, um die Capability kontinuierlich zu verbessern.",
+  "station.monitoring-and-improving.outcomes": "Gemessene Capability-Gesundheit und Wertbeitrag",
+  "station.monitoring-and-improving.how_it_works": "Definieren Sie Metriken für Nutzung, Zuverlässigkeit, Datenqualität, Kosten, Adoption und Nutzerwert.",
   "station.user-experience.title": "Benutzerfreundlichkeit - Entwerfen Sie APIs mit dem Benutzer im Hinterkopf",
   "station.user-experience.description": "Stellen Sie sicher, dass die APIs mit Blick auf den Endnutzer entwickelt werden und eine nahtlose und intuitive Erfahrung bieten.",
-  "station.user-experience.why_it_matters": "APIs sind nicht nur technische Produkte, sondern auch Produkte für die Benutzer. Ein schlechtes Benutzererlebnis kann zu geringer Akzeptanz und Frustration führen. Diese Station hilft Teams bei der Entwicklung von APIs, die benutzerfreundlich sind und die Bedürfnisse der Verbraucher erfüllen.",
+  "station.user-experience.why_it_matters": "APIs sind nicht nur technische Produkte, sondern auch Produkte für die Benutzer. Ein schlechtes Benutzererlebnis kann zu geringer Akzeptanz und Frustration führen. Diese Station hilft Teams bei der Entwicklung von APIs, die benutzerfreundlich sind und die Bedürfnisse der Nutzer erfüllen.",
   "station.user-experience.apply_in_work": "Bereitstellung von Richtlinien, Vorlagen und Tools für die Benutzererfahrung beim API-Design. Sicherstellen, dass die Teams nutzerzentrierte Designpraktiken befolgen und Nutzerfeedback in API-Iterationen einbeziehen.",
   "station.user-experience.outcomes": "APIs, die auf die Bedürfnisse der Nutzer abgestimmt sind",
   "station.user-experience.how_it_works": "Verwendung von User Personas, um die Bedürfnisse und Erwartungen der Endnutzer zu verstehen",
@@ -108,17 +108,17 @@
   "station.design-standards.outcomes": "Einheitliches API-Design in der gesamten Organisation",
   "station.design-standards.how_it_works": "Definition von Designstandards und Richtlinien für das API-Design, einschließlich Benennungskonventionen, Antwortformaten und Fehlerbehandlung.",
   "station.vendor-management.title": "Vendor Management - Verwalten von API-Integrationen von Drittanbietern",
-  "station.vendor-management.description": "Effiziente Verwaltung von Drittanbieter-APIs und Integrationen zur Gewährleistung von Zuverlässigkeit und Konformität.",
-  "station.vendor-management.why_it_matters": "APIs von Drittanbietern können Risiken und Abhängigkeiten mit sich bringen, die sich auf Ihr API-Ökosystem auswirken. Diese Station enthält Richtlinien für die Verwaltung von Anbieterbeziehungen, die Zuverlässigkeit, Konformität und Übereinstimmung mit Ihrer API-Strategie sicherstellen.",
-  "station.vendor-management.apply_in_work": "Bereitstellung von Rahmenwerken für die Anbieterverwaltung, Bewertungskriterien und Überwachungsinstrumenten. Sicherstellen, dass die Teams API-Anbieter von Drittanbietern effektiv verwalten, um Zuverlässigkeit, Konformität und Übereinstimmung mit den Unternehmensstandards zu gewährleisten.",
+  "station.vendor-management.description": "Effiziente Verwaltung von Drittanbieter-APIs und Integrationen zur Gewährleistung von Zuverlässigkeit und Compliance.",
+  "station.vendor-management.why_it_matters": "APIs von Drittanbietern können Risiken und Abhängigkeiten mit sich bringen, die sich auf Ihr API-Ökosystem auswirken. Diese Station enthält Richtlinien für die Verwaltung von Anbieterbeziehungen, die Zuverlässigkeit, Compliance und Übereinstimmung mit Ihrer API-Strategie sicherstellen.",
+  "station.vendor-management.apply_in_work": "Bereitstellung von Rahmenwerken für die Anbieterverwaltung, Bewertungskriterien und Überwachungsinstrumenten. Sicherstellen, dass die Teams API-Anbieter von Drittanbietern effektiv verwalten, um Zuverlässigkeit, Compliance und Übereinstimmung mit den Unternehmensstandards zu gewährleisten.",
   "station.vendor-management.outcomes": "Effektive Prozesse für das Lieferantenmanagement eingeführt",
   "station.vendor-management.how_it_works": "Einführung von Prozessen für das Anbietermanagement, um Drittanbieter von APIs zu bewerten, einzubinden und zu überwachen.",
-  "station.contract-design.title": "Vertragsgestaltung - Definieren Sie klare API-Verträge",
-  "station.contract-design.description": "Erstellen Sie klare und genau definierte API-Verträge, die Erwartungen, Verantwortlichkeiten und Nutzungsrichtlinien umreißen.",
-  "station.contract-design.why_it_matters": "API-Verträge sind wichtig, um Klarheit und Übereinstimmung zwischen API-Anbietern und Kunden zu gewährleisten. Diese Station bietet Richtlinien für die Gestaltung von API-Verträgen, die klar, umfassend und leicht verständlich sind.",
-  "station.contract-design.apply_in_work": "Bereitstellung von Vertragsentwurfsvorlagen, standardisierten Formaten und Überprüfungsprozessen. Sicherstellen, dass Teams klare und gut definierte API-Verträge erstellen, die Erwartungen, Verantwortlichkeiten und Nutzungsrichtlinien umreißen.",
-  "station.contract-design.outcomes": "Klare API-Verträge für jede API definiert",
-  "station.contract-design.how_it_works": "Definieren Sie API-Verträge, in denen die Erwartungen, Verantwortlichkeiten und Nutzungsrichtlinien für jede API festgelegt sind.",
+  "station.contract-design.title": "Vertragsgestaltung - Definieren Sie klare Schnittstellenverträge",
+  "station.contract-design.description": "Erstellen Sie klare und genau definierte Schnittstellenverträge, die Erwartungen, Verantwortlichkeiten und Nutzungsrichtlinien umreißen.",
+  "station.contract-design.why_it_matters": "Schnittstellenverträge sind wichtig, um Klarheit und Übereinstimmung zwischen API-Anbietern und Kunden zu gewährleisten. Diese Station bietet Richtlinien für die Gestaltung von Schnittstellenverträgen, die klar, umfassend und leicht verständlich sind.",
+  "station.contract-design.apply_in_work": "Bereitstellung von Vertragsentwurfsvorlagen, standardisierten Formaten und Überprüfungsprozessen. Sicherstellen, dass Teams klare und gut definierte Schnittstellenverträge erstellen, die Erwartungen, Verantwortlichkeiten und Nutzungsrichtlinien umreißen.",
+  "station.contract-design.outcomes": "Klare Schnittstellenverträge für jede API definiert",
+  "station.contract-design.how_it_works": "Definieren Sie Schnittstellenverträge, in denen die Erwartungen, Verantwortlichkeiten und Nutzungsrichtlinien für jede API festgelegt sind.",
   "station.development.title": "Entwicklung - Erstellen von APIs mit bewährten Praktiken",
   "station.development.description": "Implementierung von APIs unter Verwendung von Best Practices und Frameworks zur Gewährleistung von Qualität, Wartbarkeit und Skalierbarkeit.",
   "station.development.why_it_matters": "Die API-Entwicklung ist eine entscheidende Phase, die die Qualität und Zuverlässigkeit der API bestimmt. Diese Station bietet Best Practices und Frameworks für die API-Entwicklung, die sicherstellen, dass APIs nach hohen Standards erstellt werden und effektiv gewartet und skaliert werden können.",
@@ -149,12 +149,12 @@
   "station.service-agreements.apply_in_work": "Bereitstellung von Vorlagen für Servicevereinbarungen, standardisierten Formaten und Überprüfungsprozessen. Stellen Sie sicher, dass die Teams klare und genau definierte Servicevereinbarungen erstellen, in denen die Erwartungen, Servicelevel und Verantwortlichkeiten für API-Anbieter und -Kunden festgelegt sind.",
   "station.service-agreements.outcomes": "Klare Dienstvereinbarungen für jede API definiert",
   "station.service-agreements.how_it_works": "Definieren Sie Servicevereinbarungen, in denen die Erwartungen, Servicelevel und Verantwortlichkeiten für jede API festgelegt sind.",
-  "station.api-consumer-adoption.title": "API-Verbraucherakzeptanz - Förderung der API-Nutzung",
-  "station.api-consumer-adoption.description": "Implementierung von Strategien zur Förderung der Akzeptanz und des Engagements von API-Kunden, um sicherzustellen, dass APIs effektiv genutzt werden.",
-  "station.api-consumer-adoption.why_it_matters": "Die Förderung der Akzeptanz von APIs durch die Verbraucher ist entscheidend für die Realisierung des Werts von APIs. Diese Station bietet Strategien und Best Practices für die Einbindung von API-Nutzern, um sicherzustellen, dass sie verstehen, wie APIs effektiv genutzt werden können und einen Nutzen aus ihnen ziehen.",
-  "station.api-consumer-adoption.apply_in_work": "Bereitstellung von Onboarding-Ressourcen, Lehrmaterial und Strategien zur Einbindung von API-Kunden. Sicherstellen, dass die Teams Strategien umsetzen, die die Akzeptanz, das Engagement und die Zufriedenheit der API-Kunden fördern.",
-  "station.api-consumer-adoption.outcomes": "Strategien zur Übernahme von API durch die Verbraucher umgesetzt",
-  "station.api-consumer-adoption.how_it_works": "Entwicklung von Onboarding-Prozessen und -Ressourcen, damit API-Kunden verstehen, wie sie APIs effektiv nutzen können.",
+  "station.api-consumer-adoption.title": "Nutzerakzeptanz - Förderung der API-Nutzung",
+  "station.api-consumer-adoption.description": "Implementierung von Strategien zur Förderung der Akzeptanz und des Engagements von Nutzer, um sicherzustellen, dass APIs effektiv genutzt werden.",
+  "station.api-consumer-adoption.why_it_matters": "Die Förderung der Akzeptanz von APIs durch die Nutzer ist entscheidend für die Realisierung des Werts von APIs. Diese Station bietet Strategien und Best Practices für die Einbindung von Nutzern, um sicherzustellen, dass sie verstehen, wie APIs effektiv genutzt werden können und einen Nutzen aus ihnen ziehen.",
+  "station.api-consumer-adoption.apply_in_work": "Bereitstellung von Onboarding-Ressourcen, Lehrmaterial und Strategien zur Einbindung von Nutzer. Sicherstellen, dass die Teams Strategien umsetzen, die die Akzeptanz, das Engagement und die Zufriedenheit der Nutzer fördern.",
+  "station.api-consumer-adoption.outcomes": "Strategien zur Übernahme von API durch die Nutzer umgesetzt",
+  "station.api-consumer-adoption.how_it_works": "Entwicklung von Onboarding-Prozessen und -Ressourcen, damit Nutzer verstehen, wie sie APIs effektiv nutzen können.",
   "station.api-promotion.title": "API-Promotion - Erhöhen Sie die Sichtbarkeit und Nutzung von APIs",
   "station.api-promotion.description": "Förderung von APIs, um die Sichtbarkeit, Nutzung und Akzeptanz bei den Zielgruppen zu erhöhen.",
   "station.api-promotion.why_it_matters": "Die Förderung von APIs ist wichtig, um ihre Sichtbarkeit zu erhöhen und ihre Nutzung zu fördern. Diese Station bietet Strategien und Best Practices für eine effektive Werbung für APIs bei den Zielgruppen, um sicherzustellen, dass diese die APIs kennen und ihren Wert verstehen.",
@@ -206,44 +206,44 @@
   "station.api-product-strategy.outcomes.1": "Gemeinsame Sprache zwischen Produkt, Design und Technik",
   "station.api-product-strategy.outcomes.2": "Ein solides Argument für die Finanzierung/Bewilligung",
   "station.api-product-strategy.how_it_works.1": "Definieren Sie zentrale Entitäten, ihre Attribute und Beziehungen, um ein gemeinsames konzeptionelles Verständnis für alle Journeys und eventuell APIs zu schaffen.",
-  "station.api-product-strategy.how_it_works.2": "Verwenden Sie das API Value Proposition Canvas, um die unterstützten Geschäftsaufgaben sowie die Probleme, Vorteile und Funktionen für API-Nutzer zu erfassen, die neue oder wiederverwendbare APIs prägen.",
-  "station.api-product-strategy.how_it_works.3": "Definieren Sie den Wert - für die Nutzer und das Unternehmen - mit dem API Business Model Canvas, um Ihre API-Strategie visuell, gemeinsam nutzbar und einfach mit Ihren API-Kunden an der nächsten Station zu validieren.",
+  "station.api-product-strategy.how_it_works.2": "Verwenden Sie das API Value Proposition Canvas, um die unterstützten Geschäftsaufgaben sowie die Probleme, Vorteile und Funktionen für Nutzer zu erfassen, die neue oder wiederverwendbare APIs prägen.",
+  "station.api-product-strategy.how_it_works.3": "Definieren Sie den Wert - für die Nutzer und das Unternehmen - mit dem API Business Model Canvas, um Ihre API-Strategie visuell, gemeinsam nutzbar und einfach mit Ihren Nutzer an der nächsten Station zu validieren.",
   "station.api-consumer-experience.outcomes.1": "Definieren Sie die API-Erlebnisreise",
   "station.api-consumer-experience.outcomes.2": "Onboarding, Dokumentation und Feedback planen",
   "station.api-consumer-experience.outcomes.3": "Verbesserung der Akzeptanz durch echte Empathie + Developer Experience (DX)",
   "station.api-platform-architecture.outcomes.1": "Umsetzung einer einheitlichen Governance ohne starke Kontrolle von oben nach unten",
   "station.api-platform-architecture.outcomes.2": "Design für interne Wiederverwendung und externe Skalierbarkeit",
-  "station.api-platform-architecture.how_it_works.1": "Kartierung der Standorte von API-Anbietern und -Verbrauchern, um die Zugänglichkeit und Einhaltung von Vorschriften zu gewährleisten.",
+  "station.api-platform-architecture.how_it_works.1": "Kartierung der Standorte von API-Anbietern und -Nutzern, um die Zugänglichkeit und Einhaltung von Vorschriften zu gewährleisten.",
   "station.api-platform-architecture.how_it_works.2": "Das Capacity Canvas gleicht geschäftliche Transaktionsmuster, künftige Verbrauchstrends und technische Lösungen ab, um die Skalierbarkeit und Leistung von APIs zu gewährleisten und liefert wichtige Informationen für Skalierungsentscheidungen und die Infrastrukturplanung.",
   "station.api-platform-architecture.how_it_works.3": "Definieren und überwachen Sie Leistungsmetriken (z. B. API-Aufrufe, Latenz, Fehlerraten) und Adoptionsmetriken (z. B. NPS).",
-  "station.api-design.outcomes.1": "Wiederverwendbare und validierte API-Verträge",
+  "station.api-design.outcomes.1": "Wiederverwendbare und validierte Schnittstellenverträge",
   "station.api-design.outcomes.2": "Entwürfe, die auf Domänenmodelle und Interaktionsmuster abgestimmt sind",
   "station.api-design.outcomes.3": "Rückverfolgbarkeit des Designs zum Geschäftswert",
-  "station.api-design.how_it_works.1": "Verwenden Sie das Interaction Canvas, um zu definieren, wie die Verbraucher mit der API interagieren werden, um sicherzustellen, dass sie ihren Bedürfnissen und Erwartungen entspricht.",
-  "station.api-design.how_it_works.2": "Wenden Sie REST-Entwurfsmuster an, um konsistente, wiederverwendbare API-Verträge zu erstellen, die mit den Beteiligten validiert werden.",
-  "station.api-design.how_it_works.3": "Wenden Sie ereignisgesteuerte Entwurfsmuster an, um konsistente, wiederverwendbare API-Verträge zu erstellen, die mit den Beteiligten validiert werden.",
-  "station.api-design.how_it_works.4": "Wenden Sie GraphQL-Designmuster an, um konsistente, wiederverwendbare API-Verträge zu erstellen, die mit den Beteiligten validiert werden.",
+  "station.api-design.how_it_works.1": "Verwenden Sie das Interaction Canvas, um zu definieren, wie die Nutzer mit der API interagieren werden, um sicherzustellen, dass sie ihren Bedürfnissen und Erwartungen entspricht.",
+  "station.api-design.how_it_works.2": "Wenden Sie REST-Entwurfsmuster an, um konsistente, wiederverwendbare Schnittstellenverträge zu erstellen, die mit den Beteiligten validiert werden.",
+  "station.api-design.how_it_works.3": "Wenden Sie ereignisgesteuerte Entwurfsmuster an, um konsistente, wiederverwendbare Schnittstellenverträge zu erstellen, die mit den Beteiligten validiert werden.",
+  "station.api-design.how_it_works.4": "Wenden Sie GraphQL-Designmuster an, um konsistente, wiederverwendbare Schnittstellenverträge zu erstellen, die mit den Beteiligten validiert werden.",
   "station.api-design.how_it_works.5": "Nutzen Sie die Designprinzipien und den API-Styleguide, um Ihre Designentscheidungen an gemeinsamen Regeln auszurichten und eine konsistente Audit-Validierung zu ermöglichen.",
-  "station.api-design.how_it_works.6": "Wenden Sie Contract-First- oder Design-First-Ansätze an, um den API-Vertrag vor der Implementierung zu erfassen und zu validieren.",
+  "station.api-design.how_it_works.6": "Wenden Sie Contract-First- oder Design-First-Ansätze an, um den Schnittstellenvertrag vor der Implementierung zu erfassen und zu validieren.",
   "station.api-design.how_it_works.7": "Verwenden Sie die API-Audit-Checkliste, um sicherzustellen, dass das API-Design funktionale und nicht-funktionale Anforderungen erfüllt, einschließlich Sicherheit, Leistung und Compliance.",
   "station.api-delivery.outcomes.1": "Zuverlässige und automatisierte CI/CD-Pipelines",
   "station.api-delivery.outcomes.2": "Funktionale und nicht-funktionale Tests integriert",
-  "station.api-delivery.outcomes.3": "Sichere und gesetzeskonforme Zustellungspipelines",
+  "station.api-delivery.outcomes.3": "Sichere und gesetzeskonforme Bereitstellungspipelines",
   "station.api-delivery.how_it_works.1": "Erstellen Sie die API-Implementierung auf Basis des validierten Vertrags unter Verwendung etablierter Frameworks, Bibliotheken und Teamstandards.",
   "station.api-delivery.how_it_works.2": "Testen Sie APIs auf Funktionalität, Sicherheit und Leistung mit automatisierten Testwerkzeugen.",
   "station.api-delivery.how_it_works.3": "Verwenden Sie CI/CD-Pipelines, um Build-, Test- und Bereitstellungsprozesse zu automatisieren und so konsistente Qualität und Nachvollziehbarkeit zu gewährleisten.",
   "station.api-delivery.how_it_works.4": "Stellen Sie sicher, dass APIs die Sicherheits- und Compliance-Anforderungen durch automatische Prüfungen und Audits erfüllen.",
   "station.api-delivery.how_it_works.5": "Verwenden Sie die API-Audit-Checkliste, um sicherzustellen, dass die API die funktionalen und nicht-funktionalen Anforderungen erfüllt, einschließlich Sicherheit, Leistung und Compliance.",
   "station.api-audit.outcomes.1": "Klare Dokumentation des API-Designs und der Implementierungsentscheidungen",
-  "station.api-audit.outcomes.2": "Sicherheit, Leistung und Konformität validiert",
+  "station.api-audit.outcomes.2": "Sicherheit, Leistung und Compliance validiert",
   "station.api-audit.outcomes.3": "Geringeres Risiko von Problemen in der Produktion",
-  "station.api-audit.how_it_works.1": "Verwenden Sie Checklisten, Linters und Testwerkzeuge, um die Konsistenz und Konformität mit den Standards zu überprüfen.",
+  "station.api-audit.how_it_works.1": "Verwenden Sie Checklisten, Linters und Testwerkzeuge, um die Konsistenz und Compliance mit den Standards zu überprüfen.",
   "station.api-audit.how_it_works.2": "Zusammenarbeit mit Governance-Teams und Domänenexperten, um sicherzustellen, dass APIs für die Produktion bereit sind.",
   "station.api-publishing.outcomes.1": "Klare API-Einführungs- und Registrierungsprozesse",
   "station.api-publishing.outcomes.2": "Dokumentation, Sicherheitsmodelle und Richtlinien verfügbar",
   "station.api-publishing.outcomes.3": "APIs bereit für Skalierung und Governance",
-  "station.api-publishing.how_it_works.1": "Dokumentieren Sie, wie die Verbraucher die API finden und nutzen, einschließlich Onboarding-Prozesse und Registrierung.",
-  "station.api-publishing.how_it_works.2": "Stellen Sie sicher, dass die Sicherheitsmodelle, die Gateway-Konfiguration und die rechtlichen Bestimmungen für die Verbraucher klar und verständlich sind.",
+  "station.api-publishing.how_it_works.1": "Dokumentieren Sie, wie die Nutzer die API finden und nutzen, einschließlich Onboarding-Prozesse und Registrierung.",
+  "station.api-publishing.how_it_works.2": "Stellen Sie sicher, dass die Sicherheitsmodelle, die Gateway-Konfiguration und die rechtlichen Bestimmungen für die Nutzer klar und verständlich sind.",
   "station.monitoring-and-improving.outcomes.1": "Feedback-Schleifen für Entwickler sind vorhanden",
   "station.monitoring-and-improving.outcomes.2": "Kontinuierlich ermittelte und behandelte Probleme",
   "station.monitoring-and-improving.outcomes.3": "Iteration der API, abgestimmt auf die Bedürfnisse der Nutzer",
@@ -252,7 +252,7 @@
   "station.user-experience.outcomes.1": "Intuitive und einheitliche Benutzeroberflächen",
   "station.user-experience.outcomes.2": "Nutzer-Feedback in API-Design integriert",
   "station.user-experience.outcomes.3": "Verbesserte Nutzerzufriedenheit und Akzeptanz",
-  "station.user-experience.how_it_works.1": "Führen Sie Nutzerforschung durch, um Erkenntnisse darüber zu gewinnen, wie die Verbraucher mit den Ökosystemdiensten oder Ihren API nutzenden Anwendungen interagieren.",
+  "station.user-experience.how_it_works.1": "Führen Sie Nutzerforschung durch, um Erkenntnisse darüber zu gewinnen, wie die Nutzer mit den Ökosystemdiensten oder Ihren API nutzenden Anwendungen interagieren.",
   "station.user-experience.how_it_works.2": "Dokumentieren Sie die Anforderungen an die Benutzererfahrung, damit sie beim API-Design verwendet werden können, um sicherzustellen, dass sie intuitiv und einfach zu bedienen sind.",
   "station.market-insights.outcomes.1": "Ermittlung von Industriestandards und bewährten Verfahren",
   "station.market-insights.outcomes.2": "API-Strategie auf die Bedürfnisse des Marktes abgestimmt",
@@ -283,7 +283,7 @@
   "station.legal-and-compliance.outcomes.2": "Ermittelte und abgemilderte rechtliche Risiken",
   "station.legal-and-compliance.outcomes.3": "Klare Dokumentation der Compliance-Maßnahmen",
   "station.legal-and-compliance.how_it_works.1": "Implementieren Sie Maßnahmen, die sicherstellen, dass APIs diese Anforderungen erfüllen, einschließlich Datenverschlüsselung, Zugriffskontrollen und Prüfpfade.",
-  "station.legal-and-compliance.how_it_works.2": "Dokumentieren Sie die Maßnahmen zur Einhaltung der Vorschriften und stellen Sie sicher, dass sie den Beteiligten und Verbrauchern mitgeteilt werden.",
+  "station.legal-and-compliance.how_it_works.2": "Dokumentieren Sie die Maßnahmen zur Einhaltung der Vorschriften und stellen Sie sicher, dass sie den Beteiligten und Nutzern mitgeteilt werden.",
   "station.security-and-privacy.outcomes.1": "Schutz der Nutzerdaten durch Maßnahmen zum Schutz der Privatsphäre",
   "station.security-and-privacy.outcomes.2": "Bewährte Sicherheitspraktiken bei der Gestaltung und Entwicklung von APIs",
   "station.security-and-privacy.outcomes.3": "Einhaltung von Sicherheitsstandards und -vorschriften",
@@ -299,15 +299,15 @@
   "station.vendor-management.outcomes.3": "Geringere Risiken im Zusammenhang mit Abhängigkeiten von Dritten",
   "station.vendor-management.how_it_works.1": "Definieren Sie Kriterien für die Bewertung von Anbieter-APIs, einschließlich Zuverlässigkeit, Sicherheit und Compliance.",
   "station.vendor-management.how_it_works.2": "Überwachung der Leistung von Anbietern und der Einhaltung von Service Level Agreements (SLAs) und Organisationsstandards.",
-  "station.contract-design.outcomes.1": "Umriss der Erwartungen und Verantwortlichkeiten von API-Anbietern und Verbrauchern",
+  "station.contract-design.outcomes.1": "Umriss der Erwartungen und Verantwortlichkeiten von API-Anbietern und Nutzern",
   "station.contract-design.outcomes.2": "Dokumentierte Verwendungsrichtlinien und bewährte Verfahren",
   "station.contract-design.outcomes.3": "Weniger Missverständnisse und Streitigkeiten über die API-Nutzung",
-  "station.contract-design.how_it_works.1": "Verwenden Sie standardisierte Formate (z. B. OpenAPI, AsyncAPI), um maschinenlesbare API-Verträge zu erstellen, die sich leicht austauschen und validieren lassen.",
-  "station.contract-design.how_it_works.2": "Sicherstellen, dass die API-Verträge von den Beteiligten geprüft und genehmigt werden, um Übereinstimmung und Klarheit zu gewährleisten.",
+  "station.contract-design.how_it_works.1": "Verwenden Sie standardisierte Formate (z. B. OpenAPI, AsyncAPI), um maschinenlesbare Schnittstellenverträge zu erstellen, die sich leicht austauschen und validieren lassen.",
+  "station.contract-design.how_it_works.2": "Sicherstellen, dass die Schnittstellenverträge von den Beteiligten geprüft und genehmigt werden, um Übereinstimmung und Klarheit zu gewährleisten.",
   "station.development.outcomes.1": "Hochwertige, wartbare und skalierbare APIs",
   "station.development.outcomes.2": "Befolgung einheitlicher Kodierungsstandards und -praktiken",
   "station.development.outcomes.3": "Geringere Entwicklungszeit und weniger technische Schulden",
-  "station.development.how_it_works.1": "Wenden Sie Contract-First- oder Design-First-Ansätze an, um sicherzustellen, dass API-Verträge vor der Implementierung validiert werden.",
+  "station.development.how_it_works.1": "Wenden Sie Contract-First- oder Design-First-Ansätze an, um sicherzustellen, dass Schnittstellenverträge vor der Implementierung validiert werden.",
   "station.development.how_it_works.2": "Befolgen Sie Kodierungsstandards und bewährte Verfahren, um eine konsistente und hochwertige API-Entwicklung zu gewährleisten.",
   "station.ci-cd.outcomes.1": "Konsistente Qualität und Rückverfolgbarkeit bei der API-Lieferung",
   "station.ci-cd.outcomes.2": "Schnellere Iterationen und kürzere Markteinführungszeiten",
@@ -324,19 +324,19 @@
   "station.release-management.outcomes.3": "Geringere Risiken im Zusammenhang mit API-Änderungen",
   "station.release-management.how_it_works.1": "Implementierung von Bereitstellungsstrategien (z. B. blau-grüne Bereitstellungen, Canary-Releases) zur Minimierung der Risiken bei API-Releases.",
   "station.release-management.how_it_works.2": "Einführung von Rollback-Verfahren zur schnellen Rückgängigmachung von Änderungen im Falle von Problemen bei API-Releases.",
-  "station.service-agreements.outcomes.1": "Erwartungen und Dienstleistungsniveaus für API-Anbieter und Verbraucher",
+  "station.service-agreements.outcomes.1": "Erwartungen und Dienstleistungsniveaus für API-Anbieter und Nutzer",
   "station.service-agreements.outcomes.2": "Zuständigkeiten und Unterstützungsprozesse dokumentiert",
   "station.service-agreements.outcomes.3": "Verbesserte Kommunikation und Zusammenarbeit zwischen API-Teams",
   "station.service-agreements.how_it_works.1": "Verwenden Sie standardisierte Formate, um maschinenlesbare Servicevereinbarungen zu erstellen, die sich leicht austauschen und validieren lassen.",
   "station.service-agreements.how_it_works.2": "Sicherstellen, dass die Dienstleistungsvereinbarungen von den Beteiligten überprüft und genehmigt werden, um die Übereinstimmung und Klarheit zu gewährleisten.",
   "station.api-consumer-adoption.outcomes.1": "Erhöhte API-Nutzung und Engagement",
-  "station.api-consumer-adoption.outcomes.2": "API-Kunden werden über die Funktionen und Vorteile von APIs aufgeklärt",
-  "station.api-consumer-adoption.outcomes.3": "Verbesserte Zufriedenheit und Loyalität der API-Kunden",
+  "station.api-consumer-adoption.outcomes.2": "Nutzer werden über die Funktionen und Vorteile von APIs aufgeklärt",
+  "station.api-consumer-adoption.outcomes.3": "Verbesserte Zufriedenheit und Loyalität der Nutzer",
   "station.api-consumer-adoption.how_it_works.1": "Erstellung von Lehrmaterial (z. B. Tutorials, Dokumentation), das die Funktionen, Vorteile und Nutzungsmuster der API erläutert.",
   "station.api-consumer-adoption.how_it_works.2": "Engagieren Sie sich mit API-Benutzern über Feedbackschleifen, Support-Kanäle und Community-Foren, um ihre Bedürfnisse zu verstehen und die API-Akzeptanz zu verbessern.",
   "station.api-promotion.outcomes.1": "Erhöhte Sichtbarkeit und Bekanntheit von API",
   "station.api-promotion.outcomes.2": "Höhere API-Nutzungs- und Akzeptanzraten",
-  "station.api-promotion.outcomes.3": "Verbesserte API-Kundenbindung und -zufriedenheit",
+  "station.api-promotion.outcomes.3": "Verbesserte Nutzerbindung und -zufriedenheit",
   "station.api-promotion.how_it_works.1": "Erstellen Sie Werbematerialien (z. B. Fallstudien, Erfolgsgeschichten), die den Wert und die Vorteile von APIs hervorheben.",
   "station.api-promotion.how_it_works.2": "Engagieren Sie sich in API-Gemeinschaften und Foren, um API-Aktualisierungen weiterzugeben, Feedback zu sammeln und die API-Nutzung zu fördern.",
   "station.partner-integration.outcomes.1": "Verbesserte API-Funktionen durch Partner-APIs",
@@ -357,8 +357,6 @@
   "station.upskilling.outcomes.1": "Erhöhte Kompetenz bei der Konzeption, Entwicklung und Verwaltung von APIs",
   "station.upskilling.outcomes.2": "Verbesserte Fähigkeit zur Übernahme neuer Technologien und Verfahren",
   "station.upskilling.outcomes.3": "Befähigte Teams zur Förderung von API-Innovation und -Qualität",
-  "station.upskilling.how_it_works.1": "Bereitstellung von Schulungsprogrammen, Workshops und Ressourcen, um Teams bei der Verbesserung ihrer API-Fähigkeiten und -Kenntnisse zu unterstützen.",
-  "station.upskilling.how_it_works.2": "Fördern Sie kontinuierliches Lernen durch Online-Kurse, Zertifizierungen und Engagement in der Gemeinschaft.",
   "station.operating-guidelines.outcomes.1": "Konsistente API-Verwaltung und -Qualität im gesamten Unternehmen",
   "station.operating-guidelines.outcomes.2": "Einhaltung von Organisationsstandards und bewährten Verfahren",
   "station.operating-guidelines.outcomes.3": "Verbesserte Sichtbarkeit und Kontrolle über API-Initiativen",
@@ -367,11 +365,103 @@
   "station.portfolio-management.outcomes.1": "APIs im Einklang mit Unternehmenszielen und strategischen Initiativen",
   "station.portfolio-management.outcomes.2": "Priorisierung und Optimierung von APIs auf der Grundlage von Wert und Wirkung",
   "station.portfolio-management.outcomes.3": "Verbesserte Sichtbarkeit und Kontrolle über das API-Portfolio",
-  "station.portfolio-management.how_it_works.1": "Festlegung von Kriterien für die Bewertung und Priorisierung von APIs auf der Grundlage des Geschäftswerts, der Auswirkungen und der Ausrichtung auf strategische Initiativen.",
-  "station.portfolio-management.how_it_works.2": "Überwachen Sie das API-Portfolio, um sicherzustellen, dass die APIs einen Mehrwert liefern, die Leistungserwartungen erfüllen und mit den Geschäftszielen übereinstimmen.",
   "station.budget-and-resource-management.outcomes.1": "Effiziente Zuweisung von Ressourcen für API-Initiativen",
   "station.budget-and-resource-management.outcomes.2": "Optimierte Investitionen in die API-Entwicklung und -Verwaltung",
   "station.budget-and-resource-management.outcomes.3": "Verbesserte finanzielle Transparenz und Kontrolle über API-Initiativen",
-  "station.budget-and-resource-management.how_it_works.1": "Festlegung von Kriterien für die Bewertung und Priorisierung von Budgetzuweisungen auf der Grundlage des Geschäftswerts, der Auswirkungen und der Ausrichtung auf strategische Initiativen.",
-  "station.budget-and-resource-management.how_it_works.2": "Überwachung des Budgets und der Ressourcennutzung, um effektive Investitionen und Ressourcenzuweisung für API-Initiativen sicherzustellen."
+  "cycle.api-productization-cycle.station.api-product-strategy.title": "API-Produktstrategie - APIs in strategische Produkte verwandeln",
+  "cycle.api-productization-cycle.station.api-product-strategy.description": "Bevor Sie etwas bauen, sollten Sie von Anfang an den Wert, die Benutzer und die Geschäftsziele Ihrer API definieren.",
+  "cycle.api-productization-cycle.station.api-product-strategy.why_it_matters": "Viele Unternehmen betrachten APIs als technische Projekte und nicht als Produkte. Das Ergebnis? Verwirrte Kunden, schlechte Akzeptanz und verschwendeter Aufwand.\n\nDiese Station hilft Ihnen, den Zweck Ihrer API, die Zielgruppe und die Erfolgskriterien zu definieren, damit Teams APIs bereitstellen können, die echte Probleme lösen.",
+  "cycle.api-productization-cycle.station.api-product-strategy.apply_in_work": "Bereitstellung von Richtlinien und Vorlagen für die Erstellung von API-Geschäftsmodellen, Wertvorschlägen und Roadmaps.",
+  "cycle.api-productization-cycle.station.api-product-strategy.outcomes": "Ein klares API-Wertversprechen und eine klare Zielgruppe",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works": "Untersuchen Sie das Kunden- oder Partnerproblem, das Sie mit APIs lösen wollen. Zeichnen Sie die Stakeholder, deren Wege und Ergebnisse mithilfe der Customer Journey Canvas auf.",
+  "cycle.api-productization-cycle.station.api-product-strategy.outcomes.1": "Gemeinsame Sprache zwischen Produkt, Design und Technik",
+  "cycle.api-productization-cycle.station.api-product-strategy.outcomes.2": "Ein solides Argument für die Finanzierung/Bewilligung",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works.1": "Definieren Sie zentrale Entitäten, ihre Attribute und Beziehungen, um ein gemeinsames konzeptionelles Verständnis für alle Journeys und eventuell APIs zu schaffen.",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works.2": "Verwenden Sie das API Value Proposition Canvas, um die unterstützten Geschäftsaufgaben sowie die Probleme, Vorteile und Funktionen für Nutzer zu erfassen, die neue oder wiederverwendbare APIs prägen.",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works.3": "Definieren Sie den Wert - für die Nutzer und das Unternehmen - mit dem API Business Model Canvas, um Ihre API-Strategie visuell, gemeinsam nutzbar und einfach mit Ihren Nutzer an der nächsten Station zu validieren.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.title": "API Consumer Experience - Design für die echten Benutzer Ihrer API",
+  "cycle.api-productization-cycle.station.api-consumer-experience.description": "Stellen Sie sicher, dass Ihre API auffindbar, verständlich und nutzbar ist - vor und nach der Einführung.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.why_it_matters": "Großartige APIs funktionieren nicht nur - sie fühlen sich auch intuitiv an. Ganz gleich, ob Ihr Kunde ein interner Entwickler, ein externer Partner oder ein KI-Agent ist, seine Erfahrung entscheidet über die Akzeptanz.\n\nOhne einen klaren Erlebnisplan:\n- Großartige APIs bleiben ungenutzt\n- Teams verschwenden Zeit damit, zu raten, wie sie Ihre API verwenden sollen\n- Feedbackschleifen sind unterbrochen oder fehlen.\n\nDiese Station hilft Ihnen, Ihre API mit den Augen ihrer Nutzer zu sehen.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.how_it_works": "Überprüfen Sie das bestehende API Value Proposition Canvаs von der Perspektive des Nutzers. Stellen Sie die Stabilität der unterstützten Geschäftsprozesse sicher und ergänzen Sie die Funktionen, die Probleme lösen und Vorteile bieten, um die Bedürfnisse der Nutzer zu berücksichtigen, damit diese spätere Designentscheidungen leiten können.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.how_it_works.1": "Verwenden Sie das Customer Journey Canvas für die Customer Journey des Nutzers von der Entdeckung und Bewertung bis hin zu Onboarding, Integration, Fehlerbehebung und fortlaufender Nutzung.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.how_it_works.2": "Nutzen Sie die daraus resultierende Customer Journey, um Onboarding, Dokumentation, Support und Feedback-Schleifen für den Nutzer zu verbessern.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.apply_in_work": "Bereitstellung von Richtlinien, Tools und Feedback-Mechanismen für das Verständnis, die Analyse und die Verbesserung der internen und externen Erfahrungen von Entwicklern und Partnern.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes": "Identifizieren und priorisieren Sie Ihre Nutzer",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes.1": "Definieren Sie die API-Erlebnisreise",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes.2": "Onboarding, Dokumentation und Feedback planen",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes.3": "Verbesserung der Akzeptanz durch echte Empathie + Developer Experience (DX)",
+  "cycle.api-productization-cycle.station.api-platform-architecture.title": "API-Plattformarchitektur - Architektur von APIs für Skalierbarkeit und Wiederverwendung",
+  "cycle.api-productization-cycle.station.api-platform-architecture.description": "Gewährleisten Sie Skalierbarkeit, Wiederverwendung und Governance für Ihre API- und Plattformkomponenten.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.why_it_matters": "Wenn APIs teamübergreifend skaliert werden, muss Ihre Plattform Governance und Wiederverwendung ermöglichen, ohne die Geschwindigkeit zu beeinträchtigen. Diese Station zeigt, wie man APIs für Langlebigkeit, Sicherheit und Effizienz entwickelt.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.apply_in_work": "Aufbau einer skalierbaren, sicheren und konformen Infrastruktur für den API-Betrieb. Bereitstellung von Leitlinien für bewährte Architekturverfahren.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.outcomes": "Redundante APIs abbauen und die Kosten für die Cloud-Plattform senken",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works": "Das Business Impact Canvas hilft dabei, Risiken in Bezug auf API-Verfügbarkeit, -Sicherheit und -Funktionalität zu identifizieren und zu mindern, um fundierte Architekturentscheidungen zu unterstützen.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.outcomes.1": "Umsetzung einer einheitlichen Governance ohne starke Kontrolle von oben nach unten",
+  "cycle.api-productization-cycle.station.api-platform-architecture.outcomes.2": "Design für interne Wiederverwendung und externe Skalierbarkeit",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works.1": "Kartierung der Standorte von API-Anbietern und -Nutzern, um die Zugänglichkeit und Einhaltung von Vorschriften zu gewährleisten.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works.2": "Das Capacity Canvas gleicht geschäftliche Transaktionsmuster, künftige Verbrauchstrends und technische Lösungen ab, um die Skalierbarkeit und Leistung von APIs zu gewährleisten und liefert wichtige Informationen für Skalierungsentscheidungen und die Infrastrukturplanung.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works.3": "Definieren und überwachen Sie Leistungsmetriken (z. B. API-Aufrufe, Latenz, Fehlerraten) und Adoptionsmetriken (z. B. NPS).",
+  "cycle.api-productization-cycle.station.api-design.title": "API-Design - Entwerfen Sie APIs, die Wert liefern",
+  "cycle.api-productization-cycle.station.api-design.description": "Erstellen Sie API-Designs, die konsistent, wiederverwendbar und auf Geschäftszielen und gemeinsamen Standards basieren.",
+  "cycle.api-productization-cycle.station.api-design.why_it_matters": "Beim Entwurf von APIs geht es nicht nur um die Benennung von Endpunkten. Gutes Design stellt sicher, dass APIs benutzerfreundlich, konsistent und auf Geschäfts- und technische Ziele ausgerichtet sind. Schlecht gestaltete APIs führen zu enger Kopplung, geringer Wiederverwendung und kostspieligen Nacharbeiten in den Teams.",
+  "cycle.api-productization-cycle.station.api-design.apply_in_work": "Bereitstellung von wiederverwendbaren Designmustern, gemeinsamen Standards und Validierungstools für API-Spezifikationen. Sicherstellen, dass Designentscheidungen konsistent, frühzeitig überprüft und auf die Geschäftsabsicht ausgerichtet sind.",
+  "cycle.api-productization-cycle.station.api-design.outcomes": "Gut dokumentierte und konsistente API-Designs",
+  "cycle.api-productization-cycle.station.api-design.how_it_works": "Definieren Sie zentrale Entitäten, ihre Attribute und Beziehungen, um ein gemeinsames konzeptionelles Verständnis für alle APIs zu schaffen.",
+  "cycle.api-productization-cycle.station.api-design.outcomes.1": "Wiederverwendbare und validierte API-Schnittstellenverträge",
+  "cycle.api-productization-cycle.station.api-design.outcomes.2": "Entwürfe, die auf Domänenmodelle und Interaktionsmuster abgestimmt sind",
+  "cycle.api-productization-cycle.station.api-design.outcomes.3": "Rückverfolgbarkeit des Designs zum Geschäftswert",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.1": "Verwenden Sie das Interaction Canvas, um zu definieren, wie die Nutzer mit der API interagieren werden, um sicherzustellen, dass sie ihren Bedürfnissen und Erwartungen entspricht.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.2": "Wenden Sie REST-Entwurfsmuster an, um konsistente, wiederverwendbare Schnittstellenverträge zu erstellen, die mit den Beteiligten validiert werden.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.3": "Wenden Sie ereignisgesteuerte Entwurfsmuster an, um konsistente, wiederverwendbare Schnittstellenverträge zu erstellen, die mit den Beteiligten validiert werden.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.4": "Wenden Sie GraphQL-Designmuster an, um konsistente, wiederverwendbare Schnittstellenverträge zu erstellen, die mit den Beteiligten validiert werden.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.5": "Nutzen Sie die Designprinzipien und den API-Styleguide, um Ihre Designentscheidungen an gemeinsamen Regeln auszurichten und eine konsistente Audit-Validierung zu ermöglichen.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.6": "Wenden Sie Contract-First- oder Design-First-Ansätze an, um den API-Schnittstellenvertrag vor der Implementierung zu erfassen und zu validieren.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.7": "Verwenden Sie die API-Audit-Checkliste, um sicherzustellen, dass das API-Design funktionale und nicht-funktionale Anforderungen erfüllt, einschließlich Sicherheit, Leistung und Compliance.",
+  "cycle.api-productization-cycle.station.api-delivery.title": "API-Bereitstellung - Bereitstellung sicherer und zuverlässiger APIs",
+  "cycle.api-productization-cycle.station.api-delivery.description": "Erstellen, Testen und Freigeben von APIs unter Verwendung moderner Bereitstellungspipelines und bewährter technischer Verfahren.",
+  "cycle.api-productization-cycle.station.api-delivery.why_it_matters": "Selbst die besten API-Designs scheitern, wenn die Bereitstellung uneinheitlich ist. Diese Station stellt sicher, dass Ihre APIs qualitativ hochwertig erstellt, gründlich getestet und zuverlässig bereitgestellt werden - für schnellere Iterationen und mehr Vertrauen.",
+  "cycle.api-productization-cycle.station.api-delivery.apply_in_work": "Bereitstellung von Frameworks, Bibliotheken und Standards für die API-Implementierung. Implementierung von CI/CD-Pipelines, Qualitätssicherungs-Frameworks und Tools zur Automatisierung der Bereitstellung.",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes": "APIs, die mit getesteten Frameworks und Mustern implementiert werden",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works": "Verwenden Sie Best Practices für die API-Entwicklung als Leitfaden für die Implementierung des validierten Schnittstellenvertrags mit etablierten Frameworks und Bibliotheken, um sicherzustellen, dass das Ergebnis wiederverwendbar und wartbar ist.",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes.1": "Zuverlässige und automatisierte CI/CD-Pipelines",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes.2": "Funktionale und nicht-funktionale Tests integriert",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes.3": "Sichere und gesetzeskonforme Bereitstellungspipelines",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.1": "Erstellen Sie die API-Implementierung auf Basis des validierten Schnittstellenvertrags unter Verwendung etablierter Frameworks, Bibliotheken und Teamstandards.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.2": "Testen Sie APIs auf Funktionalität, Sicherheit und Leistung mit automatisierten Testwerkzeugen.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.3": "Verwenden Sie CI/CD-Pipelines, um Build-, Test- und Bereitstellungsprozesse zu automatisieren und so konsistente Qualität und Nachvollziehbarkeit zu gewährleisten.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.4": "Stellen Sie sicher, dass APIs die Sicherheits- und Compliance-Anforderungen durch automatische Prüfungen und Audits erfüllen.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.5": "Verwenden Sie die API-Audit-Checkliste, um sicherzustellen, dass die API die funktionalen und nicht-funktionalen Anforderungen erfüllt, einschließlich Sicherheit, Leistung und Compliance.",
+  "cycle.api-productization-cycle.station.api-audit.title": "API-Audit - Prüfung von APIs auf Compliance und Qualität",
+  "cycle.api-productization-cycle.station.api-audit.description": "Stellen Sie sicher, dass APIs vor der Veröffentlichung und Bereitstellung den geschäftlichen, gestalterischen und betrieblichen Standards entsprechen.",
+  "cycle.api-productization-cycle.station.api-audit.why_it_matters": "APIs sind langlebige Produkte und müssen den Erwartungen hinsichtlich Qualität, Konsistenz und Compliance entsprechen. Das Audit verbindet Designentscheidungen, Implementierung und Betriebsbereitschaft mit definierten Standards und reduziert so Risiken vor der Bereitstellung.",
+  "cycle.api-productization-cycle.station.api-audit.apply_in_work": "Richten Sie einen konsistenten Audit-Prozess ein, der die API-Bereitschaft über alle Lebenszyklusphasen hinweg anhand definierter Kriterien, Nachweise und Standards bewertet. Stellen Sie sicher, dass Lücken frühzeitig erkannt und vor der Veröffentlichung behoben werden.",
+  "cycle.api-productization-cycle.station.api-audit.outcomes": "APIs erfüllen interne und externe Standards",
+  "cycle.api-productization-cycle.station.api-audit.how_it_works": "Führen Sie Audits durch, um sicherzustellen, dass APIs vor der Veröffentlichung organisatorische, technische und rechtliche Standards erfüllen.",
+  "cycle.api-productization-cycle.station.api-audit.outcomes.1": "Klare Dokumentation des API-Designs und der Implementierungsentscheidungen",
+  "cycle.api-productization-cycle.station.api-audit.outcomes.2": "Sicherheit, Leistung und Compliance validiert",
+  "cycle.api-productization-cycle.station.api-audit.outcomes.3": "Geringeres Risiko von Problemen in der Produktion",
+  "cycle.api-productization-cycle.station.api-audit.how_it_works.1": "Verwenden Sie Checklisten, Linters und Testwerkzeuge, um die Konsistenz und Compliance mit den Standards zu überprüfen.",
+  "cycle.api-productization-cycle.station.api-audit.how_it_works.2": "Zusammenarbeit mit Governance-Teams und Domänenexperten, um sicherzustellen, dass APIs für die Produktion bereit sind.",
+  "cycle.api-productization-cycle.station.api-publishing.title": "API-Veröffentlichung - Veröffentlichen Sie APIs mit Zuversicht",
+  "cycle.api-productization-cycle.station.api-publishing.description": "Stellen Sie APIs mit der richtigen Dokumentation und den richtigen Prozessen sicher und klar für die richtige Zielgruppe bereit.",
+  "cycle.api-productization-cycle.station.api-publishing.why_it_matters": "Bei der Veröffentlichung geht es nicht nur um die Bereitstellung, sondern auch um die Auffindbarkeit, den Zugang und die Unterstützung. Wenn APIs nicht korrekt veröffentlicht werden, können sie nicht verwendet, wiederverwendet oder effektiv gesichert werden.",
+  "cycle.api-productization-cycle.station.api-publishing.apply_in_work": "Ermöglichung der Veröffentlichung von APIs in der jeweiligen Umgebung mit klaren Registrierungs- und Zugriffsmechanismen (z. B. API-Schlüssel, OAuth, Abonnementpläne) je nach den Nutzersegmenten und den Sicherheits- und Compliance-Anforderungen.",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes": "Veröffentlichung von APIs in der richtigen Umgebung (privat, Partner, öffentlich)",
+  "cycle.api-productization-cycle.station.api-publishing.how_it_works": "Veröffentlichen Sie APIs in den entsprechenden Gateways und Umgebungen, um die Wiederverwendbarkeit für mehrere Nutzer zu unterstützen.",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes.1": "Klare API-Einführungs- und Registrierungsprozesse",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes.2": "Dokumentation, Sicherheitsmodelle und Richtlinien verfügbar",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes.3": "APIs bereit für Skalierung und Governance",
+  "cycle.api-productization-cycle.station.api-publishing.how_it_works.1": "Dokumentieren Sie, wie die Nutzer die API finden und nutzen, einschließlich Onboarding-Prozesse und Registrierung.",
+  "cycle.api-productization-cycle.station.api-publishing.how_it_works.2": "Stellen Sie sicher, dass die Sicherheitsmodelle, die Gateway-Konfiguration und die rechtlichen Bestimmungen für die Nutzer klar und verständlich sind.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.title": "Überwachen und Verbessern - für den API-Wert",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.description": "Nutzen Sie Messgrößen und Feedback, um die API-Leistung zu verfolgen und kontinuierliche Verbesserungen voranzutreiben.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.why_it_matters": "Die API-Bereitstellung endet nicht mit dem Start. Ohne Überwachung können Teams weder die Akzeptanz noch die Leistung oder den ROI verbessern. Diese Station stellt sicher, dass APIs nützlich und sicher bleiben und sich mit den Geschäftsanforderungen weiterentwickeln.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.apply_in_work": "Einrichtung von Analyserahmen zur Verfolgung von Leistung und Engagement. Entwickeln Sie Feedbackschleifen, Analysetools und Engagementstrategien für APIs.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes": "Festlegung und Verfolgung von Leistungs- und Nutzungskennzahlen",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.how_it_works": "Überwachen Sie Leistungsmetriken (z. B. API-Aufrufe, Latenz, Fehlerraten) und Akzeptanzmetriken (z. B. NPS).",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes.1": "Feedback-Schleifen für Entwickler sind vorhanden",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes.2": "Kontinuierlich ermittelte und behandelte Probleme",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes.3": "Iteration der API, abgestimmt auf die Bedürfnisse der Nutzer",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.how_it_works.1": "Analysieren Sie API-Nutzungsmetriken und integrieren Sie Benutzerfeedback in API-Iterationen.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.how_it_works.2": "Machen Sie es sich zur Gewohnheit, die Messwerte zu überprüfen und kontinuierliche Verbesserungsmaßnahmen zu planen."
 }
diff --git a/src/data/method/en/labels.criteria.json b/src/data/method/en/labels.criteria.json
index 1725671..bb988ba 100644
--- a/src/data/method/en/labels.criteria.json
+++ b/src/data/method/en/labels.criteria.json
@@ -1,25 +1,26 @@
 {
   "exit_criteria": "Exit criteria",
   "entry_criteria": "Entry criteria",
-  "criterion.metrics-feedback-available": "Relevant market signals, feedback, or operational insights are available to guide this API opportunity.",
+  "criterion.metrics-feedback-available": "Relevant market signals, feedback, or operational insights are available to guide this capability opportunity.",
   "criterion.business-goals-defined": "Business goals are defined.",
-  "criterion.market-research-done": "Market research identifies API opportunities.",
-  "criterion.stakeholder-approval": "Relevant stakeholders agree this API opportunity is worth exploring and prioritizing.",
-  "criterion.api-opportunity-documented": "Individual API opportunities are identified and documented.",
-  "criterion.api-reusability": "The API meets a clear business need and is reusable for multiple API consumers.",
-  "criterion.hide-backend-discrepancies": "The API is intended to shield consumers from backend complexity and inconsistencies.",
-  "criterion.value-prop-validated": "The API value proposition has been reviewed and validated with the relevant business and consumer stakeholders.",
-  "criterion.consumer-segments-identified": "API consumer segments (internal and external) are identified.",
-  "criterion.api-roadmap-defined": "High-level roadmaps for API development are established.",
-  "criterion.architecture-patterns-validated": "The chosen API architecture and platform patterns have been validated with the relevant architecture, security, and platform stakeholders.",
-  "criterion.design-reflects-business-value": "The API design and exposed capabilities clearly trace back to business value and user needs.",
-  "criterion.api-consistency": "The API design follows our shared API product and design conventions.",
-  "criterion.api-contract-tested": "The API contract is tested and meets functional and non-functional requirements.",
-  "criterion.api-description-available": "The API and its exposed capabilities are described clearly enough for review, audit, and onboarding.",
-  "criterion.audit-passed": "The API passes compliance, security, and audit checks.",
+  "criterion.market-research-done": "Market research identifies capability opportunities.",
+  "criterion.stakeholder-approval": "Relevant stakeholders agree this capability opportunity is worth exploring and prioritizing.",
+  "criterion.api-opportunity-documented": "Capability opportunity is identified and documented.",
+  "criterion.api-reusability": "The capability addresses a clear business need and is reusable by its intended consumers.",
+  "criterion.hide-backend-discrepancies": "The selected interface provides an appropriate abstraction for consumers.",
+  "criterion.value-prop-validated": "The capability value proposition has been validated with business and consumer stakeholders.",
+  "criterion.consumer-segments-identified": "Consumer segments are identified.",
+  "criterion.api-roadmap-defined": "A high-level implementation roadmap is defined.",
+  "criterion.architecture-patterns-validated": "The chosen architecture, platform, and implementation style have been validated with the relevant architecture, security, and platform stakeholders.",
+  "criterion.design-reflects-business-value": "The interface design and exposed capabilities trace back to business value and consumer needs.",
+  "criterion.api-consistency": "The interface design follows agreed design standards and conventions.",
+  "criterion.api-contract-tested": "The interface contract has been validated and tested against functional and non-functional requirements.",
+  "criterion.automation-workflow-validated": "The workflow, rules, integrations, and relevant interface contracts have been validated and tested.",
+  "criterion.api-description-available": "The interface and its capabilities are documented clearly enough for review, audit, and onboarding.",
+  "criterion.audit-passed": "The solution passes quality, security, compliance, and readiness checks.",
   "criterion.audit-reports-shared": "Audit findings and remediation decisions are shared with the relevant stakeholders.",
-  "criterion.api-ready-for-publishing": "The API is ready to be deployed and exposed through the intended gateways and environments.",
-  "criterion.api-documentation-ready": "Consumer-facing API documentation is complete enough for publishing and onboarding.",
-  "criterion.consumer-support-ready": "Registration, support, and communication processes are ready for API consumers.",
-  "criterion.legal-compliance-clear": "Legal, privacy, and compliance requirements for publishing are defined and understood."
+  "criterion.api-ready-for-publishing": "The capability is ready to be published or released through the selected delivery mechanism.",
+  "criterion.api-documentation-ready": "Consumer-facing documentation and onboarding materials are ready.",
+  "criterion.consumer-support-ready": "Consumer onboarding, support, and communication processes are ready.",
+  "criterion.legal-compliance-clear": "Legal, privacy, and compliance requirements for publishing or release are defined and understood."
 }
diff --git a/src/data/method/en/labels.cycles.json b/src/data/method/en/labels.cycles.json
new file mode 100644
index 0000000..9cef79f
--- /dev/null
+++ b/src/data/method/en/labels.cycles.json
@@ -0,0 +1,93 @@
+{
+  "cycles.title": "Cycle Views",
+  "cycles.description": "Audience-specific views over the APIOps Cycles method",
+  "cycle.capability-productization-cycle.title": "Capability Productization Cycle",
+  "cycle.capability-productization-cycle.description": "A cycle for turning business capabilities into reusable digital capabilities before selecting the implementation style.",
+  "cycle.capability-productization-cycle.purpose": "Identify and productize reusable digital capabilities before choosing an API, event, file, stream, data product, AI-enabled service, direct integration, or hybrid implementation style.",
+  "cycle.api-productization-cycle.title": "API Productization Cycle",
+  "cycle.api-productization-cycle.description": "The API-focused APIOps Cycles journey for productizing, designing, delivering, publishing, and improving APIs.",
+  "cycle.api-productization-cycle.purpose": "API-focused method journey for teams that already know the intended implementation style is an API product.",
+  "cycle.integration-productization-cycle.title": "Integration Productization Cycle",
+  "cycle.integration-productization-cycle.description": "A cycle for productizing reusable integration capabilities before selecting the implementation style.",
+  "cycle.integration-productization-cycle.purpose": "Guide reusable integration capability design before choosing an API, event, file, stream, data product, direct integration, or hybrid implementation style.",
+  "cycle.station.capability-strategy": "Capability Strategy",
+  "cycle.station.consumer-requirements-onboarding": "Consumer Requirements & Onboarding",
+  "cycle.station.architecture-platform-decisions": "Architecture & Platform Decisions",
+  "cycle.station.solution-interface-design": "Solution & Interface Design",
+  "cycle.station.delivery-operations": "Delivery & Operations",
+  "cycle.station.quality-readiness-assurance": "Quality & Readiness Assurance",
+  "cycle.station.publishing-enablement": "Publishing & Enablement",
+  "cycle.station.monitoring-improvement": "Monitoring & Improvement",
+  "cycle.station.api-product-strategy": "API Product Strategy",
+  "cycle.station.api-consumer-experience": "API Consumer Experience",
+  "cycle.station.api-platform-architecture": "API Platform Architecture",
+  "cycle.station.api-design": "API Design",
+  "cycle.station.api-delivery": "API Delivery",
+  "cycle.station.api-audit": "API Audit",
+  "cycle.station.api-publishing": "API Publishing",
+  "cycle.station.monitoring-and-improving": "API Monitoring & Improvement",
+  "cycle.station.integration-capability-strategy": "Integration Capability Strategy",
+  "cycle.station.integration-consumer-requirements-onboarding": "Integration Consumer Requirements & Onboarding",
+  "cycle.station.integration-architecture-decision": "Integration Architecture & Platform Decisions",
+  "cycle.station.integration-solution-design": "Integration Solution Design",
+  "cycle.station.integration-delivery-operations": "Integration Delivery & Operations",
+  "cycle.station.integration-readiness-assurance": "Integration Readiness Assurance",
+  "cycle.station.capability-publishing": "Integration Publishing & Enablement",
+  "cycle.station.integration-monitoring-improvement": "Integration Monitoring & Improvement",
+  "cycle.capability-productization-cycle.station.api-product-strategy.description": "Frame the business need as a reusable capability with clear value, consumers, ownership, and business goals before selecting the implementation style.",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.description": "Capture consumer requirements, onboarding needs, constraints, service expectations, and producer responsibilities.",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.description": "Use requirements and constraints to select the implementation style, architecture pattern, and enabling platform capabilities.",
+  "cycle.capability-productization-cycle.station.api-design.description": "Design the interface contract and interaction model for the selected implementation style.",
+  "cycle.capability-productization-cycle.station.api-delivery.description": "Build, test, deploy, and operate the capability using the selected implementation style and validated interface contract.",
+  "cycle.capability-productization-cycle.station.api-audit.description": "Validate the interface contract, controls, documentation, support model, and operational readiness before release.",
+  "cycle.capability-productization-cycle.station.api-publishing.description": "Publish the capability so consumers can discover it, evaluate it, request access, complete onboarding, use it, and get support.",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.description": "Monitor capability health, consumer outcomes, reliability, reuse, and improvement opportunities.",
+  "cycle.owner.business-owner": "Business owner",
+  "cycle.owner.domain-expert": "Domain expert",
+  "cycle.owner.capability-owner": "Capability owner",
+  "cycle.owner.consumer-representative": "Consumer representative",
+  "cycle.owner.enterprise-architect": "Enterprise architect",
+  "cycle.owner.platform-owner": "Platform owner",
+  "cycle.owner.api-product-owner": "API product owner",
+  "cycle.owner.api-platform-owner": "API platform owner",
+  "cycle.owner.integration-architect": "Integration architect",
+  "cycle.owner.solution-architect": "Solution architect",
+  "cycle.api-productization-cycle.station.api-product-strategy.description": "Frame the API as a product with clear value proposition, consumers, business model, ownership, and lifecycle intent.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.description": "Define API consumer segments, onboarding paths, expectations, and experience requirements before design decisions are locked.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.description": "Choose and validate the API platform, architecture, governance, and operational constraints needed for the product.",
+  "cycle.api-productization-cycle.station.api-design.description": "Design the API contract, interaction model, schemas, policies, and usability details before implementation.",
+  "cycle.api-productization-cycle.station.api-delivery.description": "Implement, test, secure, automate, and operate the API product through the delivery pipeline.",
+  "cycle.api-productization-cycle.station.api-audit.description": "Validate API quality, compliance, evidence, operational readiness, and release criteria.",
+  "cycle.api-productization-cycle.station.api-publishing.description": "Publish the API product so consumers can discover it, evaluate it, request access, complete onboarding, use it, and get support.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.description": "Monitor API health, adoption, consumer outcomes, reliability, and improvement opportunities after release.",
+  "cycle.integration-productization-cycle.station.api-product-strategy.description": "Frame the reusable integration capability, business need, ownership, and expected reuse before selecting the implementation style.",
+  "cycle.integration-productization-cycle.station.api-consumer-experience.description": "Capture integration consumers, provider responsibilities, onboarding needs, service expectations, and operational constraints.",
+  "cycle.integration-productization-cycle.station.api-platform-architecture.description": "Select the integration architecture, implementation style, and platform capabilities, taking account of constraints and the governance model.",
+  "cycle.integration-productization-cycle.station.api-design.description": "Design the interface contract, schemas, payloads, and interaction patterns for the selected integration style.",
+  "cycle.integration-productization-cycle.station.api-delivery.description": "Build, test, automate, deploy, and operate the integration capability using its selected implementation style and validated interface contract.",
+  "cycle.integration-productization-cycle.station.api-audit.description": "Assure integration readiness, governance, quality, security, compliance, and operational evidence before release.",
+  "cycle.integration-productization-cycle.station.api-publishing.description": "Publish the integration capability so teams can discover it, evaluate it, request access, complete onboarding, reuse it, and get support.",
+  "cycle.integration-productization-cycle.station.monitoring-and-improving.description": "Monitor integration reliability, reuse, incidents, performance, consumer outcomes, and improvement needs.",
+  "cycle.automation-cycle.title": "Automation Cycle",
+  "cycle.automation-cycle.description": "A cycle for identifying, designing, delivering, enabling, and improving automation opportunities.",
+  "cycle.automation-cycle.purpose": "Productize automation opportunities into governed workflows with clear users, platforms, controls, delivery paths, enablement, and monitoring.",
+  "cycle.audience.automation-owners": "Automation owners",
+  "cycle.audience.process-owners": "Process owners",
+  "cycle.audience.automation-teams": "Automation teams",
+  "cycle.station.automation-opportunity-strategy": "Automation Opportunity Strategy",
+  "cycle.station.process-user-requirements": "Process & User Requirements",
+  "cycle.station.automation-platform-decision": "Automation Platform Decision",
+  "cycle.station.automation-workflow-design": "Automation Workflow Design",
+  "cycle.station.automation-delivery": "Automation Delivery & Operations",
+  "cycle.station.automation-readiness-review": "Automation Readiness Review",
+  "cycle.station.automation-enablement": "Automation Rollout & Enablement",
+  "cycle.station.automation-monitoring-improvement": "Automation Monitoring & Improvement",
+  "cycle.automation-cycle.station.api-product-strategy.description": "Identify and prioritize automation opportunities by value, feasibility, risk, ownership, and expected process impact.",
+  "cycle.automation-cycle.station.api-consumer-experience.description": "Capture process users, roles, handoffs, exceptions, constraints, and service expectations before designing the automation.",
+  "cycle.automation-cycle.station.api-platform-architecture.description": "Choose the automation platform, runtime, integration approach, governance controls, and operating constraints.",
+  "cycle.automation-cycle.station.api-design.description": "Design the automation workflow, triggers, decision points, integrations, data handling, relevant interface contracts, and exception paths.",
+  "cycle.automation-cycle.station.api-delivery.description": "Build, test, deploy, document, and operate the automation using clear ownership, controls, and rollback paths.",
+  "cycle.automation-cycle.station.api-audit.description": "Review automation readiness, quality, risk, compliance, human oversight, evidence, and release criteria.",
+  "cycle.automation-cycle.station.api-publishing.description": "Roll out the automation with discovery, onboarding, operating instructions, support paths, and change communication for users and operators.",
+  "cycle.automation-cycle.station.monitoring-and-improving.description": "Monitor automation performance, exceptions, reliability, user outcomes, operational impact, and improvement opportunities."
+}
diff --git a/src/data/method/en/labels.lines.json b/src/data/method/en/labels.lines.json
index 0f693aa..dda0025 100644
--- a/src/data/method/en/labels.lines.json
+++ b/src/data/method/en/labels.lines.json
@@ -1,16 +1,16 @@
 {
   "lines.title": "Metro Lines",
-  "lines.description": "A collection of API lines that guide the development and management of APIs.",
+  "lines.description": "A collection of shared metro lines that guide reusable capability, API, integration, automation, and future data productization work.",
   "line.business-opportunities-line.title": "Business Opportunities Line",
-  "line.business-opportunities-line.description": "Focuses on identifying and leveraging business opportunities through APIs.",
+  "line.business-opportunities-line.description": "Focuses on identifying and shaping business opportunities as reusable digital capabilities.",
   "line.platform-architecture-line.title": "Platform Architecture Line",
-  "line.platform-architecture-line.description": "Covers the architectural aspects of API platforms.",
-  "line.api-design-line.title": "API Design Line",
-  "line.api-design-line.description": "Focuses on the design principles and practices for APIs.",
+  "line.platform-architecture-line.description": "Covers architecture and platform decisions for reusable capabilities across implementation styles.",
+  "line.api-design-line.title": "Design Line",
+  "line.api-design-line.description": "Focuses on solution and interface design principles that can be used across APIs, integrations, automations, data products, and other implementation styles.",
   "line.delivery-line.title": "Delivery Line",
-  "line.delivery-line.description": "Covers the delivery processes and practices for APIs.",
+  "line.delivery-line.description": "Covers delivery and operational practices for reusable capabilities across implementation styles.",
   "line.publishing-and-adoption-line.title": "Publishing and Adoption Line",
-  "line.publishing-and-adoption-line.description": "Focuses on publishing APIs and ensuring their adoption by consumers.",
+  "line.publishing-and-adoption-line.description": "Focuses on publishing reusable capabilities and enabling adoption by consumers.",
   "line.operating-model-line.title": "Operating Model Line",
-  "line.operating-model-line.description": "Covers the operating model for API management and governance."
-}
\ No newline at end of file
+  "line.operating-model-line.description": "Covers the operating model for reusable capability management and governance."
+}
diff --git a/src/data/method/en/labels.resources.json b/src/data/method/en/labels.resources.json
index 8c185a8..ee95e17 100644
--- a/src/data/method/en/labels.resources.json
+++ b/src/data/method/en/labels.resources.json
@@ -1,172 +1,172 @@
 {
   "resource.api-community-engagement-strategies.title": "API Community Engagement Strategies",
   "resource.api-community-engagement-strategies.description": "A playbook for fostering API adoption by cultivating communities through content, support channels, feedback loops, and social engagement strategies.",
-  "resource.api-community-engagement-strategies.outcomes": "Better understanding of API community engagement strategies principles",
-  "resource.api-community-engagement-strategies.outcomes.1": "Standardized approach using API Community Engagement Strategies",
-  "resource.api-community-engagement-strategies.outcomes.2": "Improved implementation of related API practices",
+  "resource.api-community-engagement-strategies.outcomes": "Shared understanding of the purpose and use of API Community Engagement Strategies",
+  "resource.api-community-engagement-strategies.outcomes.1": "A consistent approach to applying API Community Engagement Strategies",
+  "resource.api-community-engagement-strategies.outcomes.2": "Improved application of the related practices",
   "resource.api-community-engagement-strategies.steps": "Develop marketing strategies to promote APIs to target audiences, including social media, blogs, and webinars.",
   "resource.api-community-engagement-strategies.steps.1": "Create promotional materials (e.g., case studies, success stories) that highlight the value and benefits of APIs.",
   "resource.api-community-engagement-strategies.steps.2": "Create educational materials (e.g., tutorials, documentation) that explain API features, benefits, and usage patterns.",
   "resource.api-community-engagement-strategies.steps.3": "Engage with API consumers through feedback loops, support channels, and community forums to understand their needs and improve API adoption.",
   "resource.api-community-engagement-strategies.steps.4": "Analyze API usage metrics and incorporate user feedback into API iterations.",
-  "resource.api-community-engagement-strategies.tips": "Customize the API Community Engagement Strategies for your domain",
-  "resource.api-community-engagement-strategies.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.api-community-engagement-strategies.tips": "Adapt this resource to your context.",
+  "resource.api-community-engagement-strategies.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.api-compliance-best-practices.title": "API Compliance Best Practices",
   "resource.api-compliance-best-practices.description": "Ensure APIs meet legal, regulatory, and internal compliance through documentation, controls, and automated validations.",
-  "resource.api-compliance-best-practices.outcomes": "Better understanding of API compliance best practices principles",
-  "resource.api-compliance-best-practices.outcomes.1": "Standardized approach using API Compliance Best Practices",
-  "resource.api-compliance-best-practices.outcomes.2": "Improved implementation of related API practices",
+  "resource.api-compliance-best-practices.outcomes": "Shared understanding of the purpose and use of API Compliance Best Practices",
+  "resource.api-compliance-best-practices.outcomes.1": "A consistent approach to applying API Compliance Best Practices",
+  "resource.api-compliance-best-practices.outcomes.2": "Improved application of the related practices",
   "resource.api-compliance-best-practices.steps": "Document compliance measures and ensure they are communicated to stakeholders and consumers.",
   "resource.api-compliance-best-practices.steps.1": "Implement measures to ensure APIs comply with these requirements, including data encryption, access controls, and audit trails.",
   "resource.api-compliance-best-practices.steps.2": "Use checklists, linters, and testing tools to verify consistency and conformance with standards.",
-  "resource.api-compliance-best-practices.tips": "Customize the API Compliance Best Practices for your domain",
-  "resource.api-compliance-best-practices.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.api-compliance-best-practices.tips": "Adapt this resource to your context.",
+  "resource.api-compliance-best-practices.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.api-development-best-practices.title": "API Development Best Practices",
-  "resource.api-development-best-practices.description": "Implementation guidance for turning a validated API contract into a consistent, maintainable API codebase using standard libraries, reusable patterns, and aligned development workflows.",
-  "resource.api-development-best-practices.outcomes": "Better understanding of API development best practices principles",
-  "resource.api-development-best-practices.outcomes.1": "Standardized approach using API Development Best Practices",
-  "resource.api-development-best-practices.outcomes.2": "Improved implementation of related API practices",
-  "resource.api-development-best-practices.steps": "Apply these practices to the validated API contract and implementation plan before coding begins.",
+  "resource.api-development-best-practices.description": "Implementation guidance for turning a validated API interface contract into a consistent, maintainable API codebase using standard libraries, reusable patterns, and aligned development workflows.",
+  "resource.api-development-best-practices.outcomes": "Shared understanding of the purpose and use of API Development Best Practices",
+  "resource.api-development-best-practices.outcomes.1": "A consistent approach to applying API Development Best Practices",
+  "resource.api-development-best-practices.outcomes.2": "Improved application of the related practices",
+  "resource.api-development-best-practices.steps": "Apply these practices to the validated API interface contract and implementation plan before coding begins.",
   "resource.api-development-best-practices.steps.1": "Use established frameworks, libraries, and coding standards to implement the contract consistently and maintainably.",
   "resource.api-development-best-practices.tips": "Use this resource as implementation guidance and a review lens rather than as a required standalone artifact",
-  "resource.api-development-best-practices.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.api-development-best-practices.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.api-metrics-and-analytics.title": "API Metrics And Analytics",
   "resource.api-metrics-and-analytics.description": "A resource for defining, collecting, and analyzing API performance and usage data to align technical KPIs with business outcomes.",
-  "resource.api-metrics-and-analytics.outcomes": "Better understanding of API metrics and analytics principles",
-  "resource.api-metrics-and-analytics.outcomes.1": "Standardized approach using API Metrics And Analytics",
-  "resource.api-metrics-and-analytics.outcomes.2": "Improved implementation of related API practices",
+  "resource.api-metrics-and-analytics.outcomes": "Shared understanding of the purpose and use of API Metrics And Analytics",
+  "resource.api-metrics-and-analytics.outcomes.1": "A consistent approach to applying API Metrics And Analytics",
+  "resource.api-metrics-and-analytics.outcomes.2": "Improved application of the related practices",
   "resource.api-metrics-and-analytics.steps": "Identify key performance indicators (KPIs) to measure API success against business goals.",
   "resource.api-metrics-and-analytics.steps.1": "Define and monitor performance metrics (e.g., API calls, latency, error rates) and adoption metrics (e.g., NPS).",
   "resource.api-metrics-and-analytics.steps.2": "Monitor API initiatives to ensure adherence to operating guidelines and governance practices",
-  "resource.api-metrics-and-analytics.tips": "Customize the API Metrics And Analytics for your domain",
-  "resource.api-metrics-and-analytics.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.api-metrics-and-analytics.tips": "Adapt this resource to your context.",
+  "resource.api-metrics-and-analytics.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.api-onboarding-best-practices.title": "API Onboarding Best Practices",
   "resource.api-onboarding-best-practices.description": "Best practices to streamline API consumer onboarding journeys with step-by-step registration, discovery, and first-call guidance.",
-  "resource.api-onboarding-best-practices.outcomes": "Better understanding of API onboarding best practices principles",
-  "resource.api-onboarding-best-practices.outcomes.1": "Standardized approach using API Onboarding Best Practices",
-  "resource.api-onboarding-best-practices.outcomes.2": "Improved implementation of related API practices",
+  "resource.api-onboarding-best-practices.outcomes": "Shared understanding of the purpose and use of API Onboarding Best Practices",
+  "resource.api-onboarding-best-practices.outcomes.1": "A consistent approach to applying API Onboarding Best Practices",
+  "resource.api-onboarding-best-practices.outcomes.2": "Improved application of the related practices",
   "resource.api-onboarding-best-practices.steps": "Define the API consumer journey from discovery to troubleshooting, identifying key touchpoints and pain points.",
   "resource.api-onboarding-best-practices.steps.1": "Develop onboarding processes and resources to help API consumers understand how to use APIs effectively.",
   "resource.api-onboarding-best-practices.steps.2": "Document how consumers find and use the API, including onboarding processes and registration.",
-  "resource.api-onboarding-best-practices.tips": "Customize the API Onboarding Best Practices for your domain",
-  "resource.api-onboarding-best-practices.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.api-onboarding-best-practices.tips": "Adapt this resource to your context.",
+  "resource.api-onboarding-best-practices.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.api-portfolio-management-guidelines.title": "API Portfolio Management Guidelines",
   "resource.api-portfolio-management-guidelines.description": "A guide to strategically manage an organization's API suite—prioritizing APIs, allocating resources, and monitoring performance across lifecycles.",
-  "resource.api-portfolio-management-guidelines.outcomes": "Better understanding of API portfolio management guidelines principles",
-  "resource.api-portfolio-management-guidelines.outcomes.1": "Standardized approach using API Portfolio Management Guidelines",
-  "resource.api-portfolio-management-guidelines.outcomes.2": "Improved implementation of related API practices",
+  "resource.api-portfolio-management-guidelines.outcomes": "Shared understanding of the purpose and use of API Portfolio Management Guidelines",
+  "resource.api-portfolio-management-guidelines.outcomes.1": "A consistent approach to applying API Portfolio Management Guidelines",
+  "resource.api-portfolio-management-guidelines.outcomes.2": "Improved application of the related practices",
   "resource.api-portfolio-management-guidelines.steps": "Define portfolio management practices that outline the processes for managing the API portfolio, including prioritization, monitoring, and optimization.",
   "resource.api-portfolio-management-guidelines.steps.1": "Define budget and resource management practices that outline the processes for managing budgets and resources for API initiatives.",
   "resource.api-portfolio-management-guidelines.steps.2": "Establish criteria for evaluating and prioritizing budget allocations based on business value, impact, and alignment with strategic initiatives.",
   "resource.api-portfolio-management-guidelines.steps.3": "Monitor the API portfolio to ensure APIs are delivering value, meeting performance expectations, and aligning with business goals.",
-  "resource.api-portfolio-management-guidelines.tips": "Customize the API Portfolio Management Guidelines for your domain",
-  "resource.api-portfolio-management-guidelines.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.api-portfolio-management-guidelines.tips": "Adapt this resource to your context.",
+  "resource.api-portfolio-management-guidelines.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.api-security-best-practices.title": "API Security Best Practices",
   "resource.api-security-best-practices.description": "A set of actionable controls for securing APIs, including authentication, authorization, encryption, rate-limiting, and pipeline-level compliance checks.",
-  "resource.api-security-best-practices.outcomes": "Better understanding of API security best practices principles",
-  "resource.api-security-best-practices.outcomes.1": "Standardized approach using API Security Best Practices",
-  "resource.api-security-best-practices.outcomes.2": "Improved implementation of related API practices",
+  "resource.api-security-best-practices.outcomes": "Shared understanding of the purpose and use of API Security Best Practices",
+  "resource.api-security-best-practices.outcomes.1": "A consistent approach to applying API Security Best Practices",
+  "resource.api-security-best-practices.outcomes.2": "Improved application of the related practices",
   "resource.api-security-best-practices.steps": "Ensure APIs meet security and compliance requirements through automated checks and audits.",
   "resource.api-security-best-practices.steps.1": "Implement security measures such as authentication, authorization, encryption, and rate limiting to protect APIs from threats.",
   "resource.api-security-best-practices.steps.2": "Implement automated security checks and compliance validations in the CI/CD pipeline to ensure APIs are secure and compliant.",
-  "resource.api-security-best-practices.tips": "Customize the API Security Best Practices for your domain",
-  "resource.api-security-best-practices.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.api-security-best-practices.tips": "Adapt this resource to your context.",
+  "resource.api-security-best-practices.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.api-team-structure-guidelines.title": "API Team Structure Guidelines",
   "resource.api-team-structure-guidelines.description": "Organizational guidance for defining roles and responsibilities within API teams to ensure clarity, collaboration, and accountability.",
-  "resource.api-team-structure-guidelines.outcomes": "Better understanding of API team structure guidelines principles",
-  "resource.api-team-structure-guidelines.outcomes.1": "Standardized approach using API Team Structure Guidelines",
-  "resource.api-team-structure-guidelines.outcomes.2": "Improved implementation of related API practices",
+  "resource.api-team-structure-guidelines.outcomes": "Shared understanding of the purpose and use of API Team Structure Guidelines",
+  "resource.api-team-structure-guidelines.outcomes.1": "A consistent approach to applying API Team Structure Guidelines",
+  "resource.api-team-structure-guidelines.outcomes.2": "Improved application of the related practices",
   "resource.api-team-structure-guidelines.steps": "Define team structures and roles for API teams, including API product owners, developers, architects, and operations.",
-  "resource.api-team-structure-guidelines.tips": "Customize the API Team Structure Guidelines for your domain",
-  "resource.api-team-structure-guidelines.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.api-team-structure-guidelines.tips": "Adapt this resource to your context.",
+  "resource.api-team-structure-guidelines.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.api-testing-best-practices.title": "API Testing Best Practices",
   "resource.api-testing-best-practices.description": "Guidelines for implementing automated functional, performance, and security testing throughout the API lifecycle.",
-  "resource.api-testing-best-practices.outcomes": "Better understanding of API testing best practices principles",
-  "resource.api-testing-best-practices.outcomes.1": "Standardized approach using API Testing Best Practices",
-  "resource.api-testing-best-practices.outcomes.2": "Improved implementation of related API practices",
+  "resource.api-testing-best-practices.outcomes": "Shared understanding of the purpose and use of API Testing Best Practices",
+  "resource.api-testing-best-practices.outcomes.1": "A consistent approach to applying API Testing Best Practices",
+  "resource.api-testing-best-practices.outcomes.2": "Improved application of the related practices",
   "resource.api-testing-best-practices.steps": "Test APIs for functionality, security, and performance using automated testing tools.",
   "resource.api-testing-best-practices.steps.1": "Integrate functional and non-functional testing into the CI/CD pipeline to ensure APIs meet quality standards.",
   "resource.api-testing-best-practices.steps.2": "Use automated testing tools to validate API functionality, security, and performance.",
-  "resource.api-testing-best-practices.tips": "Customize the API Testing Best Practices for your domain",
-  "resource.api-testing-best-practices.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.api-testing-best-practices.tips": "Adapt this resource to your context.",
+  "resource.api-testing-best-practices.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.api-training-programs.title": "API Training Programs",
   "resource.api-training-programs.description": "A roadmap for upskilling teams with structured learning paths in API design, governance, performance, and security.",
-  "resource.api-training-programs.outcomes": "Better understanding of API training programs principles",
-  "resource.api-training-programs.outcomes.1": "Standardized approach using API Training Programs",
-  "resource.api-training-programs.outcomes.2": "Improved implementation of related API practices",
+  "resource.api-training-programs.outcomes": "Shared understanding of the purpose and use of API Training Programs",
+  "resource.api-training-programs.outcomes.1": "A consistent approach to applying API Training Programs",
+  "resource.api-training-programs.outcomes.2": "Improved application of the related practices",
   "resource.api-training-programs.steps": "Identify key API skills and knowledge areas that need enhancement, such as API design, security, and performance.",
   "resource.api-training-programs.steps.1": "Encourage continuous learning through online courses, certifications, and community engagement.",
   "resource.api-training-programs.steps.2": "Provide training and resources to help teams adopt an API-first mindset and understand the benefits of APIs.",
   "resource.api-training-programs.steps.3": "Provide training programs, workshops, and resources to help teams enhance their API skills and knowledge.",
-  "resource.api-training-programs.tips": "Customize the API Training Programs for your domain",
-  "resource.api-training-programs.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.api-training-programs.tips": "Adapt this resource to your context.",
+  "resource.api-training-programs.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.api-versioning-best-practices.title": "API Versioning Best Practices",
   "resource.api-versioning-best-practices.description": "Strategies for introducing, maintaining, and retiring API versions while preserving backward compatibility and consumer trust.",
-  "resource.api-versioning-best-practices.outcomes": "Better understanding of API versioning best practices principles",
-  "resource.api-versioning-best-practices.outcomes.1": "Standardized approach using API Versioning Best Practices",
-  "resource.api-versioning-best-practices.outcomes.2": "Improved implementation of related API practices",
+  "resource.api-versioning-best-practices.outcomes": "Shared understanding of the purpose and use of API Versioning Best Practices",
+  "resource.api-versioning-best-practices.outcomes.1": "A consistent approach to applying API Versioning Best Practices",
+  "resource.api-versioning-best-practices.outcomes.2": "Improved application of the related practices",
   "resource.api-versioning-best-practices.steps": "Define versioning strategies for APIs to manage changes and ensure backward compatibility.",
-  "resource.api-versioning-best-practices.tips": "Customize the API Versioning Best Practices for your domain",
-  "resource.api-versioning-best-practices.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.api-versioning-best-practices.tips": "Adapt this resource to your context.",
+  "resource.api-versioning-best-practices.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.apiops-CI-CD-for-apis.title": "APIOps CI/CD For APIs",
   "resource.apiops-CI-CD-for-apis.description": "Deployment guidance that integrates API lifecycle tasks—design, testing, governance—into continuous integration and delivery pipelines.",
-  "resource.apiops-CI-CD-for-apis.outcomes": "Better understanding of CI/CDfor APIs principles",
-  "resource.apiops-CI-CD-for-apis.outcomes.1": "Standardized approach using CI/CD For APIs",
-  "resource.apiops-CI-CD-for-apis.outcomes.2": "Improved implementation of related API practices",
+  "resource.apiops-CI-CD-for-apis.outcomes": "Shared understanding of the purpose and use of APIOps CI/CD For APIs",
+  "resource.apiops-CI-CD-for-apis.outcomes.1": "A consistent approach to applying APIOps CI/CD For APIs",
+  "resource.apiops-CI-CD-for-apis.outcomes.2": "Improved application of the related practices",
   "resource.apiops-CI-CD-for-apis.steps": "Use CI/CD pipelines to automate build, test, and deployment processes, ensuring consistent quality and traceability.",
   "resource.apiops-CI-CD-for-apis.steps.1": "Integrate automated tests into the CI/CD pipeline to ensure continuous validation of API quality.",
   "resource.apiops-CI-CD-for-apis.steps.2": "Implement deployment strategies (e.g., blue-green deployments, canary releases) to minimize risks during API releases.",
   "resource.apiops-CI-CD-for-apis.steps.3": "Establish a habit of reviewing metrics and planning continuous improvement activities.",
-  "resource.apiops-CI-CD-for-apis.tips": "Customize the CI/CD For APIs for your domain",
-  "resource.apiops-CI-CD-for-apis.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.apiops-CI-CD-for-apis.tips": "Adapt this resource to your context.",
+  "resource.apiops-CI-CD-for-apis.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.competitor-analysis-template.title": "Competitor Analysis Template",
   "resource.competitor-analysis-template.description": "A structured worksheet to benchmark your API offerings against competitors by mapping strengths, weaknesses, and value differentiators.",
-  "resource.competitor-analysis-template.outcomes": "Better understanding of competitor analysis template principles",
-  "resource.competitor-analysis-template.outcomes.1": "Standardized approach using Competitor Analysis Template",
-  "resource.competitor-analysis-template.outcomes.2": "Improved implementation of related API practices",
+  "resource.competitor-analysis-template.outcomes": "Shared understanding of the purpose and use of Competitor Analysis Template",
+  "resource.competitor-analysis-template.outcomes.1": "A consistent approach to applying Competitor Analysis Template",
+  "resource.competitor-analysis-template.outcomes.2": "Improved application of the related practices",
   "resource.competitor-analysis-template.steps": "Conduct a competitive analysis to identify key competitors, and their API offerings.",
   "resource.competitor-analysis-template.steps.1": "Analyze competitor APIs to understand their strengths, weaknesses, and unique selling points.",
-  "resource.competitor-analysis-template.tips": "Customize the Competitor Analysis Template for your domain",
-  "resource.competitor-analysis-template.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.competitor-analysis-template.tips": "Adapt this resource to your context.",
+  "resource.competitor-analysis-template.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.contract-first-design.title": "Contract First Design",
   "resource.contract-first-design.description": "A guideline advocating for API-first approaches using formal contracts (e.g., OpenAPI) to align stakeholders before development.",
-  "resource.contract-first-design.outcomes": "Better understanding of contract first design principles",
-  "resource.contract-first-design.outcomes.1": "Standardized approach using Contract First Design",
-  "resource.contract-first-design.outcomes.2": "Improved implementation of related API practices",
-  "resource.contract-first-design.steps": "Apply contract-first or design-first approaches to ensure API contracts are validated before implementation.",
-  "resource.contract-first-design.steps.1": "Define API contracts that outline the expectations, responsibilities, and usage guidelines for each API.",
-  "resource.contract-first-design.steps.2": "Use standardized formats (e.g., OpenAPI, AsyncAPI) to create machine-readable API contracts that are easy to share and validate.",
-  "resource.contract-first-design.tips": "Customize the Contract First Design for your domain",
-  "resource.contract-first-design.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.contract-first-design.outcomes": "Shared understanding of the purpose and use of Contract First Design",
+  "resource.contract-first-design.outcomes.1": "A consistent approach to applying Contract First Design",
+  "resource.contract-first-design.outcomes.2": "Improved application of the related practices",
+  "resource.contract-first-design.steps": "Apply contract-first or design-first approaches to ensure API interface contracts are validated before implementation.",
+  "resource.contract-first-design.steps.1": "Define API interface contracts that outline the expectations, responsibilities, and usage guidelines for each API.",
+  "resource.contract-first-design.steps.2": "Use standardized formats (e.g., OpenAPI, AsyncAPI) to create machine-readable API interface contracts that are easy to share and validate.",
+  "resource.contract-first-design.tips": "Adapt this resource to your context.",
+  "resource.contract-first-design.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.cross-functional-collaboration-best-practices.title": "Cross Functional Collaboration Best Practices",
   "resource.cross-functional-collaboration-best-practices.description": "Practices to facilitate communication and alignment between business and tech teams when planning or delivering APIs.",
-  "resource.cross-functional-collaboration-best-practices.outcomes": "Better understanding of cross functional collaboration best practices principles",
-  "resource.cross-functional-collaboration-best-practices.outcomes.1": "Standardized approach using Cross Functional Collaboration Best Practices",
-  "resource.cross-functional-collaboration-best-practices.outcomes.2": "Improved implementation of related API practices",
+  "resource.cross-functional-collaboration-best-practices.outcomes": "Shared understanding of the purpose and use of Cross Functional Collaboration Best Practices",
+  "resource.cross-functional-collaboration-best-practices.outcomes.1": "A consistent approach to applying Cross Functional Collaboration Best Practices",
+  "resource.cross-functional-collaboration-best-practices.outcomes.2": "Improved application of the related practices",
   "resource.cross-functional-collaboration-best-practices.steps": "Encourage cross-functional collaboration between API teams, business units, and stakeholders to align API initiatives with business goals.",
-  "resource.cross-functional-collaboration-best-practices.tips": "Customize the Cross Functional Collaboration Best Practices for your domain",
-  "resource.cross-functional-collaboration-best-practices.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.cross-functional-collaboration-best-practices.tips": "Adapt this resource to your context.",
+  "resource.cross-functional-collaboration-best-practices.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.data-privacy-guidelines.title": "Data Privacy Guidelines",
   "resource.data-privacy-guidelines.description": "Design considerations to ensure APIs meet data protection regulations like GDPR through anonymization and access controls.",
-  "resource.data-privacy-guidelines.outcomes": "Better understanding of data privacy guidelines principles",
-  "resource.data-privacy-guidelines.outcomes.1": "Standardized approach using Data Privacy Guidelines",
-  "resource.data-privacy-guidelines.outcomes.2": "Improved implementation of related API practices",
+  "resource.data-privacy-guidelines.outcomes": "Shared understanding of the purpose and use of Data Privacy Guidelines",
+  "resource.data-privacy-guidelines.outcomes.1": "A consistent approach to applying Data Privacy Guidelines",
+  "resource.data-privacy-guidelines.outcomes.2": "Improved application of the related practices",
   "resource.data-privacy-guidelines.steps": "Ensure user data privacy by implementing data protection measures, such as anonymization and access controls.",
-  "resource.data-privacy-guidelines.tips": "Customize the Data Privacy Guidelines for your domain",
-  "resource.data-privacy-guidelines.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.data-privacy-guidelines.tips": "Adapt this resource to your context.",
+  "resource.data-privacy-guidelines.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.domain-canvas.title": "Domain Canvas",
-  "resource.domain-canvas.description": "A modeling tool to define and communicate the key entities and relationships in your domain, ensuring semantic consistency across APIs.",
-  "resource.domain-canvas.outcomes": "Better understanding of domain canvas principles",
-  "resource.domain-canvas.outcomes.1": "Standardized approach using Domain Canvas",
-  "resource.domain-canvas.outcomes.2": "Improved implementation of related API practices",
-  "resource.domain-canvas.steps": "Define core entities, their attributes, and relationships to create a shared conceptual understanding across APIs.",
-  "resource.domain-canvas.tips": "Customize the Domain Canvas for your domain",
-  "resource.domain-canvas.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.domain-canvas.description": "A modeling tool to define and communicate the key entities and relationships in your domain, ensuring semantic consistency across capabilities, integrations, APIs, data products, and services.",
+  "resource.domain-canvas.outcomes": "Shared domain model and terminology",
+  "resource.domain-canvas.outcomes.1": "Core entities, relationships, rules, and ownership clarified",
+  "resource.domain-canvas.outcomes.2": "Semantic consistency across capabilities, integrations, APIs, data products, and services",
+  "resource.domain-canvas.steps": "Define core entities, their attributes, and relationships to create a shared conceptual understanding across capabilities, integrations, APIs, data products, and services.",
+  "resource.domain-canvas.tips": "Use business language first; map it to technical models only after the domain is understood.",
+  "resource.domain-canvas.tips.1": "Validate the model with domain experts, producers, and consumers.",
   "resource.ecosystem-vision-template.title": "Ecosystem Vision Template",
   "resource.ecosystem-vision-template.description": "A strategic planning tool to define the API ecosystem, including target partners, value chains, and integration opportunities.",
-  "resource.ecosystem-vision-template.outcomes": "Better understanding of ecosystem vision template principles",
-  "resource.ecosystem-vision-template.outcomes.1": "Standardized approach using Ecosystem Vision Template",
-  "resource.ecosystem-vision-template.outcomes.2": "Improved implementation of related API practices",
+  "resource.ecosystem-vision-template.outcomes": "Shared understanding of the purpose and use of Ecosystem Vision Template",
+  "resource.ecosystem-vision-template.outcomes.1": "A consistent approach to applying Ecosystem Vision Template",
+  "resource.ecosystem-vision-template.outcomes.2": "Improved application of the related practices",
   "resource.ecosystem-vision-template.steps": "Conduct market research to identify trends, opportunities, and threats in the API landscape.",
   "resource.ecosystem-vision-template.steps.1": "Identify key ecosystem partners and stakeholders who will benefit from or contribute to the ecosystem.",
   "resource.ecosystem-vision-template.steps.2": "Identify gaps in the market that your APIs can fill, based on competitor offerings.",
@@ -174,83 +174,83 @@
   "resource.ecosystem-vision-template.steps.4": "Develop a differentiation strategy that highlights unique features and benefits of your APIs.",
   "resource.ecosystem-vision-template.steps.5": "Define the ecosystem vision for your APIs, including how they will interact with other systems and platforms.",
   "resource.ecosystem-vision-template.steps.6": "Design APIs to enable seamless integration and collaboration within the ecosystem.",
-  "resource.ecosystem-vision-template.tips": "Customize the Ecosystem Vision Template for your domain",
-  "resource.ecosystem-vision-template.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.ecosystem-vision-template.tips": "Adapt this resource to your context.",
+  "resource.ecosystem-vision-template.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.industry-standards-and-best-practices.title": "Industry Standards And Best Practices",
   "resource.industry-standards-and-best-practices.description": "A reference resource for aligning API design and operation with widely recognized industry frameworks and specifications.",
-  "resource.industry-standards-and-best-practices.outcomes": "Better understanding of industry standards and best practices principles",
-  "resource.industry-standards-and-best-practices.outcomes.1": "Standardized approach using Industry Standards And Best Practices",
-  "resource.industry-standards-and-best-practices.outcomes.2": "Improved implementation of related API practices",
+  "resource.industry-standards-and-best-practices.outcomes": "Shared understanding of the purpose and use of Industry Standards And Best Practices",
+  "resource.industry-standards-and-best-practices.outcomes.1": "A consistent approach to applying Industry Standards And Best Practices",
+  "resource.industry-standards-and-best-practices.outcomes.2": "Improved application of the related practices",
   "resource.industry-standards-and-best-practices.steps": "Identify industry standards and best practices to ensure APIs are competitive and compliant.",
-  "resource.industry-standards-and-best-practices.tips": "Customize the Industry Standards And Best Practices for your domain",
-  "resource.industry-standards-and-best-practices.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.industry-standards-and-best-practices.tips": "Adapt this resource to your context.",
+  "resource.industry-standards-and-best-practices.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.partner-integration-guidelines.title": "Partner Integration Guidelines",
   "resource.partner-integration-guidelines.description": "Integration checklists and communication patterns to manage technical and legal aspects of third-party API relationships.",
-  "resource.partner-integration-guidelines.outcomes": "Better understanding of partner integration guidelines principles",
-  "resource.partner-integration-guidelines.outcomes.1": "Standardized approach using Partner Integration Guidelines",
-  "resource.partner-integration-guidelines.outcomes.2": "Improved implementation of related API practices",
+  "resource.partner-integration-guidelines.outcomes": "Shared understanding of the purpose and use of Partner Integration Guidelines",
+  "resource.partner-integration-guidelines.outcomes.1": "A consistent approach to applying Partner Integration Guidelines",
+  "resource.partner-integration-guidelines.outcomes.2": "Improved application of the related practices",
   "resource.partner-integration-guidelines.steps": "Establish integration processes and guidelines for collaborating with partners, including technical integration, data sharing, and support.",
   "resource.partner-integration-guidelines.steps.1": "Monitor partner API performance and compliance to ensure reliability and alignment with your API strategy.",
-  "resource.partner-integration-guidelines.tips": "Customize the Partner Integration Guidelines for your domain",
-  "resource.partner-integration-guidelines.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.partner-integration-guidelines.tips": "Adapt this resource to your context.",
+  "resource.partner-integration-guidelines.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.role-communication-best-practices.title": "Role Communication Best Practices",
   "resource.role-communication-best-practices.description": "Tools to define and document who is responsible for what within API initiatives, ensuring handoffs and accountability are clear.",
-  "resource.role-communication-best-practices.outcomes": "Better understanding of role communication best practices principles",
-  "resource.role-communication-best-practices.outcomes.1": "Standardized approach using Role Communication Best Practices",
-  "resource.role-communication-best-practices.outcomes.2": "Improved implementation of related API practices",
+  "resource.role-communication-best-practices.outcomes": "Shared understanding of the purpose and use of Role Communication Best Practices",
+  "resource.role-communication-best-practices.outcomes.1": "A consistent approach to applying Role Communication Best Practices",
+  "resource.role-communication-best-practices.outcomes.2": "Improved application of the related practices",
   "resource.role-communication-best-practices.steps": "Establish clear responsibilities for each role, including API design, development, testing, and operations.",
   "resource.role-communication-best-practices.steps.1": "Ensure roles and responsibilities are communicated to all team members and stakeholders to ensure alignment.",
-  "resource.role-communication-best-practices.tips": "Customize the Role Communication Best Practices for your domain",
-  "resource.role-communication-best-practices.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.role-communication-best-practices.tips": "Adapt this resource to your context.",
+  "resource.role-communication-best-practices.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.scalable-infrastructure-best-practices.title": "Scalable Infrastructure Best Practices",
   "resource.scalable-infrastructure-best-practices.description": "Architectural guidance to ensure APIs are deployed on infrastructure that can elastically handle usage spikes and growth.",
-  "resource.scalable-infrastructure-best-practices.outcomes": "Better understanding of scalable infrastructure best practices principles",
-  "resource.scalable-infrastructure-best-practices.outcomes.1": "Standardized approach using Scalable Infrastructure Best Practices",
-  "resource.scalable-infrastructure-best-practices.outcomes.2": "Improved implementation of related API practices",
+  "resource.scalable-infrastructure-best-practices.outcomes": "Shared understanding of the purpose and use of Scalable Infrastructure Best Practices",
+  "resource.scalable-infrastructure-best-practices.outcomes.1": "A consistent approach to applying Scalable Infrastructure Best Practices",
+  "resource.scalable-infrastructure-best-practices.outcomes.2": "Improved application of the related practices",
   "resource.scalable-infrastructure-best-practices.steps": "Design API infrastructure to be scalable and resilient, using cloud-native patterns and technologies.",
   "resource.scalable-infrastructure-best-practices.steps.1": "Monitor infrastructure performance and capacity to ensure it can handle growing demand.",
-  "resource.scalable-infrastructure-best-practices.tips": "Customize the Scalable Infrastructure Best Practices for your domain",
-  "resource.scalable-infrastructure-best-practices.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.scalable-infrastructure-best-practices.tips": "Adapt this resource to your context.",
+  "resource.scalable-infrastructure-best-practices.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.service-agreement-template.title": "Service Agreement Template",
   "resource.service-agreement-template.description": "A customizable agreement format that defines expectations, SLAs, responsibilities, and access terms for API consumption.",
-  "resource.service-agreement-template.outcomes": "Better understanding of service agreement template principles",
-  "resource.service-agreement-template.outcomes.1": "Standardized approach using Service Agreement Template",
-  "resource.service-agreement-template.outcomes.2": "Improved implementation of related API practices",
+  "resource.service-agreement-template.outcomes": "Shared understanding of the purpose and use of Service Agreement Template",
+  "resource.service-agreement-template.outcomes.1": "A consistent approach to applying Service Agreement Template",
+  "resource.service-agreement-template.outcomes.2": "Improved application of the related practices",
   "resource.service-agreement-template.steps": "Define service agreements that outline the expectations, service levels, and responsibilities for each API.",
   "resource.service-agreement-template.steps.1": "Use standardized formats to create machine-readable service agreements that are easy to share and validate.",
   "resource.service-agreement-template.steps.2": "Ensure service agreements are reviewed and approved by stakeholders to ensure alignment and clarity.",
-  "resource.service-agreement-template.tips": "Customize the Service Agreement Template for your domain",
-  "resource.service-agreement-template.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.service-agreement-template.tips": "Adapt this resource to your context.",
+  "resource.service-agreement-template.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.stakeholder-engagement-best-practices.title": "Stakeholder Engagement Best Practices",
   "resource.stakeholder-engagement-best-practices.description": "Engagement tactics for aligning internal and external stakeholders around shared API goals, value, and governance.",
-  "resource.stakeholder-engagement-best-practices.outcomes": "Better understanding of stakeholder engagement best practices principles",
-  "resource.stakeholder-engagement-best-practices.outcomes.1": "Standardized approach using Stakeholder Engagement Best Practices",
-  "resource.stakeholder-engagement-best-practices.outcomes.2": "Improved implementation of related API practices",
+  "resource.stakeholder-engagement-best-practices.outcomes": "Shared understanding of the purpose and use of Stakeholder Engagement Best Practices",
+  "resource.stakeholder-engagement-best-practices.outcomes.1": "A consistent approach to applying Stakeholder Engagement Best Practices",
+  "resource.stakeholder-engagement-best-practices.outcomes.2": "Improved application of the related practices",
   "resource.stakeholder-engagement-best-practices.steps": "Engage stakeholders to ensure alignment and support for API initiatives.",
-  "resource.stakeholder-engagement-best-practices.tips": "Customize the Stakeholder Engagement Best Practices for your domain",
-  "resource.stakeholder-engagement-best-practices.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.stakeholder-engagement-best-practices.tips": "Adapt this resource to your context.",
+  "resource.stakeholder-engagement-best-practices.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.test-automation-frameworks.title": "Test Automation Frameworks",
-  "resource.test-automation-frameworks.description": "Recommended tools and patterns for automating API contract, regression, and integration testing across environments.",
-  "resource.test-automation-frameworks.outcomes": "Better understanding of test automation frameworks principles",
-  "resource.test-automation-frameworks.outcomes.1": "Standardized approach using Test Automation Frameworks",
-  "resource.test-automation-frameworks.outcomes.2": "Improved implementation of related API practices",
+  "resource.test-automation-frameworks.description": "Recommended tools and patterns for automating API interface contract, regression, and integration testing across environments.",
+  "resource.test-automation-frameworks.outcomes": "Shared understanding of the purpose and use of Test Automation Frameworks",
+  "resource.test-automation-frameworks.outcomes.1": "A consistent approach to applying Test Automation Frameworks",
+  "resource.test-automation-frameworks.outcomes.2": "Improved application of the related practices",
   "resource.test-automation-frameworks.steps": "Implement test automation frameworks that support contract testing, integration testing, and end-to-end testing.",
-  "resource.test-automation-frameworks.tips": "Customize the Test Automation Frameworks for your domain",
-  "resource.test-automation-frameworks.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.test-automation-frameworks.tips": "Adapt this resource to your context.",
+  "resource.test-automation-frameworks.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.vendor-management-best-practices.title": "Vendor Management Best Practices",
   "resource.vendor-management-best-practices.description": "Framework for evaluating and managing external API vendors and third-party integrations based on risk, performance, and compliance.",
-  "resource.vendor-management-best-practices.outcomes": "Better understanding of vendor management best practices principles",
-  "resource.vendor-management-best-practices.outcomes.1": "Standardized approach using Vendor Management Best Practices",
-  "resource.vendor-management-best-practices.outcomes.2": "Improved implementation of related API practices",
+  "resource.vendor-management-best-practices.outcomes": "Shared understanding of the purpose and use of Vendor Management Best Practices",
+  "resource.vendor-management-best-practices.outcomes.1": "A consistent approach to applying Vendor Management Best Practices",
+  "resource.vendor-management-best-practices.outcomes.2": "Improved application of the related practices",
   "resource.vendor-management-best-practices.steps": "Establish vendor management processes to evaluate, onboard, and monitor third-party API vendors.",
   "resource.vendor-management-best-practices.steps.1": "Define criteria for evaluating vendor APIs, including reliability, security, and compliance.",
-  "resource.vendor-management-best-practices.tips": "Customize the Vendor Management Best Practices for your domain",
-  "resource.vendor-management-best-practices.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.vendor-management-best-practices.tips": "Adapt this resource to your context.",
+  "resource.vendor-management-best-practices.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.api-audit-checklist.title": "API Audit Checklist",
   "resource.api-audit-checklist.description": "A lifecycle-based checklist to verify API readiness across design, delivery, publishing, and compliance using defined audit criteria and evidence.",
-  "resource.api-audit-checklist.outcomes": "Better understanding of API audit checklist principles",
-  "resource.api-audit-checklist.outcomes.1": "Standardized approach using API Audit Checklist",
-  "resource.api-audit-checklist.outcomes.2": "Improved implementation of related API practices",
+  "resource.api-audit-checklist.outcomes": "Shared understanding of the purpose and use of API Audit Checklist",
+  "resource.api-audit-checklist.outcomes.1": "A consistent approach to applying API Audit Checklist",
+  "resource.api-audit-checklist.outcomes.2": "Improved application of the related practices",
   "resource.api-audit-checklist.steps": "Use the API Audit Checklist to ensure the API design meets functional and non-functional requirements, including security, performance, and compliance.",
   "resource.api-audit-checklist.steps.1": "Conduct audits to assess lifecycle coverage and verify that the API meets business, design, and operational standards.",
   "resource.api-audit-checklist.steps.2": "Ensure that documentation, security models, gateway configuration, and legal requirements are clearly defined, validated, and supported by evidence.",
@@ -265,7 +265,7 @@
   "resource.api-business-model-canvas.steps.1": "Define consumer segments",
   "resource.api-business-model-canvas.steps.2": "Identify developer relations strategies",
   "resource.api-business-model-canvas.steps.3": "Map distribution channels",
-  "resource.api-business-model-canvas.steps.4": "document key resources and activities",
+  "resource.api-business-model-canvas.steps.4": "Document key resources and activities",
   "resource.api-business-model-canvas.steps.5": "Identify key partners and stakeholders",
   "resource.api-business-model-canvas.steps.6": "Highlight benefits and costs",
   "resource.api-business-model-canvas.tips": "Start with a single API to ensure clarity",
@@ -273,16 +273,16 @@
   "resource.api-business-model-canvas.tips.2": "Validate outputs with key stakeholders",
   "resource.api-design-principles.title": "API Design Principles",
   "resource.api-design-principles.description": "A concise guide to API usability, discoverability, and consistency grounded in shared design rules and real consumer needs.",
-  "resource.api-design-principles.outcomes": "Better understanding of API design principles principles",
-  "resource.api-design-principles.outcomes.1": "Standardized approach using API Design Principles",
-  "resource.api-design-principles.outcomes.2": "Improved implementation of related API practices",
+  "resource.api-design-principles.outcomes": "Shared understanding of the purpose and use of API Design Principles",
+  "resource.api-design-principles.outcomes.1": "A consistent approach to applying API Design Principles",
+  "resource.api-design-principles.outcomes.2": "Improved application of the related practices",
   "resource.api-design-principles.steps": "**Consumer-first design:** start every APIOps cycle by gathering user goals and domain terms so APIs solve real problems.",
   "resource.api-design-principles.steps.1": "**Consistent naming and behavior:** apply shared conventions for resources, errors and formats to make APIs predictable.",
   "resource.api-design-principles.steps.2": "**Contract driven:** capture the interface with OpenAPI or AsyncAPI before coding to align teams and enable automation.",
   "resource.api-design-principles.steps.3": "**Usability and discoverability:** provide clear documentation and examples so developers quickly understand how to use the API.",
   "resource.api-design-principles.steps.4": "**Iterate safely:** evolve designs in small, versioned increments so changes do not disrupt existing consumers.",
-  "resource.api-design-principles.tips": "Customize the API Design Principles for your domain",
-  "resource.api-design-principles.tips.1": "Use it collaboratively across business and tech roles",
+  "resource.api-design-principles.tips": "Adapt this resource to your context.",
+  "resource.api-design-principles.tips.1": "Use this resource collaboratively across relevant business and technical roles.",
   "resource.api-value-proposition-canvas.title": "API Value Proposition Canvas",
   "resource.api-value-proposition-canvas.description": "Align API features with user needs by mapping tasks, pains, and gains to API products.",
   "resource.api-value-proposition-canvas.outcomes": "Focused feature development",
@@ -296,37 +296,37 @@
   "resource.api-value-proposition-canvas.tips.1": "Highlight features that relieve pains or enhance gains",
   "resource.api-value-proposition-canvas.tips.2": "Validate features with API consumers to ensure alignment",
   "resource.business-impact-canvas.title": "Business Impact Canvas",
-  "resource.business-impact-canvas.description": "Design a scalable and secure API platform architecture that meets business and technical requirements.",
-  "resource.business-impact-canvas.outcomes": "Scalable API infrastructure",
-  "resource.business-impact-canvas.outcomes.1": "Enhanced security and compliance",
-  "resource.business-impact-canvas.outcomes.2": "Improved API performance",
+  "resource.business-impact-canvas.description": "Identify business, availability, security, data, compliance, and operational risks that should shape architecture and platform decisions.",
+  "resource.business-impact-canvas.outcomes": "Documented business and operational impact assessment",
+  "resource.business-impact-canvas.outcomes.1": "Prioritized risks and mitigation actions",
+  "resource.business-impact-canvas.outcomes.2": "Evidence for architecture and platform decisions",
   "resource.business-impact-canvas.steps": "Availability Risks: Identify risks and impacts.",
   "resource.business-impact-canvas.steps.1": "Ways to Mitigate Availability Risks: Define mitigation measures.",
   "resource.business-impact-canvas.steps.2": "Security Risks: Document security-related risks.",
   "resource.business-impact-canvas.steps.3": "Ways to Mitigate Security Risks: Propose strategies to mitigate security risks.",
   "resource.business-impact-canvas.steps.4": "Data Risks: Identify risks to data accuracy or availability.",
   "resource.business-impact-canvas.steps.5": "Ways to Mitigate Data Risks: Plan strategies to address data risks.",
-  "resource.business-impact-canvas.tips": "Involve architects and developers in the design process",
-  "resource.business-impact-canvas.tips.1": "Use past incidents to identify potential risks",
-  "resource.business-impact-canvas.tips.2": "Prioritize critical APIs with the highest business impact",
+  "resource.business-impact-canvas.tips": "Complete this before selecting or confirming the implementation style.",
+  "resource.business-impact-canvas.tips.1": "Review the risks with both business and technical stakeholders.",
+  "resource.business-impact-canvas.tips.2": "Use past incidents and operational evidence to challenge assumptions.",
   "resource.capacity-canvas.title": "Capacity Canvas",
-  "resource.capacity-canvas.description": "Plan API capacity to meet current and future business demands, ensuring scalability and performance.",
-  "resource.capacity-canvas.outcomes": "Aligned API capacity with business volumes",
-  "resource.capacity-canvas.outcomes.1": "Prepared for future consumption trends",
-  "resource.capacity-canvas.outcomes.2": "Defined caching and rate-limiting strategies",
+  "resource.capacity-canvas.description": "Plan capacity for current and future demand, including volumes, peaks, latency, availability, scaling, caching, and rate limits for the selected capability and implementation style.",
+  "resource.capacity-canvas.outcomes": "Capacity requirements aligned with expected business demand",
+  "resource.capacity-canvas.outcomes.1": "Peak-load, availability, and growth assumptions documented",
+  "resource.capacity-canvas.outcomes.2": "Scaling, caching, and rate-limiting decisions defined",
   "resource.capacity-canvas.steps": "Document current business volumes",
   "resource.capacity-canvas.steps.1": "Forecast future consumption trends",
   "resource.capacity-canvas.steps.2": "Plan for peak load and availability requirements",
   "resource.capacity-canvas.steps.3": "Define caching and rate-limiting strategies",
   "resource.capacity-canvas.steps.4": "Propose scaling strategies",
-  "resource.capacity-canvas.tips": "Use analytics to forecast growth trends",
-  "resource.capacity-canvas.tips.1": "Define peak usage scenarios",
-  "resource.capacity-canvas.tips.2": "Include scalability testing in the planning phase",
+  "resource.capacity-canvas.tips": "Complete this before finalizing architecture and platform decisions.",
+  "resource.capacity-canvas.tips.1": "Use measured data where available and state assumptions explicitly.",
+  "resource.capacity-canvas.tips.2": "Revisit the canvas after pilots or material changes in demand.",
   "resource.customer-journey-canvas.title": "Customer Journey Canvas",
-  "resource.customer-journey-canvas.description": "Map customer journeys to identify needs and pain points, enhancing API design and user experience.",
-  "resource.customer-journey-canvas.outcomes": "Improved customer understanding",
-  "resource.customer-journey-canvas.outcomes.1": "Enhanced API design",
-  "resource.customer-journey-canvas.outcomes.2": "Better user experience",
+  "resource.customer-journey-canvas.description": "Map customer, partner, or consumer journeys to identify needs, pain points, gains, inputs, outputs, and experience expectations.",
+  "resource.customer-journey-canvas.outcomes": "Shared understanding of the customer, partner, or consumer journey",
+  "resource.customer-journey-canvas.outcomes.1": "Needs, pain points, gains, inputs, and outputs documented",
+  "resource.customer-journey-canvas.outcomes.2": "Journey evidence available for capability, requirements, and architecture decisions",
   "resource.customer-journey-canvas.steps": "Define customer persona",
   "resource.customer-journey-canvas.steps.1": "Identify triggers for the journey",
   "resource.customer-journey-canvas.steps.2": "Describe the journey's end",
@@ -334,20 +334,20 @@
   "resource.customer-journey-canvas.steps.4": "Identify customer pains",
   "resource.customer-journey-canvas.steps.5": "Summarize customer gains",
   "resource.customer-journey-canvas.steps.6": "Define necessary inputs and resulting outputs",
-  "resource.customer-journey-canvas.steps.7": "Define API interactions for each step",
-  "resource.customer-journey-canvas.tips": "Iterate with team input to refine steps",
-  "resource.customer-journey-canvas.tips.1": "Use outputs from this canvas to inform other canvases like the API Value Proposition Canvas",
+  "resource.customer-journey-canvas.steps.7": "Define interactions and processing expectations for each step",
+  "resource.customer-journey-canvas.tips": "Validate the journey with people who perform or experience it.",
+  "resource.customer-journey-canvas.tips.1": "Use the results to inform value proposition, domain, requirements, and architecture work.",
   "resource.event-canvas.title": "Event Canvas",
-  "resource.event-canvas.description": "Design event-driven APIs by defining events, triggers, and processing logic.",
-  "resource.event-canvas.outcomes": "Defined event-driven architecture",
-  "resource.event-canvas.outcomes.1": "Clear event triggers and processing logic",
-  "resource.event-canvas.outcomes.2": "Improved responsiveness to real-time changes",
+  "resource.event-canvas.description": "Design event-driven interfaces and integrations by defining events, triggers, schemas, producers, consumers, and processing logic.",
+  "resource.event-canvas.outcomes": "Defined event-driven interaction model",
+  "resource.event-canvas.outcomes.1": "Events, triggers, schemas, producers, and consumers clarified",
+  "resource.event-canvas.outcomes.2": "Processing, acknowledgement, and failure expectations documented",
   "resource.event-canvas.steps": "Identify key events in the system",
   "resource.event-canvas.steps.1": "Define triggers for each event",
-  "resource.event-canvas.steps.2": "Describe backend processing logic for events",
+  "resource.event-canvas.steps.2": "Describe event processing, state changes, and failure handling.",
   "resource.event-canvas.steps.3": "Specify resulting outputs or acknowledgments",
   "resource.event-canvas.tips": "Use event schemas to standardize event formats",
-  "resource.event-canvas.tips.1": "document event flows and dependencies",
+  "resource.event-canvas.tips.1": "Document event flows, ownership, ordering assumptions, and dependencies.",
   "resource.event-canvas.tips.2": "Validate event processing with test cases",
   "resource.graphql-canvas.title": "GraphQL Canvas",
   "resource.graphql-canvas.description": "Design GraphQL APIs by defining types, queries, mutations, and subscriptions.",
@@ -363,31 +363,31 @@
   "resource.graphql-canvas.steps.6": "Define authentication and authorization: Who can access which fields or types?",
   "resource.graphql-canvas.steps.7": "Consider if there are any pagination, filtering, or rate-limiting constraints",
   "resource.graphql-canvas.tips": "Use introspection to validate type definitions",
-  "resource.graphql-canvas.tips.1": "document example queries and mutations",
+  "resource.graphql-canvas.tips.1": "Document example queries and mutations",
   "resource.graphql-canvas.tips.2": "Ensure type names are descriptive and consistent",
   "resource.interaction-canvas.title": "Interaction Canvas",
-  "resource.interaction-canvas.description": "Define API interactions, workflows, and expected responses to ensure a consistent API consumer experience.",
-  "resource.interaction-canvas.outcomes": "Clear API interaction workflows",
-  "resource.interaction-canvas.outcomes.1": "Defined inputs and outputs for each interaction",
-  "resource.interaction-canvas.outcomes.2": "Consistent validation rules across interactions",
-  "resource.interaction-canvas.steps": "Map API interactions to user tasks",
-  "resource.interaction-canvas.steps.1": "Define endpoints for each interaction",
-  "resource.interaction-canvas.steps.2": "document inputs and outputs for each interaction",
+  "resource.interaction-canvas.description": "Define interactions, workflows, inputs, outputs, commands, queries, events, and expected responses to ensure a consistent consumer experience.",
+  "resource.interaction-canvas.outcomes": "Defined interaction model for the selected capability",
+  "resource.interaction-canvas.outcomes.1": "Inputs, outputs, commands, queries, events, and responses clarified",
+  "resource.interaction-canvas.outcomes.2": "Validation rules and interaction expectations agreed",
+  "resource.interaction-canvas.steps": "Map interactions to user, consumer, or system tasks",
+  "resource.interaction-canvas.steps.1": "Define access points, operations, commands, queries, or events for each interaction",
+  "resource.interaction-canvas.steps.2": "Document inputs and outputs for each interaction.",
   "resource.interaction-canvas.steps.3": "Specify validation rules and constraints",
   "resource.interaction-canvas.steps.4": "Create interaction models for CRUD, query-driven, command-driven, and event-driven interactions",
   "resource.interaction-canvas.tips": "Start with common use cases before handling edge cases",
   "resource.interaction-canvas.tips.1": "Simulate interactions with mock data to validate workflows",
-  "resource.interaction-canvas.tips.2": "document expected responses for successful and unsuccessful interactions",
+  "resource.interaction-canvas.tips.2": "Document expected responses for successful, unsuccessful, and exceptional interactions.",
   "resource.location-canvas.title": "Location Canvas",
-  "resource.location-canvas.description": "Map API provider and consumer locations to ensure compliance and performance across regions.",
-  "resource.location-canvas.outcomes": "Compliance with local regulations",
-  "resource.location-canvas.outcomes.1": "Optimized API performance across regions",
-  "resource.location-canvas.outcomes.2": "Enhanced understanding of regional requirements",
-  "resource.location-canvas.steps": "Map locations of API providers.",
+  "resource.location-canvas.description": "Map consumer, producer, system, data, network, regulatory, and trust-boundary locations to ensure compliance and performance across regions.",
+  "resource.location-canvas.outcomes": "Documented location, residency, network, and regulatory requirements",
+  "resource.location-canvas.outcomes.1": "Regional performance and accessibility constraints identified",
+  "resource.location-canvas.outcomes.2": "Data residency, trust boundaries, and applicable regulations clarified",
+  "resource.location-canvas.steps": "Map locations of producers, source systems, platforms, and consumers.",
   "resource.location-canvas.steps.1": "Document where consumers are located.",
   "resource.location-canvas.steps.2": "Identify applicable regulations.",
   "resource.location-canvas.steps.3": "Document where data must reside.",
-  "resource.location-canvas.steps.4": "nsure APIs are accessible in all intended network regions.",
+  "resource.location-canvas.steps.4": "Ensure the capability is accessible in all intended network regions.",
   "resource.location-canvas.steps.5": "Validate network performance across regions.",
   "resource.location-canvas.tips": "Collaborate with legal and compliance teams",
   "resource.location-canvas.tips.1": "Validate network performance across key regions",
@@ -403,5 +403,143 @@
   "resource.rest-canvas.steps.3": "Provide example requests and responses for each verb",
   "resource.rest-canvas.tips": "Use standard HTTP methods (GET, POST, PUT, DELETE)",
   "resource.rest-canvas.tips.1": "Ensure resource URIs are intuitive and consistent",
-  "resource.rest-canvas.tips.2": "document error handling and response codes"
+  "resource.rest-canvas.tips.2": "Document error handling and response codes",
+  "resource.capability-value-proposition-canvas.title": "Capability Value Proposition Canvas",
+  "resource.capability-value-proposition-canvas.description": "A technology-agnostic canvas for mapping consumer tasks, gains, pains, and candidate reusable capabilities before selecting an implementation style.",
+  "resource.capability-value-proposition-canvas.outcomes": "Clear reusable capability value proposition",
+  "resource.capability-value-proposition-canvas.outcomes.1": "Consumer tasks, gains, and pains captured without assuming a technology",
+  "resource.capability-value-proposition-canvas.outcomes.2": "Candidate reusable capabilities identified for architecture evaluation",
+  "resource.capability-value-proposition-canvas.steps": "List the consumer tasks and outcomes the capability should support.",
+  "resource.capability-value-proposition-canvas.steps.1": "Identify gain-enabling capability features.",
+  "resource.capability-value-proposition-canvas.steps.2": "Identify pain-relieving capability features.",
+  "resource.capability-value-proposition-canvas.steps.3": "Group the features into candidate reusable capabilities.",
+  "resource.capability-value-proposition-canvas.tips": "Stay technology agnostic until the requirements indicate a suitable implementation style.",
+  "resource.capability-value-proposition-canvas.tips.1": "Use this instead of the API Value Proposition Canvas when an API is not yet the selected implementation style.",
+  "resource.capability-business-model-canvas.title": "Capability Business Model Canvas",
+  "resource.capability-business-model-canvas.description": "A business model canvas for reusable capabilities, covering value, consumers, ownership, engagement, costs, and benefits without assuming an implementation style.",
+  "resource.capability-business-model-canvas.outcomes": "Viable reusable capability operating model",
+  "resource.capability-business-model-canvas.outcomes.1": "Ownership, consumers, channels, partners, and support needs clarified",
+  "resource.capability-business-model-canvas.outcomes.2": "Costs and benefits visible before architecture commitment",
+  "resource.capability-business-model-canvas.steps": "Summarize the capability value proposition.",
+  "resource.capability-business-model-canvas.steps.1": "Identify consumer segments and engagement channels.",
+  "resource.capability-business-model-canvas.steps.2": "Define key activities, resources, and partners.",
+  "resource.capability-business-model-canvas.steps.3": "Capture costs and benefits.",
+  "resource.capability-business-model-canvas.steps.4": "Clarify ownership, funding, support, and lifecycle expectations.",
+  "resource.capability-business-model-canvas.steps.5": "Validate the model with consumers, producers, and governance stakeholders.",
+  "resource.capability-business-model-canvas.tips": "Use this instead of the API Business Model Canvas while the implementation style remains open.",
+  "resource.capability-business-model-canvas.tips.1": "Keep the focus on reusable capability viability, not a one-off connection.",
+  "resource.consumer-experience-requirements-canvas.title": "Consumer Experience Requirements Canvas",
+  "resource.consumer-experience-requirements-canvas.description": "A requirements canvas for consumer experience and non-functional needs that should guide the later architecture and implementation-style decision.",
+  "resource.consumer-experience-requirements-canvas.outcomes": "Technology-agnostic consumer and service requirements",
+  "resource.consumer-experience-requirements-canvas.outcomes.1": "Experience and non-functional needs captured before design starts",
+  "resource.consumer-experience-requirements-canvas.outcomes.2": "Architecture implications documented for implementation-style selection",
+  "resource.consumer-experience-requirements-canvas.steps": "Capture consumer goals and usage context.",
+  "resource.consumer-experience-requirements-canvas.steps.1": "Document availability, timeliness, volume, performance, data quality, and consistency expectations.",
+  "resource.consumer-experience-requirements-canvas.steps.2": "Document security, privacy, onboarding, change, observability, support, and recovery expectations.",
+  "resource.consumer-experience-requirements-canvas.steps.3": "Summarize what the requirements imply for possible implementation styles.",
+  "resource.consumer-experience-requirements-canvas.tips": "Use this as the bridge between capability value and architecture decision.",
+  "resource.consumer-experience-requirements-canvas.tips.1": "Do not choose an API, event, file, stream, data product, direct integration, or hybrid style until the requirements indicate the fit.",
+  "resource.integration-style-selection-guide.title": "Integration Style Selection Guide",
+  "resource.integration-style-selection-guide.description": "Guidance for choosing between API, event, file, stream, data product, direct integration, or hybrid implementation styles based on requirements and constraints.",
+  "resource.integration-style-selection-guide.outcomes": "Justified integration implementation style",
+  "resource.integration-style-selection-guide.outcomes.1": "Tradeoffs documented across integration style options",
+  "resource.integration-style-selection-guide.outcomes.2": "Selected style traceable to consumer, platform, data, and operational requirements",
+  "resource.integration-style-selection-guide.steps": "Compare viable integration styles against latency, volume, coupling, data ownership, freshness, governance, and operability needs.",
+  "resource.integration-style-selection-guide.steps.1": "Identify when API, event, file, stream, data product, direct integration, or hybrid approaches fit the use case.",
+  "resource.integration-style-selection-guide.steps.2": "Document constraints, risks, and platform dependencies for the selected implementation style.",
+  "resource.integration-style-selection-guide.steps.3": "Record why rejected alternatives were not selected.",
+  "resource.integration-style-selection-guide.tips": "Use after requirements are explicit and before detailed contract design starts.",
+  "resource.integration-style-selection-guide.tips.1": "Keep REST, event, GraphQL, file, stream, and data product resources as optional follow-on design resources.",
+  "resource.process-workflow-design-guide.title": "Process Workflow Design Guide",
+  "resource.process-workflow-design-guide.description": "Guidance for modeling the process steps, roles, handoffs, decision points, states, inputs, outputs, and exceptions that shape an automation workflow.",
+  "resource.process-workflow-design-guide.outcomes": "Clear automation workflow design",
+  "resource.process-workflow-design-guide.outcomes.1": "Process steps and handoffs documented before implementation",
+  "resource.process-workflow-design-guide.outcomes.2": "Workflow states, inputs, outputs, and exception paths understood",
+  "resource.process-workflow-design-guide.steps": "Map the current and target process flow, including human and system responsibilities.",
+  "resource.process-workflow-design-guide.steps.1": "Identify workflow triggers, states, decisions, data inputs, outputs, and completion criteria.",
+  "resource.process-workflow-design-guide.steps.2": "Document handoffs between users, systems, operations, and support roles.",
+  "resource.process-workflow-design-guide.steps.3": "Confirm which steps should be automated and which require human judgment.",
+  "resource.process-workflow-design-guide.tips": "Keep process design separate from API or integration contract design until the workflow is clear.",
+  "resource.process-workflow-design-guide.tips.1": "Use this as the primary design resource for automation workflows.",
+  "resource.decision-business-rules-guide.title": "Decision And Business Rules Guide",
+  "resource.decision-business-rules-guide.description": "Guidance for capturing rules, thresholds, decisions, approvals, eligibility checks, and rule ownership for automation design.",
+  "resource.decision-business-rules-guide.outcomes": "Explicit decisions and business rules",
+  "resource.decision-business-rules-guide.outcomes.1": "Rules and thresholds documented with owners",
+  "resource.decision-business-rules-guide.outcomes.2": "Automation decisions traceable to policy, process, or business intent",
+  "resource.decision-business-rules-guide.steps": "List decisions the automation must make or support.",
+  "resource.decision-business-rules-guide.steps.1": "Document rule conditions, thresholds, exceptions, approvals, and escalation points.",
+  "resource.decision-business-rules-guide.steps.2": "Identify rule owners and change governance for each decision area.",
+  "resource.decision-business-rules-guide.tips": "Separate stable business rules from configurable operational parameters.",
+  "resource.decision-business-rules-guide.tips.1": "Use examples and edge cases to validate rule interpretation.",
+  "resource.automation-trigger-handoff-exception-guide.title": "Automation Trigger, Handoff And Exception Guide",
+  "resource.automation-trigger-handoff-exception-guide.description": "Guidance for defining automation triggers, human handoffs, exception handling, retries, compensating actions, and support escalation paths.",
+  "resource.automation-trigger-handoff-exception-guide.outcomes": "Defined automation triggers and exception paths",
+  "resource.automation-trigger-handoff-exception-guide.outcomes.1": "Human handoffs and support escalations are explicit",
+  "resource.automation-trigger-handoff-exception-guide.outcomes.2": "Exceptions, retries, and compensating actions are designed before delivery",
+  "resource.automation-trigger-handoff-exception-guide.steps": "Define the events, schedules, user actions, or system states that trigger the automation.",
+  "resource.automation-trigger-handoff-exception-guide.steps.1": "Map handoffs from automation to users, operators, or support teams.",
+  "resource.automation-trigger-handoff-exception-guide.steps.2": "Document exceptions, retry rules, timeout behavior, and fallback paths.",
+  "resource.automation-trigger-handoff-exception-guide.steps.3": "Define alerts and escalation thresholds for failed or ambiguous automation outcomes.",
+  "resource.automation-trigger-handoff-exception-guide.tips": "Design exception paths as first-class workflow behavior, not as afterthoughts.",
+  "resource.automation-trigger-handoff-exception-guide.tips.1": "Include business and operations roles when validating handoffs.",
+  "resource.automation-testing-guide.title": "Automation Testing Guide",
+  "resource.automation-testing-guide.description": "Guidance for testing automated workflows, decisions, integrations, exceptions, rollback behavior, supervision, and user impact before release.",
+  "resource.automation-testing-guide.outcomes": "Validated automation behavior",
+  "resource.automation-testing-guide.outcomes.1": "Workflow, rule, exception, and integration tests defined",
+  "resource.automation-testing-guide.outcomes.2": "Release confidence for automated and human-assisted paths",
+  "resource.automation-testing-guide.steps": "Create tests for happy paths, edge cases, exceptions, retries, and handoffs.",
+  "resource.automation-testing-guide.steps.1": "Validate business rules and decision outcomes with representative data.",
+  "resource.automation-testing-guide.steps.2": "Test rollback, recovery, observability, and manual intervention paths.",
+  "resource.automation-testing-guide.steps.3": "Include users and operators in acceptance testing where the automation changes work practices.",
+  "resource.automation-testing-guide.tips": "Use production-like scenarios and data shapes without exposing sensitive data.",
+  "resource.automation-testing-guide.tips.1": "Keep test evidence available for readiness review.",
+  "resource.automation-operational-ownership-guide.title": "Automation Operational Ownership Guide",
+  "resource.automation-operational-ownership-guide.description": "Guidance for defining ownership, runbooks, supervision, support, monitoring, change control, and continuous improvement responsibilities for automations.",
+  "resource.automation-operational-ownership-guide.outcomes": "Clear automation operating model",
+  "resource.automation-operational-ownership-guide.outcomes.1": "Ownership, support, and escalation responsibilities assigned",
+  "resource.automation-operational-ownership-guide.outcomes.2": "Monitoring and change practices ready for live operation",
+  "resource.automation-operational-ownership-guide.steps": "Define business, technical, and operational owners for the automation.",
+  "resource.automation-operational-ownership-guide.steps.1": "Document runbooks, support paths, monitoring signals, service expectations, and escalation rules.",
+  "resource.automation-operational-ownership-guide.steps.2": "Set change control and review practices for workflow, platform, and rule updates.",
+  "resource.automation-operational-ownership-guide.tips": "Do not release an automation without a named owner for exceptions and ongoing improvement.",
+  "resource.automation-operational-ownership-guide.tips.1": "Make supervision needs visible before delivery planning finishes.",
+  "resource.automation-rollback-supervision-guide.title": "Automation Rollback And Supervision Guide",
+  "resource.automation-rollback-supervision-guide.description": "Guidance for designing rollback, pause, manual override, monitoring, supervision, and recovery paths for automations.",
+  "resource.automation-rollback-supervision-guide.outcomes": "Controlled automation recovery paths",
+  "resource.automation-rollback-supervision-guide.outcomes.1": "Rollback, pause, and override behavior documented",
+  "resource.automation-rollback-supervision-guide.outcomes.2": "Supervision needs and recovery responsibilities defined",
+  "resource.automation-rollback-supervision-guide.steps": "Identify actions that must be reversible, paused, or manually overridden.",
+  "resource.automation-rollback-supervision-guide.steps.1": "Define rollback, compensation, and recovery procedures for failed or incorrect automation outcomes.",
+  "resource.automation-rollback-supervision-guide.steps.2": "Document supervision thresholds, alerts, and manual decision points.",
+  "resource.automation-rollback-supervision-guide.steps.3": "Validate recovery procedures before release.",
+  "resource.automation-rollback-supervision-guide.tips": "Treat rollback and supervision as part of the workflow design and delivery plan.",
+  "resource.automation-rollback-supervision-guide.tips.1": "Use operational incidents and near misses to refine supervision criteria.",
+  "resource.automation-readiness-checklist.title": "Automation Readiness Checklist",
+  "resource.automation-readiness-checklist.description": "A checklist for validating automation workflow, controls, risk, compliance, human oversight, testing evidence, rollback, operations, and release readiness.",
+  "resource.automation-readiness-checklist.outcomes": "Documented automation readiness",
+  "resource.automation-readiness-checklist.outcomes.1": "Known readiness gaps and mitigations before release",
+  "resource.automation-readiness-checklist.outcomes.2": "Evidence for quality, risk, compliance, oversight, and operational approval",
+  "resource.automation-readiness-checklist.steps": "Review workflow design, business rules, controls, access, data handling, and exception paths.",
+  "resource.automation-readiness-checklist.steps.1": "Verify testing evidence, rollback procedures, supervision model, and support readiness.",
+  "resource.automation-readiness-checklist.steps.2": "Confirm ownership, runbooks, monitoring, change controls, and release approval.",
+  "resource.automation-readiness-checklist.steps.3": "Record unresolved gaps, decisions, and accepted risks before release.",
+  "resource.automation-readiness-checklist.tips": "Use before release and again after material workflow or rule changes.",
+  "resource.automation-readiness-checklist.tips.1": "Make human oversight and exception handling explicit in the evidence.",
+  "resource.automation-rollout-enablement-guide.title": "Automation Rollout And Enablement Guide",
+  "resource.automation-rollout-enablement-guide.description": "Guidance for rolling out automations with user communication, onboarding, operating instructions, support paths, change management, and feedback loops.",
+  "resource.automation-rollout-enablement-guide.outcomes": "Enabled automation users and operators",
+  "resource.automation-rollout-enablement-guide.outcomes.1": "Rollout communication, onboarding, and support paths prepared",
+  "resource.automation-rollout-enablement-guide.outcomes.2": "Users and operators understand how work changes after automation release",
+  "resource.automation-rollout-enablement-guide.steps": "Define rollout audiences, timing, communication channels, and training needs.",
+  "resource.automation-rollout-enablement-guide.steps.1": "Publish operating instructions, support paths, exception handling guidance, and escalation contacts.",
+  "resource.automation-rollout-enablement-guide.steps.2": "Plan transition support for users, operators, and process owners.",
+  "resource.automation-rollout-enablement-guide.steps.3": "Collect feedback after rollout and feed improvements into the backlog.",
+  "resource.automation-rollout-enablement-guide.tips": "Use rollout language for automations instead of treating enablement as API publication.",
+  "resource.automation-rollout-enablement-guide.tips.1": "Include both users affected by the process and operators responsible for the automation.",
+  "resource.api-community-engagement-strategies.tips.2": "Use this resource when an API is the selected implementation style.",
+  "resource.api-development-best-practices.tips.2": "Use this resource when an API is the selected implementation style.",
+  "resource.api-metrics-and-analytics.tips.2": "Use this resource when an API is the selected implementation style.",
+  "resource.api-testing-best-practices.tips.2": "Use this resource when an API is the selected implementation style.",
+  "resource.apiops-CI-CD-for-apis.tips.2": "Use this resource when an API is the selected implementation style.",
+  "resource.api-audit-checklist.tips.2": "Use this resource when an API is the selected implementation style."
 }
diff --git a/src/data/method/en/labels.stakeholders.json b/src/data/method/en/labels.stakeholders.json
index d44d506..fd2ec34 100644
--- a/src/data/method/en/labels.stakeholders.json
+++ b/src/data/method/en/labels.stakeholders.json
@@ -3,33 +3,47 @@
   "stakeholder.involvement.core": "Core",
   "stakeholder.involvement.consulted": "Consulted",
   "stakeholder.business-owner.title": "Business Owner",
-  "stakeholder.business-owner.description": "Represents business goals, funding, and expected outcomes for the API initiative.",
+  "stakeholder.business-owner.description": "Represents business goals, funding, and expected outcomes for the capability, API, or automation initiative.",
   "stakeholder.api-program-owner.title": "API Program Owner",
   "stakeholder.api-program-owner.description": "Coordinates API portfolio practices, organizational alignment, and long-term API capability development.",
   "stakeholder.api-product-owner.title": "API Product Owner",
   "stakeholder.api-product-owner.description": "Drives the API opportunity, prioritization, and product-level decisions across the lifecycle.",
-  "stakeholder.domain-expert.title": "Domain Expert",
-  "stakeholder.domain-expert.description": "Brings deep knowledge of the business domain, concepts, rules, and constraints the API must reflect.",
-  "stakeholder.customer-or-partner-representative.title": "Customer or Partner Representative",
-  "stakeholder.customer-or-partner-representative.description": "Contributes the business customer or partner perspective for the journey, value, and collaboration model.",
-  "stakeholder.api-consumer-representative.title": "API Consumer Representative",
-  "stakeholder.api-consumer-representative.description": "Represents the needs of developers, integrators, or other API consumers who use the API directly.",
+  "stakeholder.capability-owner.title": "Capability Owner",
+  "stakeholder.capability-owner.description": "Owns the capability vision, value, priorities, lifecycle, and reuse across consumers.",
+  "stakeholder.domain-specialist.title": "Domain Expert",
+  "stakeholder.domain-specialist.description": "Brings deep knowledge of the business domain, concepts, rules, and constraints the capability or interface must reflect.",
+  "stakeholder.customer-specialist.title": "Customer or Partner Representative",
+  "stakeholder.customer-specialist.description": "Contributes the business customer or partner perspective for the journey, value, and collaboration model.",
+  "stakeholder.api-consumer-specialist.title": "API Consumer Representative",
+  "stakeholder.api-consumer-specialist.description": "Represents the needs of developers, integrators, or other API consumers who use the API directly.",
   "stakeholder.platform-architect.title": "Platform Architect",
-  "stakeholder.platform-architect.description": "Guides platform, integration, scalability, and architecture decisions that shape how the API is built and operated.",
+  "stakeholder.platform-architect.description": "Guides platform, integration, scalability, and architecture decisions that shape how the capability or API is built and operated.",
+  "stakeholder.api-architect.title": "API Architect",
+  "stakeholder.api-architect.description": "Owns API architecture, design principles, and interface contract quality.",
+  "stakeholder.integration-architect.title": "Integration Architect",
+  "stakeholder.integration-architect.description": "Designs integration approaches and implementation styles that connect the capability or API with other systems.",
+  "stakeholder.platform-owner.title": "Platform Owner",
+  "stakeholder.platform-owner.description": "Owns platform capabilities, roadmap, operational model, and service expectations.",
   "stakeholder.api-designer.title": "API Designer",
-  "stakeholder.api-designer.description": "Shapes the API contract, interaction model, consistency, and usability of the exposed capabilities.",
-  "stakeholder.delivery-engineer.title": "Delivery Engineer",
-  "stakeholder.delivery-engineer.description": "Owns implementation, automation, testing, and release flow concerns needed to deliver the API reliably.",
+  "stakeholder.api-designer.description": "Shapes the interface contract, interaction model, consistency, and usability of the exposed capabilities.",
+  "stakeholder.api-engineer.title": "Delivery Engineer",
+  "stakeholder.api-engineer.description": "Owns implementation, automation, testing, and release flow concerns needed to deliver the capability, API, or automation reliably.",
+  "stakeholder.automation-owner.title": "Automation Owner",
+  "stakeholder.automation-owner.description": "Owns automation goals, business value, priorities, controls, and lifecycle outcomes.",
+  "stakeholder.process-owner.title": "Process Owner",
+  "stakeholder.process-owner.description": "Owns the business process being automated, including objectives, rules, outcomes, and improvement priorities.",
+  "stakeholder.automation-engineer.title": "Automation Engineer",
+  "stakeholder.automation-engineer.description": "Implements, tests, integrates, and maintains automation solutions and supporting workflows.",
   "stakeholder.security-specialist.title": "Security Specialist",
   "stakeholder.security-specialist.description": "Ensures security risks, controls, and trust boundaries are addressed throughout the API lifecycle.",
-  "stakeholder.compliance-legal-specialist.title": "Compliance and Legal Specialist",
-  "stakeholder.compliance-legal-specialist.description": "Clarifies legal, privacy, regulatory, and contractual requirements that affect the API.",
-  "stakeholder.governance-owner.title": "API Governance Owner",
-  "stakeholder.governance-owner.description": "Represents review, audit, and organization-wide governance practices for API quality and conformity.",
-  "stakeholder.documentation-devrel-owner.title": "Documentation and DevRel Owner",
-  "stakeholder.documentation-devrel-owner.description": "Owns onboarding content, developer communication, and documentation quality for API consumers.",
-  "stakeholder.support-operations-owner.title": "Support and Operations Owner",
-  "stakeholder.support-operations-owner.description": "Represents runtime support, incident handling, observability, and operational readiness.",
-  "stakeholder.partner-vendor-manager.title": "Partner or Vendor Manager",
-  "stakeholder.partner-vendor-manager.description": "Coordinates external partner, supplier, or vendor relationships that influence API strategy and delivery."
+  "stakeholder.compliance-specialist.title": "Compliance and Legal Specialist",
+  "stakeholder.compliance-specialist.description": "Clarifies legal, privacy, regulatory, and contractual requirements that affect the capability, API, interface, or automation.",
+  "stakeholder.governance-specialist.title": "API Governance Owner",
+  "stakeholder.governance-specialist.description": "Represents review, audit, and organization-wide governance practices for API quality and conformity.",
+  "stakeholder.api-devrel-specialist.title": "Documentation and DevRel Owner",
+  "stakeholder.api-devrel-specialist.description": "Owns onboarding content, developer communication, and documentation quality for API consumers.",
+  "stakeholder.operations-specialist.title": "Support and Operations Owner",
+  "stakeholder.operations-specialist.description": "Represents runtime support, incident handling, observability, and operational readiness for the capability, API, or automation.",
+  "stakeholder.partner-specialist.title": "Partner or Vendor Manager",
+  "stakeholder.partner-specialist.description": "Coordinates external partner, supplier, or vendor relationships that influence capability or API strategy and delivery."
 }
diff --git a/src/data/method/en/labels.stations.json b/src/data/method/en/labels.stations.json
index dc04c36..451db99 100644
--- a/src/data/method/en/labels.stations.json
+++ b/src/data/method/en/labels.stations.json
@@ -1,104 +1,104 @@
 {
-  "group.core-stations.title": "API Lifecycle Core Stations",
-  "group.core-stations.description": "The core stations of the API Metro, where teams can learn how to build and manage APIs effectively.",
-  "station.api-product-strategy.title": "API Product Strategy - Turn APIs Into Strategic Products",
-  "station.api-product-strategy.description": "Before building anything, define your API's value, users, and business goals from day one.",
-  "station.api-product-strategy.why_it_matters": "Many organizations think of APIs as tech projects, not products. The result? Confused consumers, poor adoption, and wasted effort.\n\nThis station helps you define your API’s purpose, target audience, and success criteria, so teams can deliver APIs that solve real problems.",
-  "station.api-product-strategy.apply_in_work": "Provide guidelines and templates for creating API business models, value propositions, and roadmaps.",
-  "station.api-product-strategy.outcomes": "A straightforward API value proposition and audience",
-  "station.api-product-strategy.outcomes.1": "Shared language between product, design, and tech",
-  "station.api-product-strategy.outcomes.2": "A solid pitch or case for funding/approval",
-  "station.api-product-strategy.how_it_works": "Explore the customer or partner problem you expect to solve with APIs. Map the stakeholders, ther journeys and outcomes using the Customer Journey canvas.",
-  "station.api-product-strategy.how_it_works.1": "Define core entities, their attributes, and relationships to create a shared conceptual understanding across journeys and eventually APIs.",
-  "station.api-product-strategy.how_it_works.2": "Use the API Value Proposition Canvas to capture the supported business tasks and the API consumer pains, gains, and features that shape new or reusable APIs.",
-  "station.api-product-strategy.how_it_works.3": "Define the value — for users and the business with the API Business Model canvas to make your API strategy visual, shareable, and easy to validate with your API consumers at the next station.",
-  "station.api-consumer-experience.title": "API Consumer Experience - Design for Your API’s Real Users",
-  "station.api-consumer-experience.description": "Ensure your API is discoverable, understandable, and usable — before and after launch.",
-  "station.api-consumer-experience.why_it_matters": "Great APIs don’t just work — they feel intuitive. Whether your consumer is an internal developer, external partner, or AI agent, their experience determines adoption.\n\nWithout a clear experience plan:\n- Great APIs go unused\n- Teams waste time guessing how to use your API\n- Feedback loops are broken or missing.\n\nThis station helps you see your API through the eyes of its consumers.",
-  "station.api-consumer-experience.how_it_works": "Review the existing API Value Proposition Canvas from the API consumer perspective. Keep the supported business tasks stable, and enrich the pain-relieving and gain-enabling features with API consumer concerns so they can guide later design decisions.",
-  "station.api-consumer-experience.how_it_works.1": "Use the Customer Journey Canvas for the API consumer journey from discovery and evaluation to onboarding, integration, troubleshooting, and ongoing use.",
-  "station.api-consumer-experience.how_it_works.2": "Use the resulting journey to improve onboarding, documentation, support, and feedback loops for the API consumer.",
-  "station.api-consumer-experience.apply_in_work": "Provide guidelines, tools, and feedback mechanisms for understanding, analyzing, and improving internal and external developer and partner experience.",
-  "station.api-consumer-experience.outcomes": "Identify and prioritize your API consumers",
-  "station.api-consumer-experience.outcomes.1": "Define the API experience journey",
-  "station.api-consumer-experience.outcomes.2": "Plan onboarding, documentation, and feedback",
-  "station.api-consumer-experience.outcomes.3": "Improve adoption through genuine empathy + Developer Experience (DX)",
-  "station.api-platform-architecture.title": "API Platform Architecture - Architect APIs for Scalability and Reuse",
-  "station.api-platform-architecture.description": "Ensure scalability, reuse, and governance across your API and platform components.",
-  "station.api-platform-architecture.why_it_matters": "When APIs scale across teams, your platform must enable governance and reuse without blocking speed. This station shows how to architect APIs for longevity, security, and efficiency.",
-  "station.api-platform-architecture.apply_in_work": "Establish a scalable, secure, and compliant infrastructure for API operations. Provide guidelines on architecture best practices.",
-  "station.api-platform-architecture.outcomes": "Cut redundant APIs and reduce cloud platform costs",
-  "station.api-platform-architecture.outcomes.1": "Implement consistent governance without heavy top-down control",
-  "station.api-platform-architecture.outcomes.2": "Design for internal reuse and external scalability",
-  "station.api-platform-architecture.how_it_works": "The Business Impact Canvas helps to identify and mitigate risks related to API availability, security, and functionality to support informed architectural decisions.",
-  "station.api-platform-architecture.how_it_works.1": "Map the regulatory, compliance, and network locations of API providers and consumers to ensure accessibility and compliance.",
-  "station.api-platform-architecture.how_it_works.2": "The Capacity Canvas aligns business transaction patterns, future consumption trends, and technical solutions to ensure API scalability and performance.It provides critical input for scaling decisions and infrastructure planning.",
-  "station.api-platform-architecture.how_it_works.3": "Define and monitor performance metrics (e.g., API calls, latency, error rates) and adoption metrics (e.g., NPS).",
-  "station.api-design.title": "API Design - Design APIs That Deliver Value",
-  "station.api-design.description": "Create API designs that are consistent, reusable, and grounded in business intent and shared standards.",
-  "station.api-design.why_it_matters": "Designing APIs is not just about naming endpoints. Good design ensures APIs are usable, consistent, and aligned with business and technical goals. Poor design leads to tight coupling, low reuse, and costly rework across teams.",
-  "station.api-design.apply_in_work": "Provide reusable design patterns, shared standards, and validation tools for API specifications. Ensure design decisions are consistent, reviewed early, and aligned with business intent.",
-  "station.api-design.outcomes": "Well-documented and consistent API designs",
-  "station.api-design.outcomes.1": "Reusable and validated API contracts",
-  "station.api-design.outcomes.2": "Designs aligned with domain models and interaction patterns",
-  "station.api-design.outcomes.3": "Design traceability to business value",
-  "station.api-design.how_it_works": "Define core entities, their attributes, and relationships to create a shared conceptual understanding across APIs.",
-  "station.api-design.how_it_works.1": "Use the Interaction Canvas to define how consumers will interact with the API, ensuring it meets their needs and expectations.",
-  "station.api-design.how_it_works.2": "Apply REST design patterns to create consistent, reusable API contracts that are validated with stakeholders.",
-  "station.api-design.how_it_works.3": "Apply Event-driven design patterns to create consistent, reusable API contracts that are validated with stakeholders.",
-  "station.api-design.how_it_works.4": "Apply GraphQL design patterns to create consistent, reusable API contracts that are validated with stakeholders.",
-  "station.api-design.how_it_works.5": "Use the design principles and API style guide to align your design decisions with shared rules and enable consistent audit validation.",
-  "station.api-design.how_it_works.6": "Apply contract-first or design-first approaches to capture and validate the API contract before implementation.",
-  "station.api-design.how_it_works.7": "Use the API Audit Checklist to ensure the API design meets functional and non-functional requirements, including security, performance, and compliance.",
-  "station.api-delivery.title": "API Delivery - Deliver Secure and Reliable APIs",
-  "station.api-delivery.description": "Build, test, and release APIs using modern delivery pipelines and engineering best practices.",
-  "station.api-delivery.why_it_matters": "Even the best API designs fail if delivery is inconsistent. This station ensures your APIs are built with quality, tested thoroughly, and deployed reliably — enabling faster iterations and greater confidence.",
-  "station.api-delivery.apply_in_work": "Deliver coding frameworks, libraries, and standards for API implementation. Implement CI/CD pipelines, quality assurance frameworks, and deployment automation tools.",
-  "station.api-delivery.outcomes": "APIs implemented using tested frameworks and patterns",
-  "station.api-delivery.outcomes.1": "Reliable and automated CI/CD pipelines",
-  "station.api-delivery.outcomes.2": "Functional and non-functional testing integrated",
-  "station.api-delivery.outcomes.3": "Secure and compliant delivery pipelines",
-  "station.api-delivery.how_it_works": "Use API Development Best Practices as guidance for implementing the validated contract with established frameworks and libraries, ensuring the result is reusable and maintainable.",
-  "station.api-delivery.how_it_works.1": "Build the API implementation from the validated contract using established frameworks, libraries, and team standards.",
-  "station.api-delivery.how_it_works.2": "Test APIs for functionality, security, and performance using automated testing tools.",
-  "station.api-delivery.how_it_works.3": "Use CI/CD pipelines to automate build, test, and deployment processes, ensuring consistent quality and traceability.",
-  "station.api-delivery.how_it_works.4": "Ensure APIs meet security and compliance requirements through automated checks and audits.",
-  "station.api-delivery.how_it_works.5": "Use the API Audit Checklist to ensure the API meets functional and non-functional requirements, including security, performance, and compliance.",
-  "station.api-audit.title": "API Audit - Audit APIs for Compliance and Quality",
-  "station.api-audit.description": "Validate that APIs meet business, design, and operational standards before publishing and exposure.",
-  "station.api-audit.why_it_matters": "APIs are long-lived products and must meet expectations for quality, consistency, and compliance. The audit connects design decisions, implementation, and operational readiness to defined standards, reducing risk before exposure.",
-  "station.api-audit.apply_in_work": "Establish a consistent audit process that evaluates API readiness across lifecycle stages using defined criteria, evidence, and standards. Ensure gaps are identified early and resolved before publishing.",
-  "station.api-audit.outcomes": "APIs meet internal and external standards",
-  "station.api-audit.outcomes.1": "Clear documentation of API design and implementation decisions",
-  "station.api-audit.outcomes.2": "Security, performance, and compliance validated",
+  "group.core-stations.title": "Capability Lifecycle Core Stations",
+  "group.core-stations.description": "The core stations of the method, where teams can learn how to design, deliver, govern, and improve reusable capabilities across APIs, events, files, streams, data products, and other integration styles.",
+  "station.api-product-strategy.title": "Strategy",
+  "station.api-product-strategy.description": "Frame the business need as a reusable capability before choosing the implementation style.",
+  "station.api-product-strategy.why_it_matters": "Integration and API work often jumps too quickly to a technical pattern. This station keeps the team focused on the business journey, domain meaning, value, reuse potential, ownership, and viability before selecting APIs, events, files, streams, data products, or direct integration.",
+  "station.api-product-strategy.apply_in_work": "Use shared journey, domain, value proposition, and business model canvases to gather technology-agnostic requirements and decide whether the capability should be reusable.",
+  "station.api-product-strategy.outcomes": "A technology-agnostic capability opportunity statement",
+  "station.api-product-strategy.outcomes.1": "Shared understanding of consumers, producers, domain concepts, and reuse potential",
+  "station.api-product-strategy.outcomes.2": "A capability value proposition and business model before architecture selection",
+  "station.api-product-strategy.how_it_works": "Map the customer or partner journey that creates the capability need and reveals tasks, pains, gains, inputs, outputs, and decision points.",
+  "station.api-product-strategy.how_it_works.1": "Define the core entities, attributes, relationships, ownership, and business rules that the capability must respect.",
+  "station.api-product-strategy.how_it_works.2": "Use the Capability Value Proposition Canvas to capture consumer tasks, gains, pains, and reusable capability features without naming the delivery technology too early.",
+  "station.api-product-strategy.how_it_works.3": "Use the Capability Business Model Canvas to clarify ownership, partners, channels, costs, benefits, support, and lifecycle expectations for the reusable capability.",
+  "station.api-consumer-experience.title": "Consumer Requirements & Onboarding",
+  "station.api-consumer-experience.description": "Capture consumer onboarding, standards, non-functional requirements, service expectations, constraints, security needs, allowed protocols, data freshness, SLAs, observability, recovery, adoption requirements, and producer responsibilities.",
+  "station.api-consumer-experience.why_it_matters": "The right architecture depends on consumer goals, onboarding expectations, service levels, data quality needs, change tolerance, observability, support, and producer constraints.",
+  "station.api-consumer-experience.how_it_works": "Use the Consumer Experience Requirements Canvas to capture consumer goals, availability, freshness, volume, performance, data quality, security, onboarding, change, observability, and recovery expectations.",
+  "station.api-consumer-experience.how_it_works.1": "Use onboarding guidance to describe how consumers will find, request, test, get approved for, and start using the capability.",
+  "station.api-consumer-experience.how_it_works.2": "Use the resulting journey and requirements to improve onboarding, documentation, support, and feedback loops for capability consumers.",
+  "station.api-consumer-experience.apply_in_work": "Use consumer experience and onboarding guidance to make expectations explicit for both consumers and producers.",
+  "station.api-consumer-experience.outcomes": "Documented consumer requirements and onboarding expectations",
+  "station.api-consumer-experience.outcomes.1": "Clear producer responsibilities and support expectations",
+  "station.api-consumer-experience.outcomes.2": "Architecture-relevant constraints ready for decision making",
+  "station.api-consumer-experience.outcomes.3": "Improved adoption through consumer empathy, standards, and producer clarity",
+  "station.api-platform-architecture.title": "Architecture & Platform Decisions",
+  "station.api-platform-architecture.description": "Use requirements and constraints to decide the right architecture pattern and enabling platform capabilities.",
+  "station.api-platform-architecture.why_it_matters": "Architecture choices should follow from evidence about business impact, locations, trust boundaries, capacity, latency, data ownership, consistency, operability, security, privacy, governance, and cost.",
+  "station.api-platform-architecture.apply_in_work": "Compare viable architecture styles against the gathered requirements and document the selected pattern and rationale.",
+  "station.api-platform-architecture.outcomes": "A justified architecture choice",
+  "station.api-platform-architecture.outcomes.1": "Documented risks, locations, capacity, security, privacy, and operability constraints",
+  "station.api-platform-architecture.outcomes.2": "Clear rationale for API, event, file, stream, data product, direct integration, or hybrid implementation style",
+  "station.api-platform-architecture.how_it_works": "Use the Business Impact Canvas to identify availability, security, and data risks that influence architecture options.",
+  "station.api-platform-architecture.how_it_works.1": "Use the Locations Canvas to capture geopolitical, regulatory, network, residency, and trust-boundary constraints.",
+  "station.api-platform-architecture.how_it_works.2": "Use the Capacity Canvas to capture current and future volumes, peaks, latency, caching, rate limiting, and scaling expectations.",
+  "station.api-platform-architecture.how_it_works.3": "Use metrics and analytics guidance to define how the chosen capability will be monitored and improved.",
+  "station.api-design.title": "Solution & Interface Design",
+  "station.api-design.description": "Design the interface contract and interaction model after the architecture choice is justified.",
+  "station.api-design.why_it_matters": "Once the architecture pattern is known, the design must turn capability requirements into clear interface contracts, interactions, schemas, data rules, lifecycle expectations, and consumer obligations.",
+  "station.api-design.apply_in_work": "Select the design resources that fit the chosen implementation style and document the interface contract before implementation.",
+  "station.api-design.outcomes": "A validated interface contract for the selected implementation style",
+  "station.api-design.outcomes.1": "Consistent interaction, data, event, file, workflow, or API contract decisions",
+  "station.api-design.outcomes.2": "Design traceability back to capability and consumer requirements",
+  "station.api-design.outcomes.3": "Designs aligned with domain models and interaction patterns",
+  "station.api-design.how_it_works": "Reuse the Domain Canvas to confirm business objects, terms, rules, and ownership before contract design.",
+  "station.api-design.how_it_works.1": "Use the Interaction Canvas to describe how consumers, systems, or users interact with the capability.",
+  "station.api-design.how_it_works.2": "Use REST design resources when the selected interface is a REST API.",
+  "station.api-design.how_it_works.3": "Use Event Canvas resources when the selected interface is event-driven.",
+  "station.api-design.how_it_works.4": "Use GraphQL design resources when the selected interface is GraphQL.",
+  "station.api-design.how_it_works.5": "Use the design principles and style guidance to align design decisions with shared rules and enable consistent audit validation.",
+  "station.api-design.how_it_works.6": "Apply contract-first or design-first approaches to capture and validate the interface contract before implementation.",
+  "station.api-design.how_it_works.7": "Use the audit checklist to ensure the design meets functional and non-functional requirements, including security, performance, and compliance.",
+  "station.api-delivery.title": "Delivery & Operations",
+  "station.api-delivery.description": "Deliver the selected implementation style with appropriate engineering, testing, security, automation, and operational practices.",
+  "station.api-delivery.why_it_matters": "A reusable capability needs reliable delivery and operations regardless of whether it becomes an API, event stream, file exchange, data product, or direct integration.",
+  "station.api-delivery.apply_in_work": "Apply delivery, testing, CI/CD, operations, and security guidance to the chosen implementation style.",
+  "station.api-delivery.outcomes": "A delivered capability aligned with the validated interface contract",
+  "station.api-delivery.outcomes.1": "Automated testing, deployment, and environment controls",
+  "station.api-delivery.outcomes.2": "Security, operations, and quality practices appropriate to the chosen pattern",
+  "station.api-delivery.outcomes.3": "Traceable delivery and release controls",
+  "station.api-delivery.how_it_works": "Use development best practices to implement the validated interface contract with established frameworks, libraries, and team standards.",
+  "station.api-delivery.how_it_works.1": "Build the implementation from the validated interface contract using established frameworks, libraries, and team standards.",
+  "station.api-delivery.how_it_works.2": "Use testing guidance to verify functionality, data quality, compatibility, security, performance, resilience, and recovery expectations.",
+  "station.api-delivery.how_it_works.3": "Use CI/CD guidance to automate build, test, deployment, configuration, and traceability.",
+  "station.api-delivery.how_it_works.4": "Use security guidance to protect data, access, credentials, and platform boundaries.",
+  "station.api-delivery.how_it_works.5": "Use the audit checklist to ensure the solution meets functional and non-functional requirements, including security, performance, and compliance.",
+  "station.api-audit.title": "Quality & Readiness Assurance",
+  "station.api-audit.description": "Audit the capability interface contract, controls, support model, observability, documentation, and lifecycle readiness before release.",
+  "station.api-audit.why_it_matters": "Reusable capabilities create operational, data, security, privacy, compliance, and consumer-impact risks. Readiness checks reduce surprises before release or production use.",
+  "station.api-audit.apply_in_work": "Use audit and compliance resources to verify that the capability is ready for controlled release and reuse.",
+  "station.api-audit.outcomes": "Documented readiness for release and reuse",
+  "station.api-audit.outcomes.1": "Known gaps and mitigations before release",
+  "station.api-audit.outcomes.2": "Evidence for governance, compliance, support, and operational approval",
   "station.api-audit.outcomes.3": "Reduced risk of issues in production",
-  "station.api-audit.how_it_works": "Conduct audits to ensure APIs meet organizational, technical, and legal standards before publishing.",
+  "station.api-audit.how_it_works": "Use the audit checklist as a reusable quality checklist for interface contract, documentation, security, performance, and compliance readiness.",
   "station.api-audit.how_it_works.1": "Use checklists, linters, and testing tools to verify consistency and conformance with standards.",
-  "station.api-audit.how_it_works.2": "Collaborate with governance teams and domain experts to ensure APIs are ready for production.",
-  "station.api-publishing.title": "API Publishing - Publish APIs with Confidence",
-  "station.api-publishing.description": "Expose APIs securely and clearly to the right audience with the right documentation and processes.",
-  "station.api-publishing.why_it_matters": "Publishing is more than deploying — it’s about discoverability, access, and support. If APIs aren't published correctly, they won’t be used, reused, or secured effectively.",
-  "station.api-publishing.apply_in_work": "Enable APIs to be published to the relevant environment and have clear registration and access mechanisms (e.g., API keys, OAuth, subscription plans) depending on the API consumer segments and security and compliance requirements.",
-  "station.api-publishing.outcomes": "APIs published in the right environment (private, partner, public)",
-  "station.api-publishing.outcomes.1": "Clear API onboarding and registration processes",
-  "station.api-publishing.outcomes.2": "Documentation, security models, and policies available",
-  "station.api-publishing.outcomes.3": "APIs ready for scale and governance",
-  "station.api-publishing.how_it_works": "Publish APIs to the appropriate gateways and environments to support reusability for multiple API consumers.",
-  "station.api-publishing.how_it_works.1": "Document how consumers find and use the API, including onboarding processes and registration.",
-  "station.api-publishing.how_it_works.2": "Ensure security models, gateway configuration, and legal terms are clear and accessible to consumers.",
-  "station.monitoring-and-improving.title": "Monitoring and Improving - for API Value",
-  "station.monitoring-and-improving.description": "Use metrics and feedback to track API performance and drive continuous improvement.",
-  "station.monitoring-and-improving.why_it_matters": "API delivery doesn’t stop at launch. Without monitoring, teams can’t improve adoption, performance, or ROI. This station ensures APIs remain useful, secure, and evolving with business needs.",
-  "station.monitoring-and-improving.apply_in_work": "Set up analytics frameworks to track performance and engagement. Develop feedback loops, analytics tools, and engagement strategies for APIs.",
-  "station.monitoring-and-improving.outcomes": "Performance and usage metrics defined and tracked",
-  "station.monitoring-and-improving.outcomes.1": "Developer feedback loops in place",
-  "station.monitoring-and-improving.outcomes.2": "Issues identified and addressed continuously",
-  "station.monitoring-and-improving.outcomes.3": "API iteration aligned with user needs",
-  "station.monitoring-and-improving.how_it_works": "Monitor performance metrics (e.g., API calls, latency, error rates) and adoption metrics (e.g., NPS).",
-  "station.monitoring-and-improving.how_it_works.1": "Analyze API usage metrics and incorporate user feedback into API iterations.",
+  "station.api-audit.how_it_works.2": "Collaborate with governance teams and domain experts to ensure the capability is ready for production.",
+  "station.api-publishing.title": "Publishing & Enablement",
+  "station.api-publishing.description": "Publish reusable capability information so consumers can discover, request, onboard, use, and get support.",
+  "station.api-publishing.why_it_matters": "Reusable capabilities only create value when consumers can find them, understand their interface contract and service expectations, request access, and know who owns support and lifecycle decisions.",
+  "station.api-publishing.apply_in_work": "Publish ownership, documentation, onboarding, support contacts, service expectations, lifecycle status, and access request paths.",
+  "station.api-publishing.outcomes": "A discoverable reusable capability",
+  "station.api-publishing.outcomes.1": "Clear onboarding, access, support, and service expectations",
+  "station.api-publishing.outcomes.2": "Lifecycle and ownership information available to consumers and governance teams",
+  "station.api-publishing.outcomes.3": "Consumers enabled to use and reuse the capability",
+  "station.api-publishing.how_it_works": "Publish capability information to the appropriate catalogs, portals, gateways, or environments to support reuse by multiple consumers.",
+  "station.api-publishing.how_it_works.1": "Document how consumers find and use the capability, including onboarding processes and registration.",
+  "station.api-publishing.how_it_works.2": "Ensure security models, access configuration, and legal terms are clear and accessible to consumers.",
+  "station.monitoring-and-improving.title": "Monitoring & Improvement",
+  "station.monitoring-and-improving.description": "Monitor usage, reliability, data quality, consumer outcomes, operational cost, and reuse opportunities after release.",
+  "station.monitoring-and-improving.why_it_matters": "Capabilities need continuous feedback to stay reliable, valuable, cost-effective, and reusable as consumers, systems, data, and platforms change.",
+  "station.monitoring-and-improving.apply_in_work": "Use metrics, analytics, and engagement practices to improve the capability over time.",
+  "station.monitoring-and-improving.outcomes": "Measured capability health and value",
+  "station.monitoring-and-improving.outcomes.1": "Improvement backlog informed by operational and consumer feedback",
+  "station.monitoring-and-improving.outcomes.2": "Reuse, reliability, data quality, and cost signals available to owners",
+  "station.monitoring-and-improving.outcomes.3": "Continuous improvement aligned with consumer needs",
+  "station.monitoring-and-improving.how_it_works": "Use metrics and analytics guidance to define capability usage, reliability, data quality, cost, adoption, and consumer-value measures.",
+  "station.monitoring-and-improving.how_it_works.1": "Analyze usage metrics and incorporate consumer feedback into capability iterations.",
   "station.monitoring-and-improving.how_it_works.2": "Establish a habit of reviewing metrics and planning continuous improvement activities.",
-  "group.sub-stations.title": "API Lifecycle Sub Stations",
-  "group.sub-stations.description": "Sub stations that provide additional resources, tools, and best practices for API teams.",
+  "group.sub-stations.title": "Supporting Stations",
+  "group.sub-stations.description": "Supporting stations provide reusable practices, decision points and resources that can be included in different APIOps Cycles routes, including capability, API, integration, data and AI-enabled productization.",
   "station.user-experience.title": "User Experience - Design APIs with the User in Mind",
   "station.user-experience.description": "Ensure APIs are designed with the end user in mind, providing a seamless and intuitive experience.",
   "station.user-experience.why_it_matters": "APIs are not just technical products; they are user-facing products. A poor user experience can lead to low adoption and frustration. This station helps teams design APIs that are user-friendly and meet consumer needs.",
@@ -275,28 +275,28 @@
   "station.service-agreements.how_it_works": "Define service agreements that outline the expectations, service levels, and responsibilities for each API.",
   "station.service-agreements.how_it_works.1": "Use standardized formats to create machine-readable service agreements that are easy to share and validate.",
   "station.service-agreements.how_it_works.2": "Ensure service agreements are reviewed and approved by stakeholders to ensure alignment and clarity.",
-  "station.api-consumer-adoption.title": "API Consumer Adoption - Drive API Usage",
-  "station.api-consumer-adoption.description": "Implement strategies to drive API consumer adoption and engagement, ensuring APIs are used effectively.",
-  "station.api-consumer-adoption.why_it_matters": "Driving API consumer adoption is crucial for realizing the value of APIs. This station provides strategies and best practices for engaging API consumers, ensuring they understand how to use APIs effectively and derive value from them.",
-  "station.api-consumer-adoption.apply_in_work": "Provide onboarding resources, educational materials, and engagement strategies for API consumers. Ensure teams implement strategies that drive API consumer adoption, engagement, and satisfaction.",
-  "station.api-consumer-adoption.outcomes": "API consumer adoption strategies implemented",
-  "station.api-consumer-adoption.outcomes.1": "Increased API usage and engagement",
-  "station.api-consumer-adoption.outcomes.2": "API consumers educated on API features and benefits",
-  "station.api-consumer-adoption.outcomes.3": "Improved API consumer satisfaction and loyalty",
-  "station.api-consumer-adoption.how_it_works": "Develop onboarding processes and resources to help API consumers understand how to use APIs effectively.",
-  "station.api-consumer-adoption.how_it_works.1": "Create educational materials (e.g., tutorials, documentation) that explain API features, benefits, and usage patterns.",
-  "station.api-consumer-adoption.how_it_works.2": "Engage with API consumers through feedback loops, support channels, and community forums to understand their needs and improve API adoption.",
-  "station.api-promotion.title": "API Promotion - Increase API Visibility and Usage",
-  "station.api-promotion.description": "Promote APIs to increase visibility, usage, and adoption among target audiences.",
-  "station.api-promotion.why_it_matters": "Promoting APIs is essential for increasing their visibility and driving usage. This station provides strategies and best practices for effectively promoting APIs to target audiences, ensuring they are aware of the APIs and understand their value.",
-  "station.api-promotion.apply_in_work": "Provide marketing strategies, promotional materials, and community engagement resources. Ensure teams implement effective API promotion strategies that increase visibility, usage, and adoption among target audiences.",
-  "station.api-promotion.outcomes": "API promotion strategies implemented",
-  "station.api-promotion.outcomes.1": "Increased API visibility and awareness",
-  "station.api-promotion.outcomes.2": "Higher API usage and adoption rates",
-  "station.api-promotion.outcomes.3": "Improved API consumer engagement and satisfaction",
-  "station.api-promotion.how_it_works": "Develop marketing strategies to promote APIs to target audiences, including social media, blogs, and webinars.",
-  "station.api-promotion.how_it_works.1": "Create promotional materials (e.g., case studies, success stories) that highlight the value and benefits of APIs.",
-  "station.api-promotion.how_it_works.2": "Engage with API communities and forums to share API updates, gather feedback, and promote API usage.",
+  "station.api-consumer-adoption.title": "Consumer Adoption",
+  "station.api-consumer-adoption.description": "Implement strategies to drive consumer adoption and engagement so reusable capabilities are used effectively.",
+  "station.api-consumer-adoption.why_it_matters": "Driving consumer adoption is crucial for realizing the value of reusable capabilities. This station provides strategies and best practices for engaging consumers, helping them understand how to use capabilities effectively and derive value from them.",
+  "station.api-consumer-adoption.apply_in_work": "Provide onboarding resources, educational materials, and engagement strategies for consumers. Ensure teams implement adoption practices that improve engagement, satisfaction, and reuse.",
+  "station.api-consumer-adoption.outcomes": "Consumer adoption strategies implemented",
+  "station.api-consumer-adoption.outcomes.1": "Increased usage and engagement",
+  "station.api-consumer-adoption.outcomes.2": "Consumers educated on capability features and benefits",
+  "station.api-consumer-adoption.outcomes.3": "Improved consumer satisfaction and loyalty",
+  "station.api-consumer-adoption.how_it_works": "Develop onboarding processes and resources to help consumers understand how to use reusable capabilities effectively.",
+  "station.api-consumer-adoption.how_it_works.1": "Create educational materials that explain capability features, benefits, and usage patterns.",
+  "station.api-consumer-adoption.how_it_works.2": "Engage with consumers through feedback loops, support channels, and communities to understand needs and improve adoption.",
+  "station.api-promotion.title": "Promotion",
+  "station.api-promotion.description": "Promote reusable capabilities to increase visibility, usage, and adoption among target audiences.",
+  "station.api-promotion.why_it_matters": "Promotion increases visibility and drives usage. This station provides strategies and best practices for making target audiences aware of reusable capabilities and their value.",
+  "station.api-promotion.apply_in_work": "Provide communication strategies, promotional materials, and community engagement resources. Ensure teams implement promotion practices that increase visibility, usage, and adoption among target audiences.",
+  "station.api-promotion.outcomes": "Promotion strategies implemented",
+  "station.api-promotion.outcomes.1": "Increased visibility and awareness",
+  "station.api-promotion.outcomes.2": "Higher usage and adoption rates",
+  "station.api-promotion.outcomes.3": "Improved consumer engagement and satisfaction",
+  "station.api-promotion.how_it_works": "Develop communication strategies to promote reusable capabilities to target audiences, including internal channels, communities, demos, and enablement events.",
+  "station.api-promotion.how_it_works.1": "Create promotional materials such as use cases, success stories, and release notes that highlight value and benefits.",
+  "station.api-promotion.how_it_works.2": "Engage with relevant communities and forums to share updates, gather feedback, and promote usage.",
   "station.partner-integration.title": "Partner Integration - Collaborate with Partners",
   "station.partner-integration.description": "Facilitate partner integrations to enhance API capabilities and expand reach.",
   "station.partner-integration.why_it_matters": "Partner integrations can enhance API capabilities and expand reach. This station provides guidelines for collaborating with partners to integrate their APIs, ensuring seamless interoperability and value creation.",
@@ -339,8 +339,6 @@
   "station.upskilling.outcomes.2": "Improved ability to adopt new technologies and practices",
   "station.upskilling.outcomes.3": "Empowered teams to drive API innovation and quality",
   "station.upskilling.how_it_works": "Identify key API skills and knowledge areas that need enhancement, such as API design, security, and performance.",
-  "station.upskilling.how_it_works.1": "Provide training programs, workshops, and resources to help teams enhance their API skills and knowledge.",
-  "station.upskilling.how_it_works.2": "Encourage continuous learning through online courses, certifications, and community engagement.",
   "station.operating-guidelines.title": "Operating Guidelines - Establish API Governance",
   "station.operating-guidelines.description": "Establish operating guidelines and governance practices to ensure consistent API management and quality.",
   "station.operating-guidelines.why_it_matters": "Effective API governance is essential for ensuring consistent API management, quality, and compliance. This station provides operating guidelines and governance practices that help teams manage APIs effectively, ensuring they align with organizational standards and best practices.",
@@ -361,8 +359,6 @@
   "station.portfolio-management.outcomes.2": "Prioritization and optimization of APIs based on value and impact",
   "station.portfolio-management.outcomes.3": "Improved visibility and control over the API portfolio",
   "station.portfolio-management.how_it_works": "Define portfolio management practices that outline the processes for managing the API portfolio, including prioritization, monitoring, and optimization.",
-  "station.portfolio-management.how_it_works.1": "Establish criteria for evaluating and prioritizing APIs based on business value, impact, and alignment with strategic initiatives.",
-  "station.portfolio-management.how_it_works.2": "Monitor the API portfolio to ensure APIs are delivering value, meeting performance expectations, and aligning with business goals.",
   "station.budget-and-resource-management.title": "Budget and Resource Management - Optimize API Investments",
   "station.budget-and-resource-management.description": "Optimize budget and resource management for API initiatives to ensure effective investments and resource allocation.",
   "station.budget-and-resource-management.why_it_matters": "Effective budget and resource management is essential for ensuring that API initiatives are well-funded and resourced. This station provides guidelines for optimizing budget and resource management, ensuring that API initiatives are aligned with business goals and deliver maximum value.",
@@ -372,6 +368,100 @@
   "station.budget-and-resource-management.outcomes.2": "Optimized investments in API development and management",
   "station.budget-and-resource-management.outcomes.3": "Improved financial visibility and control over API initiatives",
   "station.budget-and-resource-management.how_it_works": "Define budget and resource management practices that outline the processes for managing budgets and resources for API initiatives.",
-  "station.budget-and-resource-management.how_it_works.1": "Establish criteria for evaluating and prioritizing budget allocations based on business value, impact, and alignment with strategic initiatives.",
-  "station.budget-and-resource-management.how_it_works.2": "Monitor budget and resource utilization to ensure effective investments and resource allocation for API initiatives."
+  "cycle.api-productization-cycle.station.api-product-strategy.title": "API Product Strategy - Turn APIs Into Strategic Products",
+  "cycle.api-productization-cycle.station.api-product-strategy.description": "Before building anything, define your API's value, users, and business goals from day one.",
+  "cycle.api-productization-cycle.station.api-product-strategy.why_it_matters": "Many organizations think of APIs as tech projects, not products. The result? Confused consumers, poor adoption, and wasted effort.\n\nThis station helps you define your API’s purpose, target audience, and success criteria, so teams can deliver APIs that solve real problems.",
+  "cycle.api-productization-cycle.station.api-product-strategy.apply_in_work": "Provide guidelines and templates for creating API business models, value propositions, and roadmaps.",
+  "cycle.api-productization-cycle.station.api-product-strategy.outcomes": "A straightforward API value proposition and audience",
+  "cycle.api-productization-cycle.station.api-product-strategy.outcomes.1": "Shared language between product, design, and tech",
+  "cycle.api-productization-cycle.station.api-product-strategy.outcomes.2": "A solid pitch or case for funding/approval",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works": "Explore the customer or partner problem you expect to solve with APIs. Map the stakeholders, ther journeys and outcomes using the Customer Journey canvas.",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works.1": "Define core entities, their attributes, and relationships to create a shared conceptual understanding across journeys and eventually APIs.",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works.2": "Use the API Value Proposition Canvas to capture the supported business tasks and the API consumer pains, gains, and features that shape new or reusable APIs.",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works.3": "Define the value — for users and the business with the API Business Model canvas to make your API strategy visual, shareable, and easy to validate with your API consumers at the next station.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.title": "API Consumer Experience - Design for Your API’s Real Users",
+  "cycle.api-productization-cycle.station.api-consumer-experience.description": "Ensure your API is discoverable, understandable, and usable — before and after launch.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.why_it_matters": "Great APIs don’t just work — they feel intuitive. Whether your consumer is an internal developer, external partner, or AI agent, their experience determines adoption.\n\nWithout a clear experience plan:\n- Great APIs go unused\n- Teams waste time guessing how to use your API\n- Feedback loops are broken or missing.\n\nThis station helps you see your API through the eyes of its consumers.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.how_it_works": "Review the existing API Value Proposition Canvas from the API consumer perspective. Keep the supported business tasks stable, and enrich the pain-relieving and gain-enabling features with API consumer concerns so they can guide later design decisions.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.how_it_works.1": "Use the Customer Journey Canvas for the API consumer journey from discovery and evaluation to onboarding, integration, troubleshooting, and ongoing use.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.how_it_works.2": "Use the resulting journey to improve onboarding, documentation, support, and feedback loops for the API consumer.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.apply_in_work": "Provide guidelines, tools, and feedback mechanisms for understanding, analyzing, and improving internal and external developer and partner experience.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes": "Identify and prioritize your API consumers",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes.1": "Define the API experience journey",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes.2": "Plan onboarding, documentation, and feedback",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes.3": "Improve adoption through genuine empathy + Developer Experience (DX)",
+  "cycle.api-productization-cycle.station.api-platform-architecture.title": "API Platform Architecture - Architect APIs for Scalability and Reuse",
+  "cycle.api-productization-cycle.station.api-platform-architecture.description": "Ensure scalability, reuse, and governance across your API and platform components.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.why_it_matters": "When APIs scale across teams, your platform must enable governance and reuse without blocking speed. This station shows how to architect APIs for longevity, security, and efficiency.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.apply_in_work": "Establish a scalable, secure, and compliant infrastructure for API operations. Provide guidelines on architecture best practices.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.outcomes": "Cut redundant APIs and reduce cloud platform costs",
+  "cycle.api-productization-cycle.station.api-platform-architecture.outcomes.1": "Implement consistent governance without heavy top-down control",
+  "cycle.api-productization-cycle.station.api-platform-architecture.outcomes.2": "Design for internal reuse and external scalability",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works": "The Business Impact Canvas helps to identify and mitigate risks related to API availability, security, and functionality to support informed architectural decisions.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works.1": "Map the regulatory, compliance, and network locations of API providers and consumers to ensure accessibility and compliance.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works.2": "The Capacity Canvas aligns business transaction patterns, future consumption trends, and technical solutions to ensure API scalability and performance.It provides critical input for scaling decisions and infrastructure planning.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works.3": "Define and monitor performance metrics (e.g., API calls, latency, error rates) and adoption metrics (e.g., NPS).",
+  "cycle.api-productization-cycle.station.api-design.title": "API Design - Design APIs That Deliver Value",
+  "cycle.api-productization-cycle.station.api-design.description": "Create API designs that are consistent, reusable, and grounded in business intent and shared standards.",
+  "cycle.api-productization-cycle.station.api-design.why_it_matters": "Designing APIs is not just about naming endpoints. Good design ensures APIs are usable, consistent, and aligned with business and technical goals. Poor design leads to tight coupling, low reuse, and costly rework across teams.",
+  "cycle.api-productization-cycle.station.api-design.apply_in_work": "Provide reusable design patterns, shared standards, and validation tools for API specifications. Ensure design decisions are consistent, reviewed early, and aligned with business intent.",
+  "cycle.api-productization-cycle.station.api-design.outcomes": "Well-documented and consistent API designs",
+  "cycle.api-productization-cycle.station.api-design.outcomes.1": "Reusable and validated API contracts",
+  "cycle.api-productization-cycle.station.api-design.outcomes.2": "Designs aligned with domain models and interaction patterns",
+  "cycle.api-productization-cycle.station.api-design.outcomes.3": "Design traceability to business value",
+  "cycle.api-productization-cycle.station.api-design.how_it_works": "Define core entities, their attributes, and relationships to create a shared conceptual understanding across APIs.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.1": "Use the Interaction Canvas to define how consumers will interact with the API, ensuring it meets their needs and expectations.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.2": "Apply REST design patterns to create consistent, reusable API contracts that are validated with stakeholders.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.3": "Apply Event-driven design patterns to create consistent, reusable API contracts that are validated with stakeholders.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.4": "Apply GraphQL design patterns to create consistent, reusable API contracts that are validated with stakeholders.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.5": "Use the design principles and API style guide to align your design decisions with shared rules and enable consistent audit validation.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.6": "Apply contract-first or design-first approaches to capture and validate the API contract before implementation.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.7": "Use the API Audit Checklist to ensure the API design meets functional and non-functional requirements, including security, performance, and compliance.",
+  "cycle.api-productization-cycle.station.api-delivery.title": "API Delivery - Deliver Secure and Reliable APIs",
+  "cycle.api-productization-cycle.station.api-delivery.description": "Build, test, and release APIs using modern delivery pipelines and engineering best practices.",
+  "cycle.api-productization-cycle.station.api-delivery.why_it_matters": "Even the best API designs fail if delivery is inconsistent. This station ensures your APIs are built with quality, tested thoroughly, and deployed reliably — enabling faster iterations and greater confidence.",
+  "cycle.api-productization-cycle.station.api-delivery.apply_in_work": "Deliver coding frameworks, libraries, and standards for API implementation. Implement CI/CD pipelines, quality assurance frameworks, and deployment automation tools.",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes": "APIs implemented using tested frameworks and patterns",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes.1": "Reliable and automated CI/CD pipelines",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes.2": "Functional and non-functional testing integrated",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes.3": "Secure and compliant delivery pipelines",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works": "Use API Development Best Practices as guidance for implementing the validated contract with established frameworks and libraries, ensuring the result is reusable and maintainable.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.1": "Build the API implementation from the validated contract using established frameworks, libraries, and team standards.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.2": "Test APIs for functionality, security, and performance using automated testing tools.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.3": "Use CI/CD pipelines to automate build, test, and deployment processes, ensuring consistent quality and traceability.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.4": "Ensure APIs meet security and compliance requirements through automated checks and audits.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.5": "Use the API Audit Checklist to ensure the API meets functional and non-functional requirements, including security, performance, and compliance.",
+  "cycle.api-productization-cycle.station.api-audit.title": "API Audit - Audit APIs for Compliance and Quality",
+  "cycle.api-productization-cycle.station.api-audit.description": "Validate that APIs meet business, design, and operational standards before release.",
+  "cycle.api-productization-cycle.station.api-audit.why_it_matters": "APIs are long-lived products and must meet expectations for quality, consistency, and compliance. The audit connects design decisions, implementation, and operational readiness to defined standards, reducing risk before exposure.",
+  "cycle.api-productization-cycle.station.api-audit.apply_in_work": "Establish a consistent audit process that evaluates API readiness across lifecycle stages using defined criteria, evidence, and standards. Ensure gaps are identified early and resolved before release.",
+  "cycle.api-productization-cycle.station.api-audit.outcomes": "APIs meet internal and external standards",
+  "cycle.api-productization-cycle.station.api-audit.outcomes.1": "Clear documentation of API design and implementation decisions",
+  "cycle.api-productization-cycle.station.api-audit.outcomes.2": "Security, performance, and compliance validated",
+  "cycle.api-productization-cycle.station.api-audit.outcomes.3": "Reduced risk of issues in production",
+  "cycle.api-productization-cycle.station.api-audit.how_it_works": "Conduct audits to ensure APIs meet organizational, technical, and legal standards before release.",
+  "cycle.api-productization-cycle.station.api-audit.how_it_works.1": "Use checklists, linters, and testing tools to verify consistency and conformance with standards.",
+  "cycle.api-productization-cycle.station.api-audit.how_it_works.2": "Collaborate with governance teams and domain experts to ensure APIs are ready for production.",
+  "cycle.api-productization-cycle.station.api-publishing.title": "API Publishing - Publish APIs with Confidence",
+  "cycle.api-productization-cycle.station.api-publishing.description": "Expose APIs securely and clearly to the right audience with the right documentation and processes.",
+  "cycle.api-productization-cycle.station.api-publishing.why_it_matters": "Publishing is more than deploying — it’s about discoverability, access, and support. If APIs aren't published correctly, they won’t be used, reused, or secured effectively.",
+  "cycle.api-productization-cycle.station.api-publishing.apply_in_work": "Enable APIs to be published to the relevant environment and have clear registration and access mechanisms (e.g., API keys, OAuth, subscription plans) depending on the API consumer segments and security and compliance requirements.",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes": "APIs published in the right environment (private, partner, public)",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes.1": "Clear API onboarding and registration processes",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes.2": "Documentation, security models, and policies available",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes.3": "APIs ready for scale and governance",
+  "cycle.api-productization-cycle.station.api-publishing.how_it_works": "Publish APIs to the appropriate gateways and environments to support reusability for multiple API consumers.",
+  "cycle.api-productization-cycle.station.api-publishing.how_it_works.1": "Document how consumers find and use the API, including onboarding processes and registration.",
+  "cycle.api-productization-cycle.station.api-publishing.how_it_works.2": "Ensure security models, gateway configuration, and legal terms are clear and accessible to consumers.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.title": "Monitoring and Improving - for API Value",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.description": "Use metrics and feedback to track API performance and drive continuous improvement.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.why_it_matters": "API delivery doesn’t stop at launch. Without monitoring, teams can’t improve adoption, performance, or ROI. This station ensures APIs remain useful, secure, and evolving with business needs.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.apply_in_work": "Set up analytics frameworks to track performance and engagement. Develop feedback loops, analytics tools, and engagement strategies for APIs.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes": "Performance and usage metrics defined and tracked",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes.1": "Developer feedback loops in place",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes.2": "Issues identified and addressed continuously",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes.3": "API iteration aligned with user needs",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.how_it_works": "Monitor performance metrics (e.g., API calls, latency, error rates) and adoption metrics (e.g., NPS).",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.how_it_works.1": "Analyze API usage metrics and incorporate user feedback into API iterations.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.how_it_works.2": "Establish a habit of reviewing metrics and planning continuous improvement activities."
 }
diff --git a/src/data/method/fi/labels.criteria.json b/src/data/method/fi/labels.criteria.json
index c9dbb06..3db3788 100644
--- a/src/data/method/fi/labels.criteria.json
+++ b/src/data/method/fi/labels.criteria.json
@@ -1,25 +1,26 @@
 {
-  "exit_criteria": "Poistumiskriteerit",
-  "entry_criteria": "Pääsykriteerit",
-  "criterion.metrics-feedback-available": "Olennaiset markkinasignaalit, palautteet tai toiminnalliset lähtötiedot ovat saatavilla ohjaamaan tätä API-mahdollisuutta.",
+  "exit_criteria": "Valmistumiskriteerit",
+  "entry_criteria": "Aloituskriteerit",
+  "criterion.metrics-feedback-available": "Olennaiset markkinasignaalit, palaute tai toiminnalliset havainnot ovat saatavilla tämän kyvykkyysmahdollisuuden ohjaamiseksi.",
   "criterion.business-goals-defined": "Liiketoimintatavoitteet on määritelty.",
-  "criterion.market-research-done": "Markkinatutkimus tunnistaa API-mahdollisuudet.",
-  "criterion.stakeholder-approval": "Olennaiset sidosryhmät ovat tarkastelleet ja hyväksyneet API-mahdollisuuden.",
-  "criterion.api-opportunity-documented": "Yksittäiset API-mahdollisuudet on tunnistettu ja dokumentoitu.",
-  "criterion.api-reusability": "API vastaa selkeää liiketoimintatarvetta ja on uudelleenkäytettävissä useille API-käyttäjille.",
-  "criterion.hide-backend-discrepancies": "API on tarkoitettu suojamaan hyödyntäjiä backend-kompleksisuudesta ja epäjohdonmukaisuuksista.",
-  "criterion.value-prop-validated": "APIn arvolupaus on tarkistettu ja validointi on tehty yhdessä liiketoiminnan ja hyödyntäjien sidosryhmien kanssa.",
-  "criterion.consumer-segments-identified": "API-käyttäjäsegmentit (sisäiset ja ulkoiset) on tunnistettu.",
-  "criterion.api-roadmap-defined": "API-kehityksen yleiset etenemissuunnitelmat on laadittu.",
-  "criterion.architecture-patterns-validated": "API-arkkitehtuurimallit on tarkistettu ja validointi on tehty yhdessä teknisten sidosryhmien kanssa.",
-  "criterion.design-reflects-business-value": "APIn suunnittelun on heijastettava liiketoiminnan arvoa ja API-käyttäjien tarpeita.",
-  "criterion.api-consistency": "API-suunnittelu noudattaa yhteisiä API-tuote- ja suunnitteluohjeita.",
-  "criterion.api-contract-tested": "API-sopimus on testattu ja se täyttää toiminnalliset ja ei-toiminnalliset vaatimukset.",
-  "criterion.api-description-available": "APIn kuvaus on saatavilla ja se on riittävä API-hyödyntäjien tarpeisiin.",
-  "criterion.audit-passed": "API läpäisee vaatimustenmukaisuus-, turvallisuus- ja auditointitarkastukset.",
-  "criterion.audit-reports-shared": " API-auditointiraportit on jaettu olennaisille sidosryhmille.",
-  "criterion.api-ready-for-publishing": "API on valmis julkaistavaksi hyödyntäjien saataville.",
-  "criterion.api-documentation-ready": "API-dokumentaatio on valmis ja saatavilla API-hyödyntäjille.",
-  "criterion.consumer-support-ready": "Rekisteröinti, tuki ja viestintäprosessit ovat valmiita API-hyödyntäjille.",
-  "criterion.legal-compliance-clear": "Lakien, tietosuojan ja valvontavaatimukset julkaisuun ovat määritelty ja ymmärretty."
-}
\ No newline at end of file
+  "criterion.market-research-done": "Markkinatutkimus tunnistaa kyvykkyysmahdollisuuksia.",
+  "criterion.stakeholder-approval": "Olennaiset sidosryhmät ovat yhtä mieltä siitä, että kyvykkyysmahdollisuus kannattaa selvittää ja priorisoida.",
+  "criterion.api-opportunity-documented": "Kyvykkyysmahdollisuus on tunnistettu ja dokumentoitu.",
+  "criterion.api-reusability": "Kyvykkyys vastaa selkeään liiketoimintatarpeeseen ja on uudelleenkäytettävissä tarkoitetuille hyödyntäjille.",
+  "criterion.hide-backend-discrepancies": "Valittu rajapinta tarjoaa hyödyntäjille sopivan abstraktion.",
+  "criterion.value-prop-validated": "Kyvykkyyden arvolupaus on validoitu liiketoiminnan ja hyödyntäjien sidosryhmien kanssa.",
+  "criterion.consumer-segments-identified": "Hyödyntäjäsegmentit on tunnistettu.",
+  "criterion.api-roadmap-defined": "Ylätason toteutuksen etenemissuunnitelma on määritelty.",
+  "criterion.architecture-patterns-validated": "Valittu arkkitehtuuri, alusta ja toteutustapa on validoitu olennaisten arkkitehtuuri-, tietoturva- ja alustasidosryhmien kanssa.",
+  "criterion.design-reflects-business-value": "Rajapintasuunnittelu ja tarjottavat kyvykkyydet ovat jäljitettävissä liiketoiminta-arvoon ja hyödyntäjien tarpeisiin.",
+  "criterion.api-consistency": "Rajapintasuunnittelu noudattaa sovittuja suunnittelustandardeja ja käytäntöjä.",
+  "criterion.api-contract-tested": "Rajapintasopimus on validoitu ja testattu toiminnallisia ja ei-toiminnallisia vaatimuksia vasten.",
+  "criterion.automation-workflow-validated": "Työnkulku, säännöt, integraatiot ja olennaiset rajapintasopimukset on validoitu ja testattu.",
+  "criterion.api-description-available": "Rajapinta ja sen kyvykkyydet on dokumentoitu riittävän selkeästi katselmointia, auditointia ja käyttöönottoa varten.",
+  "criterion.audit-passed": "Ratkaisu läpäisee laatu-, tietoturva-, vaatimustenmukaisuus- ja valmiustarkastukset.",
+  "criterion.audit-reports-shared": "Auditointihavainnot ja korjauspäätökset on jaettu olennaisille sidosryhmille.",
+  "criterion.api-ready-for-publishing": "Kyvykkyys on valmis julkaistavaksi tai toimitettavaksi valitun toimitusmekanismin kautta.",
+  "criterion.api-documentation-ready": "Hyödyntäjille suunnattu dokumentaatio ja käyttöönottomateriaalit ovat valmiit.",
+  "criterion.consumer-support-ready": "Hyödyntäjien käyttöönotto-, tuki- ja viestintäprosessit ovat valmiit.",
+  "criterion.legal-compliance-clear": "Julkaisun tai toimituksen oikeudelliset, tietosuoja- ja vaatimustenmukaisuusvaatimukset on määritelty ja ymmärretty."
+}
diff --git a/src/data/method/fi/labels.cycles.json b/src/data/method/fi/labels.cycles.json
new file mode 100644
index 0000000..d54e7f4
--- /dev/null
+++ b/src/data/method/fi/labels.cycles.json
@@ -0,0 +1,107 @@
+{
+  "cycles.title": "Syklinäkymät",
+  "cycles.description": "Kohderyhmäkohtaiset näkymät APIOps Cycles -menetelmään.",
+  "cycle.capability-productization-cycle.title": "Kyvykkyyden tuotteistamisen sykli",
+  "cycle.capability-productization-cycle.description": "Sykli liiketoiminnan kyvykkyyksien muuttamiseen uudelleenkäytettäviksi digitaalisiksi kyvykkyyksiksi ennen toteutustavan valintaa.",
+  "cycle.capability-productization-cycle.purpose": "Tunnista ja tuotteista uudelleenkaytettavia digitaalisia kyvykkyyksia ennen API-, tapahtuma-, tiedosto-, virta-, datatuote-, tekoalya hyodyntava palvelu-, suora integraatio- tai hybriditoteutustavan valintaa.",
+  "cycle.api-productization-cycle.title": "API-tuotteistamisen sykli",
+  "cycle.api-productization-cycle.description": "API-keskeinen APIOps Cycles -polku APIen tuotteistamiseen, suunnitteluun, toimittamiseen, julkaisuun ja parantamiseen.",
+  "cycle.api-productization-cycle.purpose": "API-keskeinen menetelmäpolku tiimeille, jotka jo tietävät, että tarkoitettu toteutustapa on API-tuote.",
+  "cycle.integration-productization-cycle.title": "Integraatiokyvykkyyden tuotteistamisen sykli",
+  "cycle.integration-productization-cycle.description": "Sykli uudelleenkaytettavien integraatiokyvykkyyksien tuotteistamiseen ennen toteutustavan valintaa.",
+  "cycle.integration-productization-cycle.purpose": "Ohjaa uudelleenkaytettavan integraatiokyvykkyyden suunnittelua ennen API-, tapahtuma-, tiedosto-, virta-, datatuote-, suora integraatio- tai hybriditoteutustavan valintaa.",
+  "cycle.station.capability-strategy": "Kyvykkyysstrategia",
+  "cycle.station.consumer-requirements-onboarding": "Hyödyntäjien vaatimukset ja käyttöönotto",
+  "cycle.station.architecture-platform-decisions": "Arkkitehtuuri ja alustaratkaisut",
+  "cycle.station.solution-interface-design": "Ratkaisu- ja rajapintasuunnittelu",
+  "cycle.station.delivery-operations": "Toimitus ja operointi",
+  "cycle.station.quality-readiness-assurance": "Laadun ja valmiuden varmistus",
+  "cycle.station.publishing-enablement": "Julkaisu ja kayttoonoton tuki",
+  "cycle.station.monitoring-improvement": "Seuranta ja parantaminen",
+  "cycle.station.api-product-strategy": "API-tuotestrategia",
+  "cycle.station.api-consumer-experience": "API-hyödyntäjäkokemus",
+  "cycle.station.api-platform-architecture": "API-alustan arkkitehtuuri",
+  "cycle.station.api-design": "API-suunnittelu",
+  "cycle.station.api-delivery": "API-toteutus",
+  "cycle.station.api-audit": "API-auditointi",
+  "cycle.station.api-publishing": "API-julkaisu",
+  "cycle.station.monitoring-and-improving": "APIen seuranta ja parantaminen",
+  "cycle.station.integration-capability-strategy": "Integraatiokyvykkyyden strategia",
+  "cycle.station.integration-consumer-requirements-onboarding": "Integraation hyödyntäjien vaatimukset ja käyttöönotto",
+  "cycle.station.integration-architecture-decision": "Integraatioarkkitehtuuri ja alustapaatokset",
+  "cycle.station.integration-solution-design": "Integraation ratkaisusuunnittelu",
+  "cycle.station.integration-delivery-operations": "Integraation toimitus ja operointi",
+  "cycle.station.integration-readiness-assurance": "Integraation valmiuden varmistus",
+  "cycle.station.capability-publishing": "Integraation julkaisu ja kayttoonoton tuki",
+  "cycle.station.integration-monitoring-improvement": "Integraation seuranta ja parantaminen",
+  "cycle.capability-productization-cycle.station.api-product-strategy.description": "Kuvaa liiketoimintatarve uudelleenkaytettavana kyvykkyytena, jolla on selkea arvo, hyodyntajat, omistajuus ja liiketoimintatavoitteet ennen toteutustavan valintaa.",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.description": "Kokoa hyödyntäjien vaatimukset, käyttöönoton tarpeet, rajoitteet, palveluodotukset ja tuottajan vastuut.",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.description": "Kayta vaatimuksia ja rajoitteita toteutustavan, arkkitehtuurimallin ja mahdollistavien alustakyvykkyyksien valintaan.",
+  "cycle.capability-productization-cycle.station.api-design.description": "Suunnittele rajapintasopimus ja vuorovaikutusmalli valitulle toteutustavalle.",
+  "cycle.capability-productization-cycle.station.api-delivery.description": "Rakenna, testaa, julkaise ja operoi kyvykkyyttä valitulla toteutustavalla ja validoidulla rajapintasopimuksella.",
+  "cycle.capability-productization-cycle.station.api-audit.description": "Validoi rajapintasopimus, kontrollit, dokumentaatio, tukimalli ja operatiivinen valmius ennen julkaisua.",
+  "cycle.capability-productization-cycle.station.api-publishing.description": "Julkaise kyvykkyys, jotta hyodyntajat voivat loytaa sen, arvioida sen, pyytaa kayttooikeutta, suorittaa kayttoonoton, kayttaa sita ja saada tukea.",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.description": "Seuraa kyvykkyyden tilaa, hyödyntäjien tuloksia, luotettavuutta, uudelleenkäyttöä ja parannusmahdollisuuksia.",
+  "cycle.owner.business-owner": "Liiketoimintaomistaja",
+  "cycle.owner.domain-expert": "Toimialan asiantuntija",
+  "cycle.owner.capability-owner": "Kyvykkyyden omistaja",
+  "cycle.owner.consumer-representative": "Hyödyntäjien edustaja",
+  "cycle.owner.enterprise-architect": "Kokonaisarkkitehti",
+  "cycle.owner.platform-owner": "Alustan omistaja",
+  "cycle.owner.api-product-owner": "API-tuoteomistaja",
+  "cycle.owner.api-platform-owner": "API-alustan omistaja",
+  "cycle.owner.integration-architect": "Integraatioarkkitehti",
+  "cycle.owner.solution-architect": "Ratkaisuarkkitehti",
+  "cycle.template.intent-fit.title": "Tarkoitus ja soveltuvuus",
+  "cycle.template.intent-fit.description": "Kuvaa liiketoimintatulos, hyödyntäjät, tuottajat, rajaus, rajoitteet ja päätöksen tila.",
+  "cycle.template.requirements.title": "Vaatimukset",
+  "cycle.template.requirements.description": "Kokoa asiantuntijoiden syötteet suositeltujen kysymysten avulla. Käsittele vastauksia suunnittelupäätösten lähtötietoina, älä lopullisina suunnittelupäätöksinä.",
+  "cycle.template.architecture-decision.title": "Arkkitehtuuripäätös",
+  "cycle.template.architecture-decision.description": "Vertaa mahdollisia arkkitehtuurivalintoja koottuihin vaatimuksiin, näyttöön, riskeihin ja avoimiin kysymyksiin.",
+  "cycle.template.api-architecture-decision.title": "API-arkkitehtuuripäätös",
+  "cycle.template.api-architecture-decision.description": "Dokumentoi API-arkkitehtuuria, alustaa, tietoturvaa, elinkaarta ja julkaisua koskevat päätökset.",
+  "cycle.template.integration-pattern-decision.title": "Integraatiomallin päätös",
+  "cycle.template.integration-pattern-decision.description": "Vertaa API-, tapahtuma-, tiedosto-, virta-, datatuote-, suora integraatio- ja hybridivaihtoehtoja vaatimuksiin.",
+  "cycle.template.human-validation.title": "Ihmisen tekemä validointi",
+  "cycle.template.human-validation.description": "Dokumentoi, kuka validoi tekoälyavusteiset tuotokset ja mitkä päätökset edellyttävät ihmisen vastuuta.",
+  "cycle.template.adr.title": "Arkkitehtuuripäätöksen dokumentti",
+  "cycle.template.adr.description": "Kirjaa valittu päätös, perustelut, vaihtoehdot, seuraukset, näyttö ja jatkotoimet.",
+  "cycle.api-productization-cycle.station.api-product-strategy.description": "Miellä API tuotteena, jolla on selkeä arvolupaus, hyödyntäjät, liiketoimintamalli, omistajuus ja elinkaaren tavoite.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.description": "Määrittele API-hyödyntäjäsegmentit, käyttöönoton polut, odotukset ja kokemukseen liittyvät vaatimukset ennen suunnittelupäätösten lukitsemista.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.description": "Valitse ja validoi API-tuotteen tarvitsema API-alusta, arkkitehtuuri, hallintamalli ja operatiiviset rajoitteet.",
+  "cycle.api-productization-cycle.station.api-design.description": "Suunnittele API-rajapintasopimus, vuorovaikutusmalli, skeemat, käytännöt ja käytettävyyden yksityiskohdat ennen toteutusta.",
+  "cycle.api-productization-cycle.station.api-delivery.description": "Toteuta, testaa, suojaa, automatisoi ja operoi API-tuotetta toimitusputken kautta.",
+  "cycle.api-productization-cycle.station.api-audit.description": "Validoi API-laatu, vaatimustenmukaisuus, naytto, operatiivinen valmius ja julkaisukriteerit.",
+  "cycle.api-productization-cycle.station.api-publishing.description": "Julkaise API-tuote, jotta hyodyntajat voivat loytaa sen, arvioida sen, pyytaa kayttooikeutta, suorittaa kayttoonoton, kayttaa sita ja saada tukea.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.description": "Seuraa APIen tilaa, käyttöönottoa, hyödyntäjien tuloksia, luotettavuutta ja parannusmahdollisuuksia julkaisun jälkeen.",
+  "cycle.integration-productization-cycle.station.api-product-strategy.description": "Kuvaa uudelleenkaytettava integraatiokyvykkyys, liiketoimintatarve, omistajuus ja odotettu uudelleenkaytto ennen toteutustavan valintaa.",
+  "cycle.integration-productization-cycle.station.api-consumer-experience.description": "Kokoa integraation hyödyntäjät, tuottajan vastuut, käyttöönoton tarpeet, palveluodotukset ja operatiiviset rajoitteet.",
+  "cycle.integration-productization-cycle.station.api-platform-architecture.description": "Valitse integraatioarkkitehtuuri, toteutustapa ja alustakyvykkyydet huomioiden rajoitteet ja hallintamalli.",
+  "cycle.integration-productization-cycle.station.api-design.description": "Suunnittele rajapintasopimus, skeemat, tietosisallot ja vuorovaikutusmallit valitulle integraatiotavalle.",
+  "cycle.integration-productization-cycle.station.api-delivery.description": "Rakenna, testaa, automatisoi, julkaise ja operoi integraatiokyvykkyyttä sen valitulla toteutustavalla ja validoidulla rajapintasopimuksella.",
+  "cycle.integration-productization-cycle.station.api-audit.description": "Varmista integraation valmius, hallintamalli, laatu, tietoturva, vaatimustenmukaisuus ja operatiivinen näyttö ennen julkaisua.",
+  "cycle.integration-productization-cycle.station.api-publishing.description": "Julkaise integraatiokyvykkyys, jotta tiimit voivat loytaa sen, arvioida sen, pyytaa kayttooikeutta, suorittaa kayttoonoton, kayttaa sita uudelleen ja saada tukea.",
+  "cycle.integration-productization-cycle.station.monitoring-and-improving.description": "Seuraa integraation luotettavuutta, uudelleenkäyttöä, häiriöitä, suorituskykyä, hyödyntäjien tuloksia ja parannustarpeita.",
+  "cycle.automation-cycle.title": "Automaatiosykli",
+  "cycle.automation-cycle.description": "Sykli automaatiomahdollisuuksien tunnistamiseen, suunnitteluun, toimittamiseen, käyttöönoton mahdollistamiseen ja parantamiseen.",
+  "cycle.automation-cycle.purpose": "Tuotteista automaatiomahdollisuuksia hallituiksi työnkuluiksi, joilla on selkeät käyttäjät, alustat, kontrollit, toimituspolut, käyttöönoton tuki ja seuranta.",
+  "cycle.audience.automation-owners": "Automaation omistajat",
+  "cycle.audience.process-owners": "Prosessinomistajat",
+  "cycle.audience.automation-teams": "Automaatiotiimit",
+  "cycle.station.automation-opportunity-strategy": "Automaatiomahdollisuuden strategia",
+  "cycle.station.process-user-requirements": "Prosessin ja käyttäjien vaatimukset",
+  "cycle.station.automation-platform-decision": "Automaatioalustan päätös",
+  "cycle.station.automation-workflow-design": "Automaatiotyönkulun suunnittelu",
+  "cycle.station.automation-delivery": "Automaation toimitus ja operointi",
+  "cycle.station.automation-readiness-review": "Automaation valmiuskatselmointi",
+  "cycle.station.automation-enablement": "Automaation kayttoonotto ja kayttoonoton tuki",
+  "cycle.station.automation-monitoring-improvement": "Automaation seuranta ja parantaminen",
+  "cycle.automation-cycle.station.api-product-strategy.description": "Tunnista ja priorisoi automaatiomahdollisuudet arvon, toteutettavuuden, riskin, omistajuuden ja odotetun prosessivaikutuksen perusteella.",
+  "cycle.automation-cycle.station.api-consumer-experience.description": "Kokoa prosessin käyttäjät, roolit, luovutukset, poikkeukset, rajoitteet ja palveluodotukset ennen automaation suunnittelua.",
+  "cycle.automation-cycle.station.api-platform-architecture.description": "Valitse automaatioalusta, ajoymparisto, integraatiotapa, hallintakontrollit ja operatiiviset rajoitteet.",
+  "cycle.automation-cycle.station.api-design.description": "Suunnittele automaation tyonkulku, kaynnistimet, paatospisteet, integraatiot, datankasittely, olennaiset rajapintasopimukset ja poikkeuspolut.",
+  "cycle.automation-cycle.station.api-delivery.description": "Rakenna, testaa, julkaise, dokumentoi ja operoi automaatiota selkeällä omistajuudella, kontrolleilla ja palautuspoluilla.",
+  "cycle.automation-cycle.station.api-audit.description": "Katselmoi automaation valmius, laatu, riski, vaatimustenmukaisuus, ihmisen valvonta, näyttö ja julkaisukriteerit.",
+  "cycle.automation-cycle.station.api-publishing.description": "Mahdollista käyttäjien ja operaattorien työ löydettävyyden, käyttöönoton, käyttöohjeiden, tukipolkujen ja muutosviestinnän avulla.",
+  "cycle.automation-cycle.station.monitoring-and-improving.description": "Seuraa automaation suorituskykyä, poikkeuksia, luotettavuutta, käyttäjien tuloksia, operatiivista vaikutusta ja parannusmahdollisuuksia."
+}
diff --git a/src/data/method/fi/labels.lines.json b/src/data/method/fi/labels.lines.json
index 26913f5..487ff2e 100644
--- a/src/data/method/fi/labels.lines.json
+++ b/src/data/method/fi/labels.lines.json
@@ -1,16 +1,16 @@
 {
   "lines.title": "Metrolinjat",
-  "lines.description": "API-linjausten kokoelma, joka ohjaa APIen kehittämistä ja hallintaa.",
-  "line.business-opportunities-line.title": "Liiketoimintamahdollisuudet linja",
-  "line.business-opportunities-line.description": "Keskittyy tunnistamaan ja hyödyntämään liiketoimintamahdollisuuksia sovellusrajapintojen avulla.",
+  "lines.description": "APIOps Cycles -metrolinjat, jotka ohjaavat kyvykkyyksien, APIen ja integraatioiden suunnittelua, toteutusta ja kehittämistä.",
+  "line.business-opportunities-line.title": "Liiketoimintamahdollisuuksien linja",
+  "line.business-opportunities-line.description": "Keskittyy tunnistamaan, arvioimaan ja tuotteistamaan liiketoimintamahdollisuuksia uudelleenkäytettävinä kyvykkyyksinä.",
   "line.platform-architecture-line.title": "Alusta-arkkitehtuurilinja",
-  "line.platform-architecture-line.description": "Kattaa API-alustojen arkkitehtuurinäkökohtia.",
+  "line.platform-architecture-line.description": "Kattaa alustojen, integraatioiden ja rajapintojen arkkitehtuurin suunnittelun.",
   "line.api-design-line.title": "API-suunnittelulinja",
-  "line.api-design-line.description": "Keskittyy APIen suunnitteluperiaatteisiin ja -käytäntöihin.",
+  "line.api-design-line.description": "Keskittyy rajapintojen ja integraatioratkaisujen suunnitteluperiaatteisiin ja -käytäntöihin.",
   "line.delivery-line.title": "Toimituslinja",
-  "line.delivery-line.description": "Kattaa APIen toimitusprosessit ja -käytännöt.",
-  "line.publishing-and-adoption-line.title": "Julkaisu- ja hyväksymislinja",
-  "line.publishing-and-adoption-line.description": "Keskittyy API-rajapintojen julkaisemiseen ja sen varmistamiseen, että kuluttajat hyväksyvät ne.",
-  "line.operating-model-line.title": "Toimintamalli Line",
-  "line.operating-model-line.description": "Kattaa API-hallinnan ja -hallinnan toimintamallin."
-}
+  "line.delivery-line.description": "Kattaa toteutuksen, testauksen, automaation ja toimituskäytännöt.",
+  "line.publishing-and-adoption-line.title": "Julkaisu- ja käyttöönoton linja",
+  "line.publishing-and-adoption-line.description": "Keskittyy kyvykkyyksien julkaisemiseen, käyttöönottoon ja hyödyntämisen tukemiseen.",
+  "line.operating-model-line.title": "Toimintamallilinja",
+  "line.operating-model-line.description": "Kattaa kyvykkyyksien hallintamallin, vastuut ja governance-käytännöt."
+}
\ No newline at end of file
diff --git a/src/data/method/fi/labels.resources.json b/src/data/method/fi/labels.resources.json
index cd88e3c..178eaf7 100644
--- a/src/data/method/fi/labels.resources.json
+++ b/src/data/method/fi/labels.resources.json
@@ -1,399 +1,399 @@
 {
   "resource.api-community-engagement-strategies.title": "API-yhteisön sitouttamisstrategiat",
   "resource.api-community-engagement-strategies.description": "Toimintakirja API-käyttöliittymien käyttöönoton edistämiseksi kehittämällä yhteisöjä sisällön, tukikanavien, palautesilmukoiden ja sosiaalisen sitoutumisen strategioiden avulla.",
-  "resource.api-community-engagement-strategies.outcomes": "API-yhteisön sitouttamisstrategioiden periaatteiden parempi ymmärtäminen",
+  "resource.api-community-engagement-strategies.outcomes": "Yhteinen ymmärrys resurssin API-yhteisön sitouttamisstrategiat tarkoituksesta ja käytöstä",
   "resource.api-community-engagement-strategies.steps": "Kehitä markkinointistrategioita APIen markkinoimiseksi kohdeyleisöille, mukaan lukien sosiaalinen media, blogit ja webinaarit.",
-  "resource.api-community-engagement-strategies.tips": "Mukauta API-yhteisön sitouttamisstrategiat toimialueellesi sopiviksi",
+  "resource.api-community-engagement-strategies.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.api-compliance-best-practices.title": "API-vaatimustenmukaisuuden parhaat käytännöt",
-  "resource.api-compliance-best-practices.description": "Varmista, että sovellusrajapinnat täyttävät oikeudelliset, sääntelyyn liittyvät ja sisäiset vaatimukset dokumentoinnin, valvonnan ja automaattisten validointien avulla.",
-  "resource.api-compliance-best-practices.outcomes": "Parempi ymmärrys API-vaatimustenmukaisuuden parhaiden käytäntöjen periaatteista",
-  "resource.api-compliance-best-practices.steps": "dokumentoida vaatimustenmukaisuustoimenpiteet ja varmistaa, että niistä tiedotetaan sidosryhmille ja kuluttajille.",
-  "resource.api-compliance-best-practices.tips": "Mukauta API Compliance Best Practices -käytännöt omaan toimialueeseesi.",
+  "resource.api-compliance-best-practices.description": "Varmista, että rajapinnat täyttävät oikeudelliset, sääntelyyn liittyvät ja sisäiset vaatimukset dokumentoinnin, valvonnan ja automaattisten validointien avulla.",
+  "resource.api-compliance-best-practices.outcomes": "Yhteinen ymmärrys resurssin API-vaatimustenmukaisuuden parhaat käytännöt tarkoituksesta ja käytöstä",
+  "resource.api-compliance-best-practices.steps": "Dokumentoi vaatimustenmukaisuustoimenpiteet ja varmista, että niistä tiedotetaan sidosryhmille ja hyödyntäjille.",
+  "resource.api-compliance-best-practices.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.api-development-best-practices.title": "API-kehityksen parhaat käytännöt",
-  "resource.api-development-best-practices.description": "Ohjeet, joiden avulla validoitu API-sopimus voidaan muuttaa johdonmukaiseksi ja ylläpidettäväksi API-koodiksi käyttämällä vakiokirjastoja, uudelleenkäytettäviä malleja ja yhdenmukaistettuja kehitystyönkulkuja.",
-  "resource.api-development-best-practices.outcomes": "API-kehityksen parhaiden käytäntöjen periaatteiden parempi ymmärtäminen",
-  "resource.api-development-best-practices.steps": "Sovella näitä käytäntöjä validoituun API-sopimukseen ja toteutussuunnitelmaan ennen koodaamisen aloittamista.",
-  "resource.api-development-best-practices.tips": "Mukauta API-kehityksen parhaat käytännöt omaan toimialueeseesi sopiviksi",
+  "resource.api-development-best-practices.description": "Toteutusohje, jonka avulla validoitu API-rajapintasopimus muutetaan johdonmukaiseksi ja ylläpidettäväksi API-koodipohjaksi vakiokirjastojen, uudelleenkäytettävien mallien ja yhteensovitettujen kehitystyönkulkujen avulla.",
+  "resource.api-development-best-practices.outcomes": "Yhteinen ymmärrys resurssin API-kehityksen parhaat käytännöt tarkoituksesta ja käytöstä",
+  "resource.api-development-best-practices.steps": "Sovella näitä käytäntöjä validoituun API-rajapintasopimukseen ja toteutussuunnitelmaan ennen koodaamisen aloittamista.",
+  "resource.api-development-best-practices.tips": "Mukauta API-kehityksen parhaat käytännöt omaan kontekstiisi sopiviksi",
   "resource.api-metrics-and-analytics.title": "API-mittarit ja analytiikka",
   "resource.api-metrics-and-analytics.description": "Resurssi API-suorituskyvyn ja käyttötietojen määrittelyyn, keräämiseen ja analysointiin, jotta tekniset KPI:t voidaan sovittaa yhteen liiketoiminnan tulosten kanssa.",
-  "resource.api-metrics-and-analytics.outcomes": "Parempi ymmärrys API-mittareista ja analytiikan periaatteista.",
+  "resource.api-metrics-and-analytics.outcomes": "Yhteinen ymmärrys resurssin API-mittarit ja analytiikka tarkoituksesta ja käytöstä",
   "resource.api-metrics-and-analytics.steps": "Määritä keskeiset suorituskykyindikaattorit (KPI), joilla mitataan APIn onnistumista suhteessa liiketoiminnan tavoitteisiin.",
-  "resource.api-metrics-and-analytics.tips": "Mukauta API-mittareita ja analytiikkaa toimialueellesi.",
+  "resource.api-metrics-and-analytics.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.api-onboarding-best-practices.title": "API-käyttöönoton parhaat käytännöt",
   "resource.api-onboarding-best-practices.description": "Parhaat käytännöt API-asiakkaiden käyttöönoton sujuvoittamiseksi vaiheittaisella rekisteröinnillä, tutustumisella ja ensisoitto-opastuksella.",
-  "resource.api-onboarding-best-practices.outcomes": "Parempi ymmärrys API-käyttöönoton parhaiden käytäntöjen periaatteista.",
-  "resource.api-onboarding-best-practices.steps": "Määrittele API-kuluttajan matka löytämisestä vianmääritykseen ja tunnista keskeiset kosketuspisteet ja kipupisteet.",
-  "resource.api-onboarding-best-practices.tips": "Mukauta API Onboarding Best Practices -käytännöt omalle toimialueellesi.",
+  "resource.api-onboarding-best-practices.outcomes": "Yhteinen ymmärrys resurssin API-käyttöönoton parhaat käytännöt tarkoituksesta ja käytöstä",
+  "resource.api-onboarding-best-practices.steps": "Määrittele API-hyödyntäjän matka löytämisestä vianmääritykseen ja tunnista keskeiset kosketuspisteet ja kipupisteet.",
+  "resource.api-onboarding-best-practices.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.api-portfolio-management-guidelines.title": "API-portfolion hallinnan suuntaviivat",
   "resource.api-portfolio-management-guidelines.description": "Opas organisaation API-sarjan strategiseen hallintaan - APIen priorisointiin, resurssien jakamiseen ja suorituskyvyn seurantaan koko elinkaaren ajan.",
-  "resource.api-portfolio-management-guidelines.outcomes": "API-salkunhallinnan suuntaviivojen periaatteiden parempi ymmärtäminen",
+  "resource.api-portfolio-management-guidelines.outcomes": "Yhteinen ymmärrys resurssin API-portfolion hallinnan suuntaviivat tarkoituksesta ja käytöstä",
   "resource.api-portfolio-management-guidelines.steps": "Määrittele salkunhallintakäytännöt, joissa hahmotellaan API-salkun hallinnointiprosessit, mukaan lukien priorisointi, seuranta ja optimointi.",
-  "resource.api-portfolio-management-guidelines.tips": "Mukauta API-salkunhallintaohjeet toimialueellesi sopiviksi",
+  "resource.api-portfolio-management-guidelines.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.api-security-best-practices.title": "API-turvallisuuden parhaat käytännöt",
-  "resource.api-security-best-practices.description": "Joukko toimivia valvontatoimia sovellusrajapintojen suojaamiseksi, mukaan lukien todennus, valtuutus, salaus, nopeuden rajoittaminen ja putkitason vaatimustenmukaisuustarkastukset.",
-  "resource.api-security-best-practices.outcomes": "API-turvan parhaiden käytäntöjen periaatteiden parempi ymmärtäminen",
-  "resource.api-security-best-practices.steps": "Varmista, että sovellusrajapinnat täyttävät turvallisuus- ja vaatimustenmukaisuusvaatimukset automaattisten tarkastusten ja auditointien avulla.",
-  "resource.api-security-best-practices.tips": "Mukauta API Security Best Practices -käytännöt toimialueellesi.",
+  "resource.api-security-best-practices.description": "Joukko toimivia valvontatoimia rajapintojen suojaamiseksi, mukaan lukien todennus, valtuutus, salaus, nopeuden rajoittaminen ja putkitason vaatimustenmukaisuustarkastukset.",
+  "resource.api-security-best-practices.outcomes": "Yhteinen ymmärrys resurssin API-turvallisuuden parhaat käytännöt tarkoituksesta ja käytöstä",
+  "resource.api-security-best-practices.steps": "Varmista, että rajapinnat täyttävät turvallisuus- ja vaatimustenmukaisuusvaatimukset automaattisten tarkastusten ja auditointien avulla.",
+  "resource.api-security-best-practices.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.api-team-structure-guidelines.title": "API-tiimin rakennetta koskevat ohjeet",
   "resource.api-team-structure-guidelines.description": "Organisatoriset ohjeet roolien ja vastuualueiden määrittelemiseksi API-tiimeissä selkeyden, yhteistyön ja vastuuvelvollisuuden varmistamiseksi.",
-  "resource.api-team-structure-guidelines.outcomes": "API-tiimin rakenteen suuntaviivojen periaatteiden parempi ymmärtäminen",
+  "resource.api-team-structure-guidelines.outcomes": "Yhteinen ymmärrys resurssin API-tiimin rakennetta koskevat ohjeet tarkoituksesta ja käytöstä",
   "resource.api-team-structure-guidelines.steps": "Määrittele API-tiimien tiimirakenteet ja roolit, mukaan lukien API-tuotteen omistajat, kehittäjät, arkkitehdit ja toiminnot.",
-  "resource.api-team-structure-guidelines.tips": "Mukauta API-tiimirakenneohjeet omaan toimialueeseesi sopiviksi",
+  "resource.api-team-structure-guidelines.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.api-testing-best-practices.title": "API-testauksen parhaat käytännöt",
-  "resource.api-testing-best-practices.description": "Ohjeet automatisoidun toiminnallisen, suorituskyky- ja tietoturvatestauksen toteuttamiseksi koko sovellusrajapinnan elinkaaren ajan.",
-  "resource.api-testing-best-practices.outcomes": "Parempi ymmärrys API-testauksen parhaiden käytäntöjen periaatteista",
-  "resource.api-testing-best-practices.steps": "Testaa sovellusrajapintojen toimivuutta, turvallisuutta ja suorituskykyä automaattisten testausvälineiden avulla.",
-  "resource.api-testing-best-practices.tips": "Mukauta API-testauksen parhaat käytännöt omaan toimialueeseesi sopiviksi",
+  "resource.api-testing-best-practices.description": "Ohjeet automatisoidun toiminnallisen, suorituskyky- ja tietoturvatestauksen toteuttamiseksi koko rajapinnan elinkaaren ajan.",
+  "resource.api-testing-best-practices.outcomes": "Yhteinen ymmärrys resurssin API-testauksen parhaat käytännöt tarkoituksesta ja käytöstä",
+  "resource.api-testing-best-practices.steps": "Testaa rajapintojen toimivuutta, turvallisuutta ja suorituskykyä automaattisten testausvälineiden avulla.",
+  "resource.api-testing-best-practices.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.api-training-programs.title": "API-koulutusohjelmat",
-  "resource.api-training-programs.description": "Etenemissuunnitelma tiimien pätevöittämistä varten, jossa on jäsenneltyjä oppimispolkuja API-suunnittelun, hallinnan, suorituskyvyn ja tietoturvan alalla.",
-  "resource.api-training-programs.outcomes": "API-koulutusohjelmien periaatteiden parempi ymmärtäminen",
-  "resource.api-training-programs.steps": "Tunnistetaan keskeiset API-taidot ja -tiedot, joita on kehitettävä, kuten API-suunnittelu, tietoturva ja suorituskyky.",
-  "resource.api-training-programs.tips": "Mukauta API-koulutusohjelmat toimialueellesi sopiviksi",
+  "resource.api-training-programs.description": "Etenemissuunnitelma tiimien pätevöittämistä varten, jossa on jäsenneltyjä oppimispolkuja API-designin, hallinnan, suorituskyvyn ja tietoturvan alalla.",
+  "resource.api-training-programs.outcomes": "Yhteinen ymmärrys resurssin API-koulutusohjelmat tarkoituksesta ja käytöstä",
+  "resource.api-training-programs.steps": "Tunnistetaan keskeiset API-taidot ja -tiedot, joita on kehitettävä, kuten API-design, tietoturva ja suorituskyky.",
+  "resource.api-training-programs.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.api-versioning-best-practices.title": "API-versionoinnin parhaat käytännöt",
-  "resource.api-versioning-best-practices.description": "Strategiat API-versioiden käyttöönottoa, ylläpitoa ja käytöstä poistamista varten siten, että taaksepäin yhteensopivuus ja kuluttajien luottamus säilyvät.",
-  "resource.api-versioning-best-practices.outcomes": "Parempi ymmärrys API-versionoinnin parhaiden käytäntöjen periaatteista",
-  "resource.api-versioning-best-practices.steps": "Määrittele sovellusrajapintojen versiointistrategiat muutosten hallitsemiseksi ja taaksepäin yhteensopivuuden varmistamiseksi.",
-  "resource.api-versioning-best-practices.tips": "Mukauta API Versioning Best Practices -käytännöt toimialuettasi varten",
-  "resource.apiops-CI-CD-for-apis.title": "APIOps CI/CD sovellusrajapinnoille",
+  "resource.api-versioning-best-practices.description": "Strategiat API-versioiden käyttöönottoa, ylläpitoa ja käytöstä poistamista varten siten, että taaksepäin yhteensopivuus ja hyödyntäjien luottamus säilyvät.",
+  "resource.api-versioning-best-practices.outcomes": "Yhteinen ymmärrys resurssin API-versionoinnin parhaat käytännöt tarkoituksesta ja käytöstä",
+  "resource.api-versioning-best-practices.steps": "Määrittele rajapintojen versiointistrategiat muutosten hallitsemiseksi ja taaksepäin yhteensopivuuden varmistamiseksi.",
+  "resource.api-versioning-best-practices.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
+  "resource.apiops-CI-CD-for-apis.title": "APIOps CI/CD rajapinnoille",
   "resource.apiops-CI-CD-for-apis.description": "Käyttöönotto-ohjeet, jotka integroivat APIn elinkaaren tehtävät - suunnittelun, testauksen ja hallinnan - jatkuvaan integrointiin ja toimitusputkiin.",
-  "resource.apiops-CI-CD-for-apis.outcomes": "Parempi ymmärrys CI/CD for APIs -periaatteista",
+  "resource.apiops-CI-CD-for-apis.outcomes": "Yhteinen ymmärrys resurssin APIOps CI/CD rajapinnoille tarkoituksesta ja käytöstä",
   "resource.apiops-CI-CD-for-apis.steps": "Käytä CI/CD-putkia rakentamis-, testaus- ja käyttöönottoprosessien automatisoimiseksi varmistaen johdonmukaisen laadun ja jäljitettävyyden.",
-  "resource.apiops-CI-CD-for-apis.tips": "Mukauta CI/CD for APIs -ohjelmistoa toimialueellesi sopivaksi",
-  "resource.competitor-analysis-template.title": "Kilpailija-analyysi malli",
+  "resource.apiops-CI-CD-for-apis.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
+  "resource.competitor-analysis-template.title": "Kilpailija-analyysimalli",
   "resource.competitor-analysis-template.description": "Strukturoitu työlista, jonka avulla voit vertailla API-tarjouksiasi kilpailijoihin kartoittamalla vahvuudet, heikkoudet ja erottavia tekijöitä.",
-  "resource.competitor-analysis-template.outcomes": "Kilpailija-analyysin malliperiaatteiden parempi ymmärtäminen",
+  "resource.competitor-analysis-template.outcomes": "Yhteinen ymmärrys resurssin Kilpailija-analyysimalli tarkoituksesta ja käytöstä",
   "resource.competitor-analysis-template.steps": "Suorita kilpailija-analyysi tärkeimpien kilpailijoiden ja niiden API-tarjonnan tunnistamiseksi.",
-  "resource.competitor-analysis-template.tips": "Mukauta kilpailija-analyysimalli omalle verkkotunnuksellesi.",
-  "resource.contract-first-design.title": "Sopimus First Design",
+  "resource.competitor-analysis-template.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
+  "resource.contract-first-design.title": "Sopimuslähtöinen suunnittelu",
   "resource.contract-first-design.description": "Suuntaviiva, jossa kannatetaan API-lähestymistapaa, jossa käytetään virallisia sopimuksia (esim. OpenAPI) sidosryhmien yhdenmukaistamiseksi ennen kehitystä.",
-  "resource.contract-first-design.outcomes": "Parempi ymmärrys sopimuksen suunnitteluperiaatteista",
+  "resource.contract-first-design.outcomes": "Yhteinen ymmärrys resurssin Sopimuslähtöinen suunnittelu tarkoituksesta ja käytöstä",
   "resource.contract-first-design.steps": "Sovellat sopimuslähtöisiä tai suunnittelulähtöisiä lähestymistapoja varmistaaksesi, että API-sopimukset validoidaan ennen toteutusta.",
-  "resource.contract-first-design.tips": "Mukauta Sopimus ensin -suunnittelua verkkotunnuksellesi",
+  "resource.contract-first-design.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.cross-functional-collaboration-best-practices.title": "Toimialarajat ylittävän yhteistyön parhaat käytännöt",
   "resource.cross-functional-collaboration-best-practices.description": "Käytännöt, joilla helpotetaan viestintää ja yhdenmukaistamista liiketoiminta- ja tekniikkatiimien välillä API-rajapintoja suunniteltaessa tai toimitettaessa.",
-  "resource.cross-functional-collaboration-best-practices.outcomes": "Toimialojen välisen yhteistyön parhaiden käytäntöjen periaatteiden parempi ymmärtäminen",
+  "resource.cross-functional-collaboration-best-practices.outcomes": "Yhteinen ymmärrys resurssin Toimialarajat ylittävän yhteistyön parhaat käytännöt tarkoituksesta ja käytöstä",
   "resource.cross-functional-collaboration-best-practices.steps": "Kannustaa API-tiimien, liiketoimintayksiköiden ja sidosryhmien välistä monialaista yhteistyötä, jotta API-aloitteet voidaan sovittaa yhteen liiketoiminnan tavoitteiden kanssa.",
-  "resource.cross-functional-collaboration-best-practices.tips": "Räätälöi monialaisen yhteistyön parhaat käytännöt omalle toimialueellesi.",
+  "resource.cross-functional-collaboration-best-practices.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.data-privacy-guidelines.title": "Tietosuojaa koskevat ohjeet",
-  "resource.data-privacy-guidelines.description": "Suunnitteluun liittyvät näkökohdat, joilla varmistetaan, että sovellusrajapinnat täyttävät tietosuojasäännökset, kuten GDPR:n, anonymisoinnin ja pääsynvalvonnan avulla.",
-  "resource.data-privacy-guidelines.outcomes": "Tietosuojaa koskevien suuntaviivojen periaatteiden parempi ymmärtäminen",
+  "resource.data-privacy-guidelines.description": "Suunnitteluun liittyvät näkökohdat, joilla varmistetaan, että rajapinnat täyttävät tietosuojasäännökset, kuten GDPR:n, anonymisoinnin ja pääsynvalvonnan avulla.",
+  "resource.data-privacy-guidelines.outcomes": "Yhteinen ymmärrys resurssin Tietosuojaa koskevat ohjeet tarkoituksesta ja käytöstä",
   "resource.data-privacy-guidelines.steps": "Varmista käyttäjien tietojen yksityisyys toteuttamalla tietosuojatoimenpiteitä, kuten anonymisointi ja käyttöoikeuksien valvonta.",
-  "resource.data-privacy-guidelines.tips": "Mukauta tietosuojaohjeet verkkotunnuksellesi",
-  "resource.domain-canvas.title": "Domain Canvas",
-  "resource.domain-canvas.description": "Mallinnustyökalu, jolla määritellään ja välitetään toimialueesi keskeiset entiteetit ja suhteet ja varmistetaan semanttinen yhdenmukaisuus eri sovellusrajapinnoissa.",
-  "resource.domain-canvas.outcomes": "Parempi ymmärrys toimialueen kangasperiaatteista",
-  "resource.domain-canvas.steps": "Määrittele keskeiset oliot, niiden attribuutit ja suhteet yhteisen käsitteellisen ymmärryksen luomiseksi eri sovellusliittymille.",
-  "resource.domain-canvas.tips": "Mukauta Domain Canvas verkkotunnusta varten",
-  "resource.ecosystem-vision-template.title": "Ekosysteemivision malli",
+  "resource.data-privacy-guidelines.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
+  "resource.domain-canvas.title": "Toimialuekanvas",
+  "resource.domain-canvas.description": "Mallinnustyökalu toimialueen keskeisten käsitteiden, entiteettien, suhteiden ja sääntöjen määrittelyyn, jotta kyvykkyydet, rajapinnat ja integraatiot pysyvät semanttisesti yhdenmukaisina.",
+  "resource.domain-canvas.outcomes": "Parempi ymmärrys toimialueen mallinnuksesta",
+  "resource.domain-canvas.steps": "Määrittele keskeiset oliot, niiden attribuutit ja suhteet yhteisen käsitteellisen ymmärryksen luomiseksi eri rajapinnoille ja kyvykkyyksille.",
+  "resource.domain-canvas.tips": "Mukauta Toimialuekanvas omaan kontekstiisi",
+  "resource.ecosystem-vision-template.title": "Ekosysteemivisiomalli",
   "resource.ecosystem-vision-template.description": "Strateginen suunnittelutyökalu API-ekosysteemin määrittelemiseksi, mukaan lukien kohdekumppanit, arvoketjut ja integrointimahdollisuudet.",
-  "resource.ecosystem-vision-template.outcomes": "Parempi ymmärrys ekosysteemivision malliperiaatteista",
+  "resource.ecosystem-vision-template.outcomes": "Yhteinen ymmärrys resurssin Ekosysteemivisiomalli tarkoituksesta ja käytöstä",
   "resource.ecosystem-vision-template.steps": "Markkinatutkimuksen tekeminen API-toimialalla vallitsevien suuntausten, mahdollisuuksien ja uhkien tunnistamiseksi.",
-  "resource.ecosystem-vision-template.tips": "Mukauta Ecosystem Vision Template -mallia toimialueellesi.",
+  "resource.ecosystem-vision-template.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.industry-standards-and-best-practices.title": "Alan standardit ja parhaat käytännöt",
-  "resource.industry-standards-and-best-practices.description": "Viiteresurssi API-suunnittelun ja -toiminnan mukauttamiseksi laajalti tunnustettuihin alan kehyksiin ja eritelmiin.",
-  "resource.industry-standards-and-best-practices.outcomes": "alan standardien ja parhaiden käytäntöjen periaatteiden parempi ymmärtäminen",
-  "resource.industry-standards-and-best-practices.steps": "Tunnistetaan alan standardit ja parhaat käytännöt, jotta voidaan varmistaa, että sovellusrajapinnat ovat kilpailukykyisiä ja yhteensopivia.",
-  "resource.industry-standards-and-best-practices.tips": "Mukauta toimialan standardit ja parhaat käytännöt omaan toimialueeseesi.",
+  "resource.industry-standards-and-best-practices.description": "Viiteresurssi API-designin ja -toiminnan mukauttamiseksi laajalti tunnustettuihin alan kehyksiin ja eritelmiin.",
+  "resource.industry-standards-and-best-practices.outcomes": "Yhteinen ymmärrys resurssin Alan standardit ja parhaat käytännöt tarkoituksesta ja käytöstä",
+  "resource.industry-standards-and-best-practices.steps": "Tunnistetaan alan standardit ja parhaat käytännöt, jotta voidaan varmistaa, että rajapinnat ovat kilpailukykyisiä ja yhteensopivia.",
+  "resource.industry-standards-and-best-practices.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.partner-integration-guidelines.title": "Kumppanien integrointiohjeet",
   "resource.partner-integration-guidelines.description": "Integroinnin tarkistuslistat ja viestintämallit kolmannen osapuolen API-suhteiden teknisten ja oikeudellisten näkökohtien hallintaan.",
-  "resource.partner-integration-guidelines.outcomes": "Parempi ymmärrys kumppanien integroinnin suuntaviivojen periaatteista",
+  "resource.partner-integration-guidelines.outcomes": "Yhteinen ymmärrys resurssin Kumppanien integrointiohjeet tarkoituksesta ja käytöstä",
   "resource.partner-integration-guidelines.steps": "Luodaan integraatioprosessit ja -ohjeet yhteistyökumppaneiden kanssa tehtävää yhteistyötä varten, mukaan lukien tekninen integraatio, tietojen jakaminen ja tuki.",
-  "resource.partner-integration-guidelines.tips": "Mukauta kumppanien integrointiohjeet toimialueellesi",
+  "resource.partner-integration-guidelines.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.role-communication-best-practices.title": "Rooliviestinnän parhaat käytännöt",
-  "resource.role-communication-best-practices.description": "Työkalut, joilla määritetään ja dokumentoidaan, kuka on vastuussa mistäkin API-aloitteesta, ja varmistetaan, että vastuunjako ja vastuuvelvollisuus ovat selkeät.",
-  "resource.role-communication-best-practices.outcomes": "rooliviestinnän parhaiden käytäntöjen periaatteiden parempi ymmärtäminen",
-  "resource.role-communication-best-practices.steps": "Määritä selkeät vastuualueet kullekin roolille, mukaan lukien API-suunnittelu, kehittäminen, testaus ja toiminta.",
-  "resource.role-communication-best-practices.tips": "Mukauta rooliviestinnän parhaat käytännöt toimialueellesi.",
+  "resource.role-communication-best-practices.description": "Työkalut, joilla määritetään ja kuvataan API-aloitteiden vastuut sekä varmistetaan selkeä työnjako ja vastuuvelvollisuus.",
+  "resource.role-communication-best-practices.outcomes": "Yhteinen ymmärrys resurssin Rooliviestinnän parhaat käytännöt tarkoituksesta ja käytöstä",
+  "resource.role-communication-best-practices.steps": "Määritä selkeät vastuualueet kullekin roolille, mukaan lukien API-design, kehittäminen, testaus ja toiminta.",
+  "resource.role-communication-best-practices.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.scalable-infrastructure-best-practices.title": "Skaalautuvan infrastruktuurin parhaat käytännöt",
-  "resource.scalable-infrastructure-best-practices.description": "Arkkitehtuuriohjeet sen varmistamiseksi, että sovellusrajapinnat otetaan käyttöön infrastruktuurissa, joka pystyy käsittelemään joustavasti käyttöpiikkejä ja -kasvua.",
-  "resource.scalable-infrastructure-best-practices.outcomes": "Parempi ymmärrys skaalautuvan infrastruktuurin parhaiden käytäntöjen periaatteista.",
+  "resource.scalable-infrastructure-best-practices.description": "Arkkitehtuuriohjeet sen varmistamiseksi, että rajapinnat otetaan käyttöön infrastruktuurissa, joka pystyy käsittelemään joustavasti käyttöpiikkejä ja -kasvua.",
+  "resource.scalable-infrastructure-best-practices.outcomes": "Yhteinen ymmärrys resurssin Skaalautuvan infrastruktuurin parhaat käytännöt tarkoituksesta ja käytöstä",
   "resource.scalable-infrastructure-best-practices.steps": "Suunnittele API-infrastruktuuri skaalautuvaksi ja joustavaksi käyttäen pilvipohjaisia malleja ja teknologioita.",
-  "resource.scalable-infrastructure-best-practices.tips": "Mukauta skaalautuvan infrastruktuurin parhaat käytännöt toimialueellesi.",
+  "resource.scalable-infrastructure-best-practices.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.service-agreement-template.title": "Palvelusopimusmalli",
   "resource.service-agreement-template.description": "Mukautettava sopimusmuoto, jossa määritellään odotukset, SLA:t, vastuut ja käyttöoikeusehdot API-käyttöä varten.",
-  "resource.service-agreement-template.outcomes": "Palvelusopimusmallin periaatteiden parempi ymmärtäminen",
-  "resource.service-agreement-template.steps": "Määrittele palvelusopimukset, joissa hahmotellaan odotukset, palvelutasot ja vastuualueet kutakin sovellusrajapintaa varten.",
-  "resource.service-agreement-template.tips": "Mukauta palvelusopimusmalli omalle verkkotunnuksellesi.",
+  "resource.service-agreement-template.outcomes": "Yhteinen ymmärrys resurssin Palvelusopimusmalli tarkoituksesta ja käytöstä",
+  "resource.service-agreement-template.steps": "Määrittele palvelusopimukset, joissa hahmotellaan odotukset, palvelutasot ja vastuualueet kutakin rajapintaa varten.",
+  "resource.service-agreement-template.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.stakeholder-engagement-best-practices.title": "Sidosryhmien sitouttamisen parhaat käytännöt",
   "resource.stakeholder-engagement-best-practices.description": "sitouttamistaktiikat sisäisten ja ulkoisten sidosryhmien saattamiseksi yhteisten API-tavoitteiden, -arvon ja -hallinnan piiriin.",
-  "resource.stakeholder-engagement-best-practices.outcomes": "Sidosryhmien sitouttamisen parhaiden käytäntöjen periaatteiden parempi ymmärtäminen",
+  "resource.stakeholder-engagement-best-practices.outcomes": "Yhteinen ymmärrys resurssin Sidosryhmien sitouttamisen parhaat käytännöt tarkoituksesta ja käytöstä",
   "resource.stakeholder-engagement-best-practices.steps": "Sidosryhmien sitouttaminen varmistamaan API-aloitteiden yhdenmukaisuus ja tuki.",
-  "resource.stakeholder-engagement-best-practices.tips": "Mukauta sidosryhmien sitouttamisen parhaat käytännöt omalle toimialueellesi.",
+  "resource.stakeholder-engagement-best-practices.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.test-automation-frameworks.title": "Testausautomaation kehykset",
-  "resource.test-automation-frameworks.description": "Suositellut työkalut ja mallit API-sopimus-, regressio- ja integrointitestauksen automatisointiin eri ympäristöissä.",
-  "resource.test-automation-frameworks.outcomes": "Parempi ymmärrys testiautomaatiokehysten periaatteista.",
+  "resource.test-automation-frameworks.description": "Suositellut työkalut ja mallit API-rajapintasopimus-, regressio- ja integrointitestauksen automatisointiin eri ympäristöissä.",
+  "resource.test-automation-frameworks.outcomes": "Yhteinen ymmärrys resurssin Testausautomaation kehykset tarkoituksesta ja käytöstä",
   "resource.test-automation-frameworks.steps": "Toteuta testiautomaatiokehykset, jotka tukevat sopimustestausta, integrointitestausta ja päästä päähän -testausta.",
-  "resource.test-automation-frameworks.tips": "Testausautomaatiokehysten mukauttaminen omaan toimialueeseesi sopiviksi",
+  "resource.test-automation-frameworks.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.vendor-management-best-practices.title": "Toimittajien hallinnan parhaat käytännöt",
   "resource.vendor-management-best-practices.description": "Kehys ulkoisten API-toimittajien ja kolmansien osapuolten integraatioiden arviointia ja hallintaa varten riskien, suorituskyvyn ja vaatimustenmukaisuuden perusteella.",
-  "resource.vendor-management-best-practices.outcomes": "Parempi ymmärrys myyjien hallinnan parhaiden käytäntöjen periaatteista",
-  "resource.vendor-management-best-practices.steps": "Ota käyttöön toimittajahallintaprosessit kolmansien osapuolten API-toimittajien arviointia, käyttöönottoa ja seurantaa varten.",
-  "resource.vendor-management-best-practices.tips": "Mukauta myyjien hallinnan parhaat käytännöt omalle toimialueellesi.",
+  "resource.vendor-management-best-practices.outcomes": "Yhteinen ymmärrys resurssin Toimittajien hallinnan parhaat käytännöt tarkoituksesta ja käytöstä",
+  "resource.vendor-management-best-practices.steps": "Ota käyttöön toimittajagovernance-prosessit kolmansien osapuolten API-toimittajien arviointia, käyttöönottoa ja seurantaa varten.",
+  "resource.vendor-management-best-practices.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
   "resource.api-audit-checklist.title": "API-auditoinnin tarkistuslista",
   "resource.api-audit-checklist.description": "Elinkaaripohjainen tarkistuslista, jolla varmistetaan APIn valmius suunnittelun, toimituksen, julkaisun ja vaatimustenmukaisuuden osalta määriteltyjen auditointikriteerien ja todisteiden avulla.",
-  "resource.api-audit-checklist.outcomes": "Parempi ymmärrys API-auditoinnin tarkistuslistan periaatteista",
-  "resource.api-audit-checklist.steps": "Varmista API-auditoinnin tarkistuslistan avulla, että API-suunnittelu täyttää toiminnalliset ja muut kuin toiminnalliset vaatimukset, mukaan lukien tietoturva, suorituskyky ja vaatimustenmukaisuus.",
+  "resource.api-audit-checklist.outcomes": "Yhteinen ymmärrys resurssin API-auditoinnin tarkistuslista tarkoituksesta ja käytöstä",
+  "resource.api-audit-checklist.steps": "Varmista API-auditoinnin tarkistuslistan avulla, että API-design täyttää toiminnalliset ja muut kuin toiminnalliset vaatimukset, mukaan lukien tietoturva, suorituskyky ja vaatimustenmukaisuus.",
   "resource.api-audit-checklist.tips": "Jokainen auditointikohta yhdistää elinkaaren työvaiheet (asemat), ohjaavat ohjeet ja tukevat todisteet, jotta APIn valmiudesta saadaan selkeä kuva.",
-  "resource.api-business-model-canvas.title": "API Business Model Canvas",
-  "resource.api-business-model-canvas.description": "Arvioi strategisesti API-liiketoiminnan elinkelpoisuutta kartoittamalla arvolupaukset, kuluttajasegmentit ja tärkeimmät resurssit.",
-  "resource.api-business-model-canvas.outcomes": "Selkeä liiketoimintastrategia sovellusrajapintoja varten",
+  "resource.api-business-model-canvas.title": "API-liiketoimintamallikanvas",
+  "resource.api-business-model-canvas.description": "Arvioi API-liiketoiminnan elinkelpoisuutta kartoittamalla arvolupaus, API-hyödyntäjäsegmentit ja keskeiset resurssit.",
+  "resource.api-business-model-canvas.outcomes": "Selkeä liiketoimintastrategia rajapintoja varten",
   "resource.api-business-model-canvas.steps": "Tiivistä APIn arvolupauksen tiivistelmä",
-  "resource.api-business-model-canvas.tips": "Aloita yhdestä sovellusrajapinnasta selkeyden varmistamiseksi",
-  "resource.api-design-principles.title": "APIn suunnitteluperiaatteet",
-  "resource.api-design-principles.description": "Tiivis opas APIn käytettävyyteen, löydettävyyteen ja johdonmukaisuuteen, joka perustuu yhteisiin suunnittelusääntöihin ja todellisiin kuluttajien tarpeisiin.",
-  "resource.api-design-principles.outcomes": "API-suunnittelun periaatteiden parempi ymmärtäminen",
-  "resource.api-design-principles.steps": "**Kuluttaja ensin -suunnittelu:** Aloita jokainen APIOps-sykli keräämällä käyttäjien tavoitteet ja toimialan ehdot, jotta APIt ratkaisevat todellisia ongelmia.",
-  "resource.api-design-principles.tips": "Mukauta API-suunnitteluperiaatteet omaan toimialueeseesi sopiviksi",
-  "resource.api-value-proposition-canvas.title": "API Value Proposition Canvas",
+  "resource.api-business-model-canvas.tips": "Aloita yhdestä rajapinnasta selkeyden varmistamiseksi",
+  "resource.api-design-principles.title": "API-suunnitteluperiaatteet",
+  "resource.api-design-principles.description": "Tiivis opas APIn käytettävyyteen, löydettävyyteen ja johdonmukaisuuteen, joka perustuu yhteisiin suunnittelusääntöihin ja todellisiin hyödyntäjien tarpeisiin.",
+  "resource.api-design-principles.outcomes": "Yhteinen ymmärrys resurssin APIn suunnitteluperiaatteet tarkoituksesta ja käytöstä",
+  "resource.api-design-principles.steps": "**Hyödyntäjä ensin -suunnittelu:** Aloita jokainen APIOps-sykli keräämällä käyttäjien tavoitteet ja toimialan ehdot, jotta APIt ratkaisevat todellisia ongelmia.",
+  "resource.api-design-principles.tips": "Mukauta resurssi omaan toimintaympäristöösi.",
+  "resource.api-value-proposition-canvas.title": "API-arvolupauskanvas",
   "resource.api-value-proposition-canvas.description": "Kohdista API-ominaisuudet käyttäjien tarpeisiin kartoittamalla tehtävät, ongelmat ja hyödyt API-tuotteisiin.",
   "resource.api-value-proposition-canvas.outcomes": "Keskitetty ominaisuuksien kehittäminen",
-  "resource.api-value-proposition-canvas.steps": "Luettelo käyttäjän matkan tehtävistä",
-  "resource.api-value-proposition-canvas.tips": "Hyödynnä Customer Journey Canvasin tietoja",
-  "resource.business-impact-canvas.title": "Business Impact Canvas",
-  "resource.business-impact-canvas.description": "Suunnittele skaalautuva ja turvallinen API-alusta-arkkitehtuuri, joka täyttää liiketoiminnan ja tekniset vaatimukset.",
-  "resource.business-impact-canvas.outcomes": "Skaalautuva API-infrastruktuuri",
+  "resource.api-value-proposition-canvas.steps": "Listaa käyttäjäpolun tehtävät.",
+  "resource.api-value-proposition-canvas.tips": "Hyödynnä Asiakaspolkukanvasin tietoja",
+  "resource.business-impact-canvas.title": "Liiketoimintavaikutuskanvas",
+  "resource.business-impact-canvas.description": "Tunnista liiketoimintaan, saatavuuteen, tietoturvaan, dataan, vaatimustenmukaisuuteen ja operointiin liittyvät riskit, joiden tulee ohjata arkkitehtuuri- ja alustapäätöksiä.",
+  "resource.business-impact-canvas.outcomes": "Dokumentoitu arvio liiketoiminta- ja operatiivisista vaikutuksista",
   "resource.business-impact-canvas.steps": "Saatavuusriskit: Tunnista riskit ja vaikutukset.",
-  "resource.business-impact-canvas.tips": "Otetaan arkkitehdit ja rakennuttajat mukaan suunnitteluprosessiin.",
-  "resource.capacity-canvas.title": "Capacity Canvas",
-  "resource.capacity-canvas.description": "Suunnittele API-kapasiteetti vastaamaan nykyisiä ja tulevia liiketoiminnan vaatimuksia ja varmista skaalautuvuus ja suorituskyky.",
-  "resource.capacity-canvas.outcomes": "API-kapasiteetin mukauttaminen liiketoiminnan volyymiin",
+  "resource.business-impact-canvas.tips": "Täytä tämä ennen toteutustavan valintaa tai vahvistamista.",
+  "resource.capacity-canvas.title": "Kapasiteettikanvas",
+  "resource.capacity-canvas.description": "Suunnittele kapasiteetti nykyistä ja tulevaa kysyntää varten. Huomioi volyymit, kuormitushuiput, viive, saatavuus, skaalaus, välimuistit ja kutsurajoitukset valitulle kyvykkyydelle ja toteutustavalle.",
+  "resource.capacity-canvas.outcomes": "Liiketoiminnan odotettuun kysyntään sovitetut kapasiteettivaatimukset",
   "resource.capacity-canvas.steps": "Dokumentoi nykyiset liiketoiminnan volyymit",
-  "resource.capacity-canvas.tips": "Käytä analytiikkaa kasvusuuntausten ennustamiseen",
-  "resource.customer-journey-canvas.title": "Customer Journey Canvas",
-  "resource.customer-journey-canvas.description": "Kartoita asiakkaan matkat tarpeiden ja kipupisteiden tunnistamiseksi, jotta API-suunnittelua ja käyttäjäkokemusta voidaan parantaa.",
-  "resource.customer-journey-canvas.outcomes": "Parempi asiakasymmärrys",
+  "resource.capacity-canvas.tips": "Täytä tämä ennen arkkitehtuuri- ja alustapäätösten viimeistelyä.",
+  "resource.customer-journey-canvas.title": "Asiakaspolkukanvas",
+  "resource.customer-journey-canvas.description": "Kartoittaa asiakkaan tai käyttäjän polun tarpeiden ja kipupisteiden tunnistamiseksi, jotta kyvykkyyden ja rajapinnan suunnittelu perustuu todelliseen kontekstiin.",
+  "resource.customer-journey-canvas.outcomes": "Yhteinen ymmärrys asiakkaan, kumppanin tai hyödyntäjän polusta",
   "resource.customer-journey-canvas.steps": "Määrittele asiakaspersoona",
-  "resource.customer-journey-canvas.tips": "Toista vaiheet tiimin panoksen avulla vaiheiden tarkentamiseksi.",
-  "resource.event-canvas.title": "Event Canvas",
-  "resource.event-canvas.description": "Suunnittele tapahtumapohjaisia sovellusliittymiä määrittelemällä tapahtumia, laukaisimia ja käsittelylogiikkaa.",
-  "resource.event-canvas.outcomes": "Määritelty tapahtumapohjainen arkkitehtuuri",
+  "resource.customer-journey-canvas.tips": "Validoi polku niiden ihmisten kanssa, jotka toteuttavat sen tai kokevat sen.",
+  "resource.event-canvas.title": "Tapahtumakanvas",
+  "resource.event-canvas.description": "Suunnittele tapahtumapohjaiset rajapinnat ja integraatiot määrittelemällä tapahtumat, laukaisimet, skeemat, tuottajat, hyödyntäjät ja käsittelylogiikka.",
+  "resource.event-canvas.outcomes": "Määritelty tapahtumapohjainen vuorovaikutusmalli",
   "resource.event-canvas.steps": "Järjestelmän keskeisten tapahtumien tunnistaminen",
   "resource.event-canvas.tips": "Tapahtumaskeemojen käyttäminen tapahtumamuotojen standardoimiseksi",
-  "resource.graphql-canvas.title": "GraphQL Canvas",
+  "resource.graphql-canvas.title": "GraphQL-kanvas",
   "resource.graphql-canvas.description": "Suunnittele GraphQL APIt määrittelemällä tyypit, kyselyt, mutaatiot ja tilaukset.",
   "resource.graphql-canvas.outcomes": "Strukturoidun GraphQL APIn suunnittelu",
-  "resource.graphql-canvas.steps": "Mitä ongelmia API-käyttäjät yrittävät ratkaista? Mitä tietoja he tarvitsevat?",
+  "resource.graphql-canvas.steps": "Mitä ongelmia API-hyödyntäjät yrittävät ratkaista? Mitä tietoja he tarvitsevat?",
   "resource.graphql-canvas.tips": "Käytä introspektiota tyyppimääritysten validointiin",
-  "resource.interaction-canvas.title": "Interaction Canvas",
+  "resource.interaction-canvas.title": "Vuorovaikutuskanvas",
   "resource.interaction-canvas.description": "Määrittele API-vuorovaikutukset, työnkulut ja odotetut vastaukset, jotta varmistetaan yhdenmukainen API-kokemus.",
-  "resource.interaction-canvas.outcomes": "Selkeät API-vuorovaikutuksen työnkulut",
-  "resource.interaction-canvas.steps": "API-vuorovaikutusten kartoittaminen käyttäjän tehtäviin",
+  "resource.interaction-canvas.outcomes": "Valitun kyvykkyyden määritelty vuorovaikutusmalli",
+  "resource.interaction-canvas.steps": "Kartoita rajapinnan vuorovaikutukset käyttäjän tehtäviin.",
   "resource.interaction-canvas.tips": "Aloita yleisistä käyttötapauksista ennen ääritapausten käsittelyä",
-  "resource.location-canvas.title": "Location Canvas",
-  "resource.location-canvas.description": "Kartoita API-palveluntarjoajien ja -kuluttajien sijainnit vaatimustenmukaisuuden ja suorituskyvyn varmistamiseksi eri alueilla.",
-  "resource.location-canvas.outcomes": "Paikallisten säännösten noudattaminen",
+  "resource.location-canvas.title": "Sijaintikanvas",
+  "resource.location-canvas.description": "Kartoita API-palveluntarjoajien ja -hyödyntäjien sijainnit vaatimustenmukaisuuden ja suorituskyvyn varmistamiseksi eri alueilla.",
+  "resource.location-canvas.outcomes": "Dokumentoidut sijainti-, tiedon sijainti-, verkko- ja sääntelyvaatimukset",
   "resource.location-canvas.steps": "API-palveluntarjoajien sijainnit kartalla.",
   "resource.location-canvas.tips": "Yhteistyö oikeudellisten ja sääntöjen noudattamista käsittelevien tiimien kanssa",
-  "resource.rest-canvas.title": "REST Canvas",
-  "resource.rest-canvas.description": "Suunnittele sovellusrajapinnat RESTful-periaatteiden mukaisesti määrittelemällä resurssit, verbit sekä esimerkkipyynnöt ja -vastaukset.",
-  "resource.rest-canvas.outcomes": "Johdonmukainen RESTful API-suunnittelu",
+  "resource.rest-canvas.title": "REST-kanvas",
+  "resource.rest-canvas.description": "Suunnittele rajapinnat RESTful-periaatteiden mukaisesti määrittelemällä resurssit, verbit sekä esimerkkipyynnöt ja -vastaukset.",
+  "resource.rest-canvas.outcomes": "Johdonmukainen RESTful API-design",
   "resource.rest-canvas.steps": "Tunnista APIn tarjoamat keskeiset resurssit",
   "resource.rest-canvas.tips": "Käytä tavallisia HTTP-menetelmiä (GET, POST, PUT, DELETE).",
-  "resource.api-community-engagement-strategies.outcomes.1": "Standardoitu lähestymistapa, jossa käytetään API-yhteisön sitouttamisstrategioita",
-  "resource.api-community-engagement-strategies.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
-  "resource.api-community-engagement-strategies.steps.1": "Luo myynninedistämismateriaalia (esim. tapaustutkimuksia, menestystarinoita), jossa korostetaan sovellusrajapintojen arvoa ja hyötyjä.",
+  "resource.api-community-engagement-strategies.outcomes.1": "Johdonmukainen tapa soveltaa resurssia API-yhteisön sitouttamisstrategiat",
+  "resource.api-community-engagement-strategies.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
+  "resource.api-community-engagement-strategies.steps.1": "Luo myynninedistämismateriaalia (esim. tapaustutkimuksia, menestystarinoita), jossa korostetaan rajapintojen arvoa ja hyötyjä.",
   "resource.api-community-engagement-strategies.steps.2": "Luo opetusmateriaalia (esim. opetusohjelmia, dokumentaatiota), jossa selitetään APIn ominaisuuksia, hyötyjä ja käyttötapoja.",
   "resource.api-community-engagement-strategies.steps.3": "Kytkeydy API-käyttäjiin palautekierrosten, tukikanavien ja yhteisöfoorumien kautta ymmärtämään heidän tarpeitaan ja parantamaan APIn käyttöönottoa.",
   "resource.api-community-engagement-strategies.steps.4": "Analysoi APIn käyttömittareita ja ota käyttäjien palaute huomioon API-iteraatioissa.",
-  "resource.api-community-engagement-strategies.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.api-compliance-best-practices.outcomes.1": "Standardoitu lähestymistapa API Compliance Best Practices -käytäntöjen avulla",
-  "resource.api-compliance-best-practices.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
-  "resource.api-compliance-best-practices.steps.1": "Toteuta toimenpiteitä, joilla varmistetaan, että sovellusrajapinnat täyttävät nämä vaatimukset, mukaan lukien tietojen salaus, käyttöoikeuksien valvonta ja kirjausketjut.",
+  "resource.api-community-engagement-strategies.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.api-compliance-best-practices.outcomes.1": "Johdonmukainen tapa soveltaa resurssia API-vaatimustenmukaisuuden parhaat käytännöt",
+  "resource.api-compliance-best-practices.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
+  "resource.api-compliance-best-practices.steps.1": "Toteuta toimenpiteitä, joilla varmistetaan, että rajapinnat täyttävät nämä vaatimukset, mukaan lukien tietojen salaus, käyttöoikeuksien valvonta ja kirjausketjut.",
   "resource.api-compliance-best-practices.steps.2": "Käytä tarkistuslistoja, linereita ja testausvälineitä varmistaaksesi johdonmukaisuuden ja standardien noudattamisen.",
-  "resource.api-compliance-best-practices.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.api-development-best-practices.outcomes.1": "Standardoitu lähestymistapa API-kehityksen parhaiden käytäntöjen avulla",
-  "resource.api-development-best-practices.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
+  "resource.api-compliance-best-practices.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.api-development-best-practices.outcomes.1": "Johdonmukainen tapa soveltaa resurssia API-kehityksen parhaat käytännöt",
+  "resource.api-development-best-practices.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
   "resource.api-development-best-practices.steps.1": "Käytä vakiintuneita ohjelmistokehyksiä, kirjastoja ja koodausstandardeja sopimuksen johdonmukaiseen ja ylläpidettävään toteutukseen.",
-  "resource.api-development-best-practices.tips.1": "Käytä tätä resurssia toteutuksen ohjeistuksena ja tarkastelun näkökulmana pikemminkin kuin pakollisena erillisenä artefaktina",
-  "resource.api-metrics-and-analytics.outcomes.1": "Standardoitu lähestymistapa API Metrics And Analyticsin avulla",
-  "resource.api-metrics-and-analytics.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
+  "resource.api-development-best-practices.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.api-metrics-and-analytics.outcomes.1": "Johdonmukainen tapa soveltaa resurssia API-mittarit ja analytiikka",
+  "resource.api-metrics-and-analytics.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
   "resource.api-metrics-and-analytics.steps.1": "Määrittele ja seuraa suorituskykymittareita (esim. API-kutsut, viiveet, virhetasot) ja hyväksyntämittareita (esim. NPS).",
-  "resource.api-metrics-and-analytics.steps.2": "Seuraa API-aloitteita varmistaaksesi toimintaohjeiden ja hallintokäytäntöjen noudattamisen.",
-  "resource.api-metrics-and-analytics.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.api-onboarding-best-practices.outcomes.1": "Standardoitu lähestymistapa API Onboarding Best Practices -käytäntöjen avulla",
-  "resource.api-onboarding-best-practices.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
-  "resource.api-onboarding-best-practices.steps.1": "Kehitetään käyttöönottoprosesseja ja resursseja, joiden avulla API-käyttäjät ymmärtävät, miten APIita käytetään tehokkaasti.",
-  "resource.api-onboarding-best-practices.steps.2": "Dokumentoi, miten kuluttajat löytävät ja käyttävät sovellusliittymää, mukaan lukien sisäänkirjautumisprosessit ja rekisteröinti.",
-  "resource.api-onboarding-best-practices.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.api-portfolio-management-guidelines.outcomes.1": "Standardoitu lähestymistapa API-salkunhallintaohjeiden avulla",
-  "resource.api-portfolio-management-guidelines.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
+  "resource.api-metrics-and-analytics.steps.2": "Seuraa API-aloitteita varmistaaksesi toimintaohjeiden ja governance-käytäntöjen noudattamisen.",
+  "resource.api-metrics-and-analytics.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.api-onboarding-best-practices.outcomes.1": "Johdonmukainen tapa soveltaa resurssia API-käyttöönoton parhaat käytännöt",
+  "resource.api-onboarding-best-practices.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
+  "resource.api-onboarding-best-practices.steps.1": "Kehitä käyttöönottoprosesseja ja resursseja, joiden avulla API-hyödyntäjät ymmärtävät, miten API-rajapintoja käytetään tehokkaasti.",
+  "resource.api-onboarding-best-practices.steps.2": "Dokumentoi, miten hyödyntäjät löytävät ja käyttävät rajapintaä, mukaan lukien käyttöönottoprosessit ja rekisteröinti.",
+  "resource.api-onboarding-best-practices.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.api-portfolio-management-guidelines.outcomes.1": "Johdonmukainen tapa soveltaa resurssia API-portfolion hallinnan suuntaviivat",
+  "resource.api-portfolio-management-guidelines.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
   "resource.api-portfolio-management-guidelines.steps.1": "Määrittele budjetti- ja resurssienhallintakäytännöt, joissa hahmotellaan API-aloitteiden budjettien ja resurssien hallinnointiprosessit.",
   "resource.api-portfolio-management-guidelines.steps.2": "Laaditaan kriteerit budjettimäärärahojen arvioimiseksi ja priorisoimiseksi liiketoiminta-arvon, vaikutusten ja strategisten aloitteiden mukaisuuden perusteella.",
   "resource.api-portfolio-management-guidelines.steps.3": "Seuraa API-portfoliota varmistaaksesi, että APIt tuottavat arvoa, täyttävät suorituskykyodotukset ja ovat linjassa liiketoiminnan tavoitteiden kanssa.",
-  "resource.api-portfolio-management-guidelines.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.api-security-best-practices.outcomes.1": "Standardoitu lähestymistapa API-turvallisuuden parhaiden käytäntöjen avulla",
-  "resource.api-security-best-practices.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
-  "resource.api-security-best-practices.steps.1": "Toteuta turvatoimia, kuten todennus, valtuutus, salaus ja nopeuden rajoittaminen, suojaamaan sovellusrajapintoja uhkilta.",
-  "resource.api-security-best-practices.steps.2": "Toteuta automaattiset tietoturvatarkastukset ja vaatimustenmukaisuuden validoinnit CI/CD-putkessa varmistaaksesi, että sovellusrajapinnat ovat turvallisia ja vaatimustenmukaisia.",
-  "resource.api-security-best-practices.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.api-team-structure-guidelines.outcomes.1": "Standardoitu lähestymistapa API-tiimirakenneohjeiden avulla",
-  "resource.api-team-structure-guidelines.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
-  "resource.api-team-structure-guidelines.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.api-testing-best-practices.outcomes.1": "Standardoitu lähestymistapa API-testauksen parhaiden käytäntöjen avulla",
-  "resource.api-testing-best-practices.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
-  "resource.api-testing-best-practices.steps.1": "Integroi toiminnallinen ja ei-toiminnallinen testaus CI/CD-putkeen varmistaaksesi, että sovellusrajapinnat täyttävät laatuvaatimukset.",
+  "resource.api-portfolio-management-guidelines.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.api-security-best-practices.outcomes.1": "Johdonmukainen tapa soveltaa resurssia API-turvallisuuden parhaat käytännöt",
+  "resource.api-security-best-practices.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
+  "resource.api-security-best-practices.steps.1": "Toteuta turvatoimia, kuten todennus, valtuutus, salaus ja nopeuden rajoittaminen, suojaamaan rajapintoja uhkilta.",
+  "resource.api-security-best-practices.steps.2": "Toteuta automaattiset tietoturvatarkastukset ja vaatimustenmukaisuuden validoinnit CI/CD-putkessa varmistaaksesi, että rajapinnat ovat turvallisia ja vaatimustenmukaisia.",
+  "resource.api-security-best-practices.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.api-team-structure-guidelines.outcomes.1": "Johdonmukainen tapa soveltaa resurssia API-tiimin rakennetta koskevat ohjeet",
+  "resource.api-team-structure-guidelines.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
+  "resource.api-team-structure-guidelines.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.api-testing-best-practices.outcomes.1": "Johdonmukainen tapa soveltaa resurssia API-testauksen parhaat käytännöt",
+  "resource.api-testing-best-practices.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
+  "resource.api-testing-best-practices.steps.1": "Integroi toiminnallinen ja ei-toiminnallinen testaus CI/CD-putkeen varmistaaksesi, että rajapinnat täyttävät laatuvaatimukset.",
   "resource.api-testing-best-practices.steps.2": "Käytä automatisoituja testausvälineitä API-toiminnallisuuden, tietoturvan ja suorituskyvyn validointiin.",
-  "resource.api-testing-best-practices.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.api-training-programs.outcomes.1": "Standardoitu lähestymistapa API-koulutusohjelmien avulla",
-  "resource.api-training-programs.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
+  "resource.api-testing-best-practices.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.api-training-programs.outcomes.1": "Johdonmukainen tapa soveltaa resurssia API-koulutusohjelmat",
+  "resource.api-training-programs.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
   "resource.api-training-programs.steps.1": "Kannustetaan jatkuvaan oppimiseen verkkokurssien, sertifikaattien ja yhteisöllisen sitoutumisen avulla.",
   "resource.api-training-programs.steps.2": "Tarjota koulutusta ja resursseja, jotta tiimit voivat omaksua API-first-ajattelutavan ja ymmärtää APIen edut.",
   "resource.api-training-programs.steps.3": "Tarjota koulutusohjelmia, työpajoja ja resursseja, joiden avulla tiimit voivat parantaa API-taitojaan ja -tietämystään.",
-  "resource.api-training-programs.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.api-versioning-best-practices.outcomes.1": "Standardoitu lähestymistapa API-versionoinnin parhaiden käytäntöjen avulla",
-  "resource.api-versioning-best-practices.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
-  "resource.api-versioning-best-practices.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.apiops-CI-CD-for-apis.outcomes.1": "CI/CD:tä käyttävä standardoitu lähestymistapa API-rajapintoihin",
-  "resource.apiops-CI-CD-for-apis.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
+  "resource.api-training-programs.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.api-versioning-best-practices.outcomes.1": "Johdonmukainen tapa soveltaa resurssia API-versionoinnin parhaat käytännöt",
+  "resource.api-versioning-best-practices.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
+  "resource.api-versioning-best-practices.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.apiops-CI-CD-for-apis.outcomes.1": "Johdonmukainen tapa soveltaa resurssia APIOps CI/CD rajapinnoille",
+  "resource.apiops-CI-CD-for-apis.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
   "resource.apiops-CI-CD-for-apis.steps.1": "Integroi automatisoidut testit CI/CD-putkeen API-laadun jatkuvan validoinnin varmistamiseksi.",
   "resource.apiops-CI-CD-for-apis.steps.2": "Ota käyttöön käyttöönottostrategioita (esim. sinivihreät käyttöönotot, kanarian julkaisut) API-julkaisuihin liittyvien riskien minimoimiseksi.",
   "resource.apiops-CI-CD-for-apis.steps.3": "Ota tavaksi tarkastella mittareita ja suunnitella jatkuvan parantamisen toimia.",
-  "resource.apiops-CI-CD-for-apis.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.competitor-analysis-template.outcomes.1": "Vakioitu lähestymistapa käyttäen kilpailija-analyysimallia",
-  "resource.competitor-analysis-template.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
-  "resource.competitor-analysis-template.steps.1": "Analysoi kilpailijoiden sovellusrajapinnat ymmärtämään niiden vahvuudet, heikkoudet ja ainutlaatuiset myyntivaltit.",
-  "resource.competitor-analysis-template.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.contract-first-design.outcomes.1": "Vakioitu lähestymistapa, jossa käytetään sopimusperusteista suunnittelua (Contract First Design)",
-  "resource.contract-first-design.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
+  "resource.apiops-CI-CD-for-apis.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.competitor-analysis-template.outcomes.1": "Johdonmukainen tapa soveltaa resurssia Kilpailija-analyysimalli",
+  "resource.competitor-analysis-template.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
+  "resource.competitor-analysis-template.steps.1": "Analysoi kilpailijoiden rajapinnat ymmärtämään niiden vahvuudet, heikkoudet ja ainutlaatuiset myyntivaltit.",
+  "resource.competitor-analysis-template.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.contract-first-design.outcomes.1": "Johdonmukainen tapa soveltaa resurssia Sopimuslähtöinen suunnittelu",
+  "resource.contract-first-design.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
   "resource.contract-first-design.steps.1": "Määrittele API-sopimukset, joissa hahmotellaan kunkin APIn odotukset, vastuut ja käyttöohjeet.",
   "resource.contract-first-design.steps.2": "Käytä standardoituja formaatteja (esim. OpenAPI, AsyncAPI) luodaksesi koneellisesti luettavia API-sopimuksia, joita on helppo jakaa ja validoida.",
-  "resource.contract-first-design.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.cross-functional-collaboration-best-practices.outcomes.1": "Standardoitu lähestymistapa, jossa käytetään monitoimialaisen yhteistyön parhaita käytäntöjä.",
-  "resource.cross-functional-collaboration-best-practices.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
-  "resource.cross-functional-collaboration-best-practices.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.data-privacy-guidelines.outcomes.1": "Standardoitu lähestymistapa tietosuojaa koskevien suuntaviivojen avulla",
-  "resource.data-privacy-guidelines.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
-  "resource.data-privacy-guidelines.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.domain-canvas.outcomes.1": "Vakioitu lähestymistapa Domain Canvasin avulla",
+  "resource.contract-first-design.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.cross-functional-collaboration-best-practices.outcomes.1": "Johdonmukainen tapa soveltaa resurssia Toimialarajat ylittävän yhteistyön parhaat käytännöt",
+  "resource.cross-functional-collaboration-best-practices.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
+  "resource.cross-functional-collaboration-best-practices.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.data-privacy-guidelines.outcomes.1": "Johdonmukainen tapa soveltaa resurssia Tietosuojaa koskevat ohjeet",
+  "resource.data-privacy-guidelines.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
+  "resource.data-privacy-guidelines.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.domain-canvas.outcomes.1": "Vakioitu lähestymistapa Toimialuekanvasin avulla",
   "resource.domain-canvas.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
   "resource.domain-canvas.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.ecosystem-vision-template.outcomes.1": "Yhdenmukaistettu lähestymistapa ekosysteemivision mallin avulla",
-  "resource.ecosystem-vision-template.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
+  "resource.ecosystem-vision-template.outcomes.1": "Johdonmukainen tapa soveltaa resurssia Ekosysteemivisiomalli",
+  "resource.ecosystem-vision-template.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
   "resource.ecosystem-vision-template.steps.1": "Tunnistetaan tärkeimmät ekosysteemikumppanit ja sidosryhmät, jotka hyötyvät ekosysteemistä tai osallistuvat siihen.",
-  "resource.ecosystem-vision-template.steps.2": "Tunnista markkinapuutteet, jotka sovellusrajapintasi voivat täyttää kilpailijoiden tarjonnan perusteella.",
+  "resource.ecosystem-vision-template.steps.2": "Tunnista markkinapuutteet, jotka rajapintasi voivat täyttää kilpailijoiden tarjonnan perusteella.",
   "resource.ecosystem-vision-template.steps.3": "Tunnista mahdolliset kumppanit, joiden APIt voivat parantaa API-valmiuksiasi ja arvolupaustasi.",
   "resource.ecosystem-vision-template.steps.4": "Kehitä erottautumisstrategia, jossa korostetaan sovellusrajapintojesi ainutlaatuisia ominaisuuksia ja etuja.",
   "resource.ecosystem-vision-template.steps.5": "Määrittele sovellusrajapintojesi ekosysteemivisio, mukaan lukien se, miten ne ovat vuorovaikutuksessa muiden järjestelmien ja alustojen kanssa.",
-  "resource.ecosystem-vision-template.steps.6": "Suunnittele sovellusrajapinnat, jotka mahdollistavat saumattoman integroinnin ja yhteistyön ekosysteemissä.",
-  "resource.ecosystem-vision-template.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.industry-standards-and-best-practices.outcomes.1": "Standardoitu lähestymistapa, jossa käytetään alan standardeja ja parhaita käytäntöjä.",
-  "resource.industry-standards-and-best-practices.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
-  "resource.industry-standards-and-best-practices.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.partner-integration-guidelines.outcomes.1": "Standardoitu lähestymistapa kumppanien integrointiohjeiden avulla",
-  "resource.partner-integration-guidelines.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
+  "resource.ecosystem-vision-template.steps.6": "Suunnittele rajapinnat, jotka mahdollistavat saumattoman integroinnin ja yhteistyön ekosysteemissä.",
+  "resource.ecosystem-vision-template.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.industry-standards-and-best-practices.outcomes.1": "Johdonmukainen tapa soveltaa resurssia Alan standardit ja parhaat käytännöt",
+  "resource.industry-standards-and-best-practices.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
+  "resource.industry-standards-and-best-practices.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.partner-integration-guidelines.outcomes.1": "Johdonmukainen tapa soveltaa resurssia Kumppanien integrointiohjeet",
+  "resource.partner-integration-guidelines.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
   "resource.partner-integration-guidelines.steps.1": "Seuraa kumppaneiden API-suorituskykyä ja vaatimustenmukaisuutta varmistaaksesi luotettavuuden ja yhteensopivuuden API-strategiasi kanssa.",
-  "resource.partner-integration-guidelines.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.role-communication-best-practices.outcomes.1": "Standardoitu lähestymistapa, jossa käytetään rooliviestinnän parhaita käytäntöjä",
-  "resource.role-communication-best-practices.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
+  "resource.partner-integration-guidelines.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.role-communication-best-practices.outcomes.1": "Johdonmukainen tapa soveltaa resurssia Rooliviestinnän parhaat käytännöt",
+  "resource.role-communication-best-practices.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
   "resource.role-communication-best-practices.steps.1": "Varmistaa, että roolit ja vastuut on ilmoitettu kaikille tiimin jäsenille ja sidosryhmille, jotta varmistetaan yhdenmukaisuus.",
-  "resource.role-communication-best-practices.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.scalable-infrastructure-best-practices.outcomes.1": "Standardoitu lähestymistapa, jossa käytetään skaalautuvan infrastruktuurin parhaita käytäntöjä.",
-  "resource.scalable-infrastructure-best-practices.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
+  "resource.role-communication-best-practices.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.scalable-infrastructure-best-practices.outcomes.1": "Johdonmukainen tapa soveltaa resurssia Skaalautuvan infrastruktuurin parhaat käytännöt",
+  "resource.scalable-infrastructure-best-practices.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
   "resource.scalable-infrastructure-best-practices.steps.1": "Seuraa infrastruktuurin suorituskykyä ja kapasiteettia sen varmistamiseksi, että se pystyy vastaamaan kasvavaan kysyntään.",
-  "resource.scalable-infrastructure-best-practices.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.service-agreement-template.outcomes.1": "Standardoitu lähestymistapa palvelusopimusmallin avulla",
-  "resource.service-agreement-template.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
+  "resource.scalable-infrastructure-best-practices.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.service-agreement-template.outcomes.1": "Johdonmukainen tapa soveltaa resurssia Palvelusopimusmalli",
+  "resource.service-agreement-template.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
   "resource.service-agreement-template.steps.1": "Luo koneellisesti luettavia palvelusopimuksia, joita on helppo jakaa ja validoida, käyttämällä standardoituja muotoja.",
   "resource.service-agreement-template.steps.2": "Varmista, että sidosryhmät tarkistavat ja hyväksyvät palvelusopimukset, jotta varmistetaan niiden yhdenmukaisuus ja selkeys.",
-  "resource.service-agreement-template.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.stakeholder-engagement-best-practices.outcomes.1": "Sidosryhmien sitouttamisen parhaita käytäntöjä hyödyntävä vakiomuotoinen lähestymistapa",
-  "resource.stakeholder-engagement-best-practices.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
-  "resource.stakeholder-engagement-best-practices.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.test-automation-frameworks.outcomes.1": "Standardoitu lähestymistapa testausautomaatiokehysten avulla",
-  "resource.test-automation-frameworks.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
-  "resource.test-automation-frameworks.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.vendor-management-best-practices.outcomes.1": "Myyjähallinnon parhaita käytäntöjä käyttävä standardoitu lähestymistapa",
-  "resource.vendor-management-best-practices.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
-  "resource.vendor-management-best-practices.steps.1": "Määrittele kriteerit toimittajien sovellusrajapintojen arviointia varten, mukaan lukien luotettavuus, turvallisuus ja vaatimustenmukaisuus.",
-  "resource.vendor-management-best-practices.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
-  "resource.api-audit-checklist.outcomes.1": "Standardoitu lähestymistapa API-auditoinnin tarkistuslistan avulla",
-  "resource.api-audit-checklist.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
+  "resource.service-agreement-template.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.stakeholder-engagement-best-practices.outcomes.1": "Johdonmukainen tapa soveltaa resurssia Sidosryhmien sitouttamisen parhaat käytännöt",
+  "resource.stakeholder-engagement-best-practices.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
+  "resource.stakeholder-engagement-best-practices.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.test-automation-frameworks.outcomes.1": "Johdonmukainen tapa soveltaa resurssia Testausautomaation kehykset",
+  "resource.test-automation-frameworks.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
+  "resource.test-automation-frameworks.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.vendor-management-best-practices.outcomes.1": "Johdonmukainen tapa soveltaa resurssia Toimittajien hallinnan parhaat käytännöt",
+  "resource.vendor-management-best-practices.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
+  "resource.vendor-management-best-practices.steps.1": "Määrittele kriteerit toimittajien rajapintojen arviointia varten, mukaan lukien luotettavuus, turvallisuus ja vaatimustenmukaisuus.",
+  "resource.vendor-management-best-practices.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
+  "resource.api-audit-checklist.outcomes.1": "Johdonmukainen tapa soveltaa resurssia API-auditoinnin tarkistuslista",
+  "resource.api-audit-checklist.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
   "resource.api-audit-checklist.steps.1": "Suorita auditointeja elinkaaren kattavuuden arvioimiseksi ja varmista, että API täyttää liiketoiminta-, suunnittelu- ja toimintastandardit.",
   "resource.api-audit-checklist.steps.2": "Varmista, että dokumentaatio, tietoturvamallit, gateway-konfiguraatio ja lakisääteiset vaatimukset on määritelty selkeästi, validoitu ja tuettu todisteilla.",
   "resource.api-audit-checklist.tips.1": "Käytä API-auditointilistaa yhteistyössä liiketoiminta- ja teknologia-roolien välillä",
   "resource.api-business-model-canvas.outcomes.1": "Keskeisten resurssien ja kumppaneiden tunnistaminen",
   "resource.api-business-model-canvas.outcomes.2": "API-ominaisuuksien ja liiketoiminnan tavoitteiden yhteensovittaminen",
-  "resource.api-business-model-canvas.steps.1": "Kuluttajasegmenttien määrittely",
+  "resource.api-business-model-canvas.steps.1": "Hyödyntäjäsegmenttien määrittely",
   "resource.api-business-model-canvas.steps.2": "Kehittäjäsuhdestrategioiden määrittäminen",
   "resource.api-business-model-canvas.steps.3": "Kartoita jakelukanavat",
-  "resource.api-business-model-canvas.steps.4": "dokumentoida keskeiset resurssit ja toimet",
+  "resource.api-business-model-canvas.steps.4": "Dokumentoi keskeiset resurssit ja toimet",
   "resource.api-business-model-canvas.steps.5": "Tunnistetaan tärkeimmät kumppanit ja sidosryhmät",
   "resource.api-business-model-canvas.steps.6": "Korosta hyötyjä ja kustannuksia",
   "resource.api-business-model-canvas.tips.1": "Mahdollisuuksien priorisointi kustannus-hyöty -suhteen kaltaisten mittareiden avulla.",
   "resource.api-business-model-canvas.tips.2": "Validoi tuotokset tärkeimpien sidosryhmien kanssa",
-  "resource.api-design-principles.outcomes.1": "Standardoitu lähestymistapa API-suunnitteluperiaatteiden avulla",
-  "resource.api-design-principles.outcomes.2": "Parannettu asiaan liittyvien API-käytäntöjen täytäntöönpano",
-  "resource.api-design-principles.steps.1": "**Johdonmukainen nimeäminen ja käyttäytyminen:** Sovelletaan yhteisiä käytäntöjä resursseja, virheitä ja formaatteja varten, jotta sovellusrajapinnat olisivat ennakoitavissa.",
+  "resource.api-design-principles.outcomes.1": "Johdonmukainen tapa soveltaa resurssia APIn suunnitteluperiaatteet",
+  "resource.api-design-principles.outcomes.2": "Asiaan liittyvien käytäntöjen parempi soveltaminen",
+  "resource.api-design-principles.steps.1": "**Johdonmukainen nimeäminen ja käyttäytyminen:** Sovelletaan yhteisiä käytäntöjä resursseja, virheitä ja formaatteja varten, jotta rajapinnat olisivat ennakoitavissa.",
   "resource.api-design-principles.steps.2": "**Sopimusperusteinen:** kaappaa rajapinta OpenAPIlla tai AsyncAPIlla ennen koodausta tiimien yhdenmukaistamiseksi ja automaation mahdollistamiseksi.",
   "resource.api-design-principles.steps.3": "**Käytettävyys ja löydettävyys:** Selkeä dokumentaatio ja esimerkit, jotta kehittäjät ymmärtävät nopeasti, miten APIta käytetään.",
-  "resource.api-design-principles.steps.4": "**Iteroi turvallisesti:** Kehitä malleja pienissä, versioiduissa vaiheissa, jotta muutokset eivät häiritse nykyisiä kuluttajia.",
-  "resource.api-design-principles.tips.1": "Käytä sitä yhteistyössä eri liiketoiminta- ja teknisten roolien välillä",
+  "resource.api-design-principles.steps.4": "**Iteroi turvallisesti:** Kehitä malleja pienissä, versioiduissa vaiheissa, jotta muutokset eivät häiritse nykyisiä API-hyödyntäjiä.",
+  "resource.api-design-principles.tips.1": "Käytä resurssia yhteistyössä olennaisten liiketoiminta- ja teknisten roolien kanssa.",
   "resource.api-value-proposition-canvas.outcomes.1": "Yhdenmukaisuus käyttäjien tarpeiden kanssa",
-  "resource.api-value-proposition-canvas.outcomes.2": "Parempi API-kuluttajien tyytyväisyys",
+  "resource.api-value-proposition-canvas.outcomes.2": "Parempi API-hyödyntäjien tyytyväisyys",
   "resource.api-value-proposition-canvas.steps.1": "Tunnistetaan ominaisuudet, jotka tuottavat odotettuja hyötyjä",
   "resource.api-value-proposition-canvas.steps.2": "Määritellään haasteisiin vastaavat ominaisuudet",
   "resource.api-value-proposition-canvas.steps.3": "Ominaisuuksien kartoittaminen API-tuotteisiin",
-  "resource.api-value-proposition-canvas.tips.1": "Korosta ominaisuuksia, jotka helpottavat kipuja tai parantavat voittoja.",
-  "resource.api-value-proposition-canvas.tips.2": "Validoi ominaisuudet API-käyttäjien kanssa yhdenmukaistamisen varmistamiseksi.",
-  "resource.business-impact-canvas.outcomes.1": "Parannettu turvallisuus ja vaatimustenmukaisuus",
-  "resource.business-impact-canvas.outcomes.2": "Parannettu API-suorituskyky",
+  "resource.api-value-proposition-canvas.tips.1": "Korosta ominaisuuksia, jotka vähentävät kipupisteitä tai vahvistavat tavoiteltuja hyötyjä.",
+  "resource.api-value-proposition-canvas.tips.2": "Validoi ominaisuudet API-hyödyntäjien kanssa yhdenmukaistamisen varmistamiseksi.",
+  "resource.business-impact-canvas.outcomes.1": "Priorisoidut riskit ja lieventämistoimenpiteet",
+  "resource.business-impact-canvas.outcomes.2": "Arkkitehtuuri- ja alustapäätöksiä tukeva näyttö",
   "resource.business-impact-canvas.steps.1": "Saatavuusriskien lieventämistavat: Määrittele lieventämistoimenpiteet.",
   "resource.business-impact-canvas.steps.2": "Turvallisuusriskit: Dokumentoi turvallisuuteen liittyvät riskit.",
   "resource.business-impact-canvas.steps.3": "Tapoja vähentää turvallisuusriskejä: Ehdota strategioita turvallisuusriskien lieventämiseksi.",
   "resource.business-impact-canvas.steps.4": "Tietoriskit: Tunnista tietojen tarkkuuteen tai saatavuuteen liittyvät riskit.",
   "resource.business-impact-canvas.steps.5": "Tietoriskien lieventämistavat: Suunnittele strategioita tietoriskien torjumiseksi.",
-  "resource.business-impact-canvas.tips.1": "Mahdollisten riskien tunnistaminen aiempien tapahtumien avulla",
-  "resource.business-impact-canvas.tips.2": "Priorisoi kriittiset APIt, joilla on suurin vaikutus liiketoimintaan.",
-  "resource.capacity-canvas.outcomes.1": "Valmistautunut tuleviin kulutussuuntauksiin",
-  "resource.capacity-canvas.outcomes.2": "Määritellyt välimuistitallennus- ja nopeudenrajoitusstrategiat",
+  "resource.business-impact-canvas.tips.1": "Käy riskit läpi sekä liiketoiminnan että teknisten sidosryhmien kanssa.",
+  "resource.business-impact-canvas.tips.2": "Haasta oletuksia aiempien häiriöiden ja operatiivisen näytön avulla.",
+  "resource.capacity-canvas.outcomes.1": "Dokumentoidut oletukset kuormitushuipuista, saatavuudesta ja kasvusta",
+  "resource.capacity-canvas.outcomes.2": "Määritellyt skaalaus-, välimuisti- ja kutsurajoitusratkaisut",
   "resource.capacity-canvas.steps.1": "Ennustaa tulevia kulutussuuntauksia",
   "resource.capacity-canvas.steps.2": "Suunnittele huippukuormitus ja saatavuusvaatimukset",
   "resource.capacity-canvas.steps.3": "Määrittele välimuistitallennus- ja nopeudenrajoitusstrategiat.",
   "resource.capacity-canvas.steps.4": "Ehdotetaan skaalausstrategioita",
-  "resource.capacity-canvas.tips.1": "Määrittele huippukäytön skenaariot",
-  "resource.capacity-canvas.tips.2": "Sisällytä skaalautuvuuden testaus suunnitteluvaiheeseen.",
-  "resource.customer-journey-canvas.outcomes.1": "Parannettu API-suunnittelu",
-  "resource.customer-journey-canvas.outcomes.2": "Parempi käyttäjäkokemus",
+  "resource.capacity-canvas.tips.1": "Käytä mitattua tietoa aina kun sitä on saatavilla ja kirjaa oletukset näkyviin.",
+  "resource.capacity-canvas.tips.2": "Päivitä kanvas pilotin tai kysynnän olennaisten muutosten jälkeen.",
+  "resource.customer-journey-canvas.outcomes.1": "Dokumentoidut tarpeet, kipupisteet, hyödyt, syötteet ja tuotokset",
+  "resource.customer-journey-canvas.outcomes.2": "Polkua koskeva näyttö kyvykkyys-, vaatimus- ja arkkitehtuuripäätösten tueksi",
   "resource.customer-journey-canvas.steps.1": "Tunnista matkan käynnistäjät",
   "resource.customer-journey-canvas.steps.2": "Kuvaile matkan loppua",
   "resource.customer-journey-canvas.steps.3": "Kartoita matkan vaiheet ja syötteet/lähtötiedot",
   "resource.customer-journey-canvas.steps.4": "Tunnista asiakkaan kipupisteet",
   "resource.customer-journey-canvas.steps.5": "Yhteenveto asiakkaan saamista eduista",
-  "resource.customer-journey-canvas.steps.6": "Määritellään tarvittavat panokset ja tuotokset",
+  "resource.customer-journey-canvas.steps.6": "Määritellään tarvittavat syötteet ja tuotokset",
   "resource.customer-journey-canvas.steps.7": "Määrittele API-vuorovaikutukset kullekin vaiheelle",
-  "resource.customer-journey-canvas.tips.1": "Käytä tämän kanvaasin tuotoksia muiden kanvaasien, kuten API Value Proposition Canvas -kanvaasin, laatimiseen.",
-  "resource.event-canvas.outcomes.1": "Selkeät tapahtumien laukaisijat ja käsittelylogiikka",
-  "resource.event-canvas.outcomes.2": "Parempi reagointikyky reaaliaikaisiin muutoksiin",
+  "resource.customer-journey-canvas.tips.1": "Hyödynnä tuloksia arvolupauksen, toimialueen, vaatimusten ja arkkitehtuurin työstämisessä.",
+  "resource.event-canvas.outcomes.1": "Selkeytetyt tapahtumat, laukaisimet, skeemat, tuottajat ja hyödyntäjät",
+  "resource.event-canvas.outcomes.2": "Dokumentoidut käsittely-, kuittaus- ja virhetilanneodotukset",
   "resource.event-canvas.steps.1": "Määritä laukaisimet kullekin tapahtumalle",
-  "resource.event-canvas.steps.2": "Tapahtumien backend-käsittelylogiikan kuvaaminen",
+  "resource.event-canvas.steps.2": "Kuvaa tapahtumien käsittely, tilamuutokset ja virhetilanteiden käsittely.",
   "resource.event-canvas.steps.3": "Määritä tuloksena olevat tuotokset tai kuittaukset",
-  "resource.event-canvas.tips.1": "dokumentoida tapahtumavirtoja ja riippuvuuksia",
+  "resource.event-canvas.tips.1": "Dokumentoi tapahtumavirrat, omistajuus, järjestysoletukset ja riippuvuudet.",
   "resource.event-canvas.tips.2": "Validoi tapahtumien käsittely testitapauksilla",
   "resource.graphql-canvas.outcomes.1": "Määritellyt tyypit ja niiden väliset suhteet",
   "resource.graphql-canvas.outcomes.2": "Selkeät kyselyt, mutaatiot ja tilaukset",
-  "resource.graphql-canvas.steps.1": "Määritä GraphQL-tyypit ja niiden attribuutit: Mitkä ovat keskeiset tyypit (esim. käyttäjä, tilaus, tuote)?",
+  "resource.graphql-canvas.steps.1": "Määritä GraphQL-tyypit ja niiden attribuutit: mitkä ovat keskeiset tyypit (esim. käyttäjä, tilaus, tuote)?",
   "resource.graphql-canvas.steps.2": "Kartoita tyyppien väliset suhteet: Miten tyypit liittyvät toisiinsa sisäkkäisissä kyselyissä?",
   "resource.graphql-canvas.steps.3": "Määritä kyselyt tiedonhakua varten",
   "resource.graphql-canvas.steps.4": "Määritä tietojen muuttamista koskevat mutaatiot: Millaisilla operaatioilla tietoja muutetaan (esim. luodaan, päivitetään, poistetaan)?",
   "resource.graphql-canvas.steps.5": "Reaaliaikaisten päivitysten tilaukset",
   "resource.graphql-canvas.steps.6": "Määrittele todennus ja valtuutus: Kuka voi käyttää mitä kenttiä tai tyyppejä?",
   "resource.graphql-canvas.steps.7": "Harkitse, onko olemassa sivutus-, suodatus- tai nopeusrajoituksia.",
-  "resource.graphql-canvas.tips.1": "asiakirjan esimerkkikyselyt ja mutaatiot",
+  "resource.graphql-canvas.tips.1": "Dokumentoi esimerkkikyselyt ja mutaatiot.",
   "resource.graphql-canvas.tips.2": "Varmista, että tyyppien nimet ovat kuvaavia ja johdonmukaisia.",
-  "resource.interaction-canvas.outcomes.1": "Määritellyt panokset ja tuotokset kutakin vuorovaikutusta varten.",
-  "resource.interaction-canvas.outcomes.2": "Yhdenmukaiset validointisäännöt vuorovaikutustilanteissa",
+  "resource.interaction-canvas.outcomes.1": "Selkeytetyt syötteet, tuotokset, komennot, kyselyt, tapahtumat ja vastaukset",
+  "resource.interaction-canvas.outcomes.2": "Sovitut validointisäännöt ja vuorovaikutusodotukset",
   "resource.interaction-canvas.steps.1": "Määritä päätepisteet kullekin vuorovaikutukselle",
-  "resource.interaction-canvas.steps.2": "dokumentoida kunkin vuorovaikutuksen panokset ja tuotokset",
+  "resource.interaction-canvas.steps.2": "Dokumentoi kunkin vuorovaikutuksen syötteet ja tuotokset.",
   "resource.interaction-canvas.steps.3": "Validointisääntöjen ja -rajoitusten määrittäminen",
   "resource.interaction-canvas.steps.4": "Luo vuorovaikutusmalleja CRUD-, kysely-, komento- ja tapahtumapohjaista vuorovaikutusta varten.",
   "resource.interaction-canvas.tips.1": "Simuloi vuorovaikutusta mallitietojen kanssa työnkulkujen validoimiseksi.",
-  "resource.interaction-canvas.tips.2": "dokumentoida odotetut reaktiot onnistuneisiin ja epäonnistuneisiin vuorovaikutustilanteisiin.",
-  "resource.location-canvas.outcomes.1": "Optimoitu API-suorituskyky eri alueilla",
-  "resource.location-canvas.outcomes.2": "Parempi ymmärrys alueellisista vaatimuksista",
-  "resource.location-canvas.steps.1": "Dokumentoi, missä kuluttajat sijaitsevat.",
+  "resource.interaction-canvas.tips.2": "Dokumentoi odotetut vastaukset onnistuneissa, epäonnistuneissa ja poikkeuksellisissa tilanteissa.",
+  "resource.location-canvas.outcomes.1": "Tunnistetut alueelliset suorituskyky- ja saavutettavuusrajoitteet",
+  "resource.location-canvas.outcomes.2": "Selkeytetyt tiedon sijaintivaatimukset, luottamusrajat ja sovellettava sääntely",
+  "resource.location-canvas.steps.1": "Dokumentoi, missä hyödyntäjät sijaitsevat.",
   "resource.location-canvas.steps.2": "Tunnista sovellettavat säädökset.",
   "resource.location-canvas.steps.3": "Dokumentoi, missä tietojen on oltava.",
-  "resource.location-canvas.steps.4": "Varmista, että sovellusrajapinnat ovat käytettävissä kaikilla aiotuilla verkkoalueilla.",
+  "resource.location-canvas.steps.4": "Varmista, että rajapinnat ovat käytettävissä kaikilla aiotuilla verkkoalueilla.",
   "resource.location-canvas.steps.5": "Validoi verkon suorituskyky eri alueilla.",
   "resource.location-canvas.tips.1": "Verkon suorituskyvyn validointi keskeisillä alueilla",
   "resource.location-canvas.tips.2": "Ratkaise ennakoivasti sijaintiin liittyviä rajoitteita",
@@ -403,5 +403,143 @@
   "resource.rest-canvas.steps.2": "Määritä HTTP-verbit, joita käytetään vuorovaikutuksessa resurssien kanssa.",
   "resource.rest-canvas.steps.3": "Anna esimerkkipyynnöt ja -vastaukset kullekin verbille",
   "resource.rest-canvas.tips.1": "Varmistetaan, että resurssien URI:t ovat intuitiivisia ja johdonmukaisia.",
-  "resource.rest-canvas.tips.2": "asiakirjan virheiden käsittely ja vastauskoodit"
+  "resource.rest-canvas.tips.2": "Dokumentoi virheiden käsittely ja vastauskoodit.",
+  "resource.capability-value-proposition-canvas.title": "Kyvykkyyden arvolupauskanvas",
+  "resource.capability-value-proposition-canvas.description": "Teknologiariippumaton kanvas hyödyntäjien tehtävien, hyötyjen, kipupisteiden ja mahdollisten uudelleenkäytettävien kyvykkyyksien kartoittamiseen ennen toteutustavan valintaa.",
+  "resource.capability-value-proposition-canvas.outcomes": "Selkeä arvolupaus uudelleenkäytettävälle kyvykkyydelle",
+  "resource.capability-value-proposition-canvas.outcomes.1": "Hyödyntäjien tehtävät, tavoitellut hyödyt ja kipupisteet on kuvattu ilman oletusta tietystä teknologiasta.",
+  "resource.capability-value-proposition-canvas.outcomes.2": "Mahdolliset uudelleenkäytettävät kyvykkyydet on tunnistettu arkkitehtuurin arviointia varten.",
+  "resource.capability-value-proposition-canvas.steps": "Listaa hyödyntäjien tehtävät ja lopputulokset, joita kyvykkyyden tulee tukea.",
+  "resource.capability-value-proposition-canvas.steps.1": "Tunnista kyvykkyyden ominaisuudet, jotka mahdollistavat tavoitellut hyödyt.",
+  "resource.capability-value-proposition-canvas.steps.2": "Tunnista kyvykkyyden ominaisuudet, jotka vähentävät kipupisteitä.",
+  "resource.capability-value-proposition-canvas.steps.3": "Ryhmittele ominaisuudet mahdollisiksi uudelleenkäytettäviksi kyvykkyyksiksi.",
+  "resource.capability-value-proposition-canvas.tips": "Pysy teknologiariippumattomana, kunnes vaatimukset osoittavat sopivan toteutustavan.",
+  "resource.capability-value-proposition-canvas.tips.1": "Käytä tätä API Value Proposition Canvasin sijaan, kun APIa ei ole vielä valittu toteutustavaksi.",
+  "resource.capability-business-model-canvas.title": "Kyvykkyyden liiketoimintamallikanvas",
+  "resource.capability-business-model-canvas.description": "Uudelleenkäytettävien kyvykkyyksien liiketoimintamallikanvas, joka käsittelee arvoa, hyödyntäjiä, omistajuutta, vuorovaikutusta, kustannuksia ja hyötyjä olettamatta toteutustapaa.",
+  "resource.capability-business-model-canvas.outcomes": "Toteuttamiskelpoinen toimintamalli uudelleenkäytettävälle kyvykkyydelle",
+  "resource.capability-business-model-canvas.outcomes.1": "Omistajuus, hyödyntäjät, kanavat, kumppanit ja tuen tarpeet on selkeytetty.",
+  "resource.capability-business-model-canvas.outcomes.2": "Kustannukset ja hyödyt ovat näkyvissä ennen arkkitehtuurisitoumusta.",
+  "resource.capability-business-model-canvas.steps": "Tiivistä kyvykkyyden arvolupaus.",
+  "resource.capability-business-model-canvas.steps.1": "Tunnista hyödyntäjäsegmentit ja osallistamiskanavat.",
+  "resource.capability-business-model-canvas.steps.2": "Määritä keskeiset toiminnot, resurssit ja kumppanit.",
+  "resource.capability-business-model-canvas.steps.3": "Kuvaa kustannukset ja hyödyt.",
+  "resource.capability-business-model-canvas.steps.4": "Selkeytä omistajuus, rahoitus, tuki ja elinkaaren odotukset.",
+  "resource.capability-business-model-canvas.steps.5": "Validoi malli hyödyntäjien, tuottajien ja governance-sidosryhmien kanssa.",
+  "resource.capability-business-model-canvas.tips": "Käytä tätä API Business Model Canvasin sijaan niin kauan kuin toteutustapa on avoin.",
+  "resource.capability-business-model-canvas.tips.1": "Pidä fokus uudelleenkäytettävän kyvykkyyden elinkelpoisuudessa, ei yksittäisessä yhteydessä.",
+  "resource.consumer-experience-requirements-canvas.title": "Hyödyntäjäkokemuksen vaatimuskanvas",
+  "resource.consumer-experience-requirements-canvas.description": "Vaatimuskanvas hyödyntäjäkokemukselle ja ei-toiminnallisille tarpeille, joiden tulee ohjata myöhempää arkkitehtuuri- ja toteutustapapäätöstä.",
+  "resource.consumer-experience-requirements-canvas.outcomes": "Teknologiariippumattomat hyödyntäjä- ja palveluvaatimukset",
+  "resource.consumer-experience-requirements-canvas.outcomes.1": "Kokemukseen ja ei-toiminnallisiin tarpeisiin liittyvät vaatimukset on kuvattu ennen suunnittelun aloittamista.",
+  "resource.consumer-experience-requirements-canvas.outcomes.2": "Dokumentoidut arkkitehtuurivaikutukset toteutustavan valintaa varten",
+  "resource.consumer-experience-requirements-canvas.steps": "Kuvaa hyödyntäjien tavoitteet ja käyttökonteksti.",
+  "resource.consumer-experience-requirements-canvas.steps.1": "Dokumentoi saatavuuteen, ajantasaisuuteen, volyymiin, suorituskykyyn, datan laatuun ja yhdenmukaisuuteen liittyvät odotukset.",
+  "resource.consumer-experience-requirements-canvas.steps.2": "Dokumentoi turvallisuuteen, tietosuojaan, käyttöönottoon, muutoksiin, havainnoitavuuteen, tukeen ja palautumiseen liittyvät odotukset.",
+  "resource.consumer-experience-requirements-canvas.steps.3": "Tiivistä, mitä vaatimukset merkitsevät mahdollisten toteutustapojen kannalta.",
+  "resource.consumer-experience-requirements-canvas.tips": "Käytä tätä siltana kyvykkyyden arvon ja arkkitehtuuripäätöksen välillä.",
+  "resource.consumer-experience-requirements-canvas.tips.1": "Älä valitse APIa, tapahtumaa, tiedostoa, tietovirtaa, datatuotetta, suoraa integraatiota tai hybriditapaa ennen kuin vaatimukset osoittavat sopivan vaihtoehdon.",
+  "resource.integration-style-selection-guide.title": "Integraatiotavan valintaopas",
+  "resource.integration-style-selection-guide.description": "Ohje API-, tapahtuma-, tiedosto-, tietovirta-, datatuote-, suora integraatio- tai hybriditoteutustavan valintaan vaatimusten ja rajoitteiden perusteella.",
+  "resource.integration-style-selection-guide.outcomes": "Perusteltu integraation toteutustapa",
+  "resource.integration-style-selection-guide.outcomes.1": "Integraatiotapojen keskeiset vaihtoehdot ja kompromissit on dokumentoitu.",
+  "resource.integration-style-selection-guide.outcomes.2": "Valittu tapa on jäljitettävissä hyödyntäjä-, alusta-, data- ja operatiivisiin vaatimuksiin.",
+  "resource.integration-style-selection-guide.steps": "Vertaa mahdollisia integraatiotapoja viiveen, volyymin, kytkeytymisen, datan omistajuuden, ajantasaisuuden, hallinnan ja operoitavuuden tarpeisiin.",
+  "resource.integration-style-selection-guide.steps.1": "Tunnista, milloin API, tapahtuma, tiedosto, tietovirta, datatuote, suora integraatio tai hybridiratkaisu sopii käyttötapaukseen.",
+  "resource.integration-style-selection-guide.steps.2": "Dokumentoi valitun toteutustavan rajoitteet, riskit ja alustariippuvuudet.",
+  "resource.integration-style-selection-guide.steps.3": "Kirjaa, miksi hylättyjä vaihtoehtoja ei valittu.",
+  "resource.integration-style-selection-guide.tips": "Käytä tätä sen jälkeen, kun vaatimukset ovat selkeät, mutta ennen yksityiskohtaista sopimussuunnittelua.",
+  "resource.integration-style-selection-guide.tips.1": "Pidä REST-, tapahtuma-, GraphQL-, tiedosto-, tietovirta- ja datatuoteresurssit valinnaisina jatkosuunnittelun resursseina.",
+  "resource.process-workflow-design-guide.title": "Prosessin ja työnkulun suunnitteluopas",
+  "resource.process-workflow-design-guide.description": "Ohje prosessivaiheiden, roolien, luovutusten, päätöspisteiden, tilojen, syötteiden, tuotosten ja poikkeusten mallintamiseen automaatiotyönkulun suunnittelua varten.",
+  "resource.process-workflow-design-guide.outcomes": "Selkeä automaatiotyönkulun suunnitelma",
+  "resource.process-workflow-design-guide.outcomes.1": "Prosessivaiheet ja luovutukset on dokumentoitu ennen toteutusta.",
+  "resource.process-workflow-design-guide.outcomes.2": "Työnkulun tilat, syötteet, tuotokset ja poikkeuspolut on ymmärretty.",
+  "resource.process-workflow-design-guide.steps": "Kuvaa nykyinen ja tavoiteltu prosessivirta, mukaan lukien ihmisten ja järjestelmien vastuut.",
+  "resource.process-workflow-design-guide.steps.1": "Tunnista työnkulun käynnistimet, tilat, päätökset, datasyötteet, tuotokset ja valmistumisen kriteerit.",
+  "resource.process-workflow-design-guide.steps.2": "Dokumentoi luovutukset käyttäjien, järjestelmien, operoinnin ja tukiroolien välillä.",
+  "resource.process-workflow-design-guide.steps.3": "Vahvista, mitkä vaiheet kannattaa automatisoida ja mitkä edellyttävät ihmisen harkintaa.",
+  "resource.process-workflow-design-guide.tips": "Pidä prosessisuunnittelu erillään API- tai integraatiosopimuksen suunnittelusta, kunnes työnkulku on selkeä.",
+  "resource.process-workflow-design-guide.tips.1": "Käytä tätä ensisijaisena suunnitteluresurssina automaatiotyönkuluille.",
+  "resource.decision-business-rules-guide.title": "Päätösten ja liiketoimintasääntöjen opas",
+  "resource.decision-business-rules-guide.description": "Ohje sääntöjen, kynnysarvojen, päätösten, hyväksyntöjen, kelpoisuustarkistusten ja sääntöjen omistajuuden kuvaamiseen automaation suunnittelua varten.",
+  "resource.decision-business-rules-guide.outcomes": "Selkeästi kuvatut päätökset ja liiketoimintasäännöt",
+  "resource.decision-business-rules-guide.outcomes.1": "Säännöt ja kynnysarvot on dokumentoitu omistajineen.",
+  "resource.decision-business-rules-guide.outcomes.2": "Automaation päätökset ovat jäljitettävissä käytäntöihin, prosessiin tai liiketoimintatarkoitukseen.",
+  "resource.decision-business-rules-guide.steps": "Listaa päätökset, jotka automaation täytyy tehdä tai joita sen täytyy tukea.",
+  "resource.decision-business-rules-guide.steps.1": "Dokumentoi sääntöjen ehdot, kynnysarvot, poikkeukset, hyväksynnät ja eskalointipisteet.",
+  "resource.decision-business-rules-guide.steps.2": "Tunnista sääntöjen omistajat ja muutosten hallintatapa jokaiselle päätösalueelle.",
+  "resource.decision-business-rules-guide.tips": "Erota vakaat liiketoimintasäännöt konfiguroitavista operatiivisista parametreista.",
+  "resource.decision-business-rules-guide.tips.1": "Käytä esimerkkejä ja reunatapauksia sääntöjen tulkinnan validointiin.",
+  "resource.automation-trigger-handoff-exception-guide.title": "Automaation käynnistinten, luovutusten ja poikkeusten opas",
+  "resource.automation-trigger-handoff-exception-guide.description": "Ohje automaation käynnistinten, ihmisten välisten luovutusten, poikkeusten käsittelyn, uudelleenyritysten, kompensoivien toimien ja tuen eskalointipolkujen määrittelyyn.",
+  "resource.automation-trigger-handoff-exception-guide.outcomes": "Määritellyt automaation käynnistimet ja poikkeuspolut",
+  "resource.automation-trigger-handoff-exception-guide.outcomes.1": "Ihmisten väliset luovutukset ja tuen eskaloinnit ovat selkeitä.",
+  "resource.automation-trigger-handoff-exception-guide.outcomes.2": "Poikkeukset, uudelleenyritykset ja kompensoivat toimet on suunniteltu ennen toimitusta.",
+  "resource.automation-trigger-handoff-exception-guide.steps": "Määritä tapahtumat, aikataulut, käyttäjätoimet tai järjestelmätilat, jotka käynnistävät automaation.",
+  "resource.automation-trigger-handoff-exception-guide.steps.1": "Kuvaa luovutukset automaatiolta käyttäjille, operaattoreille tai tukitiimeille.",
+  "resource.automation-trigger-handoff-exception-guide.steps.2": "Dokumentoi poikkeukset, uudelleenyrityssäännöt, aikakatkaisujen toiminta ja varapolut.",
+  "resource.automation-trigger-handoff-exception-guide.steps.3": "Määritä hälytykset ja eskalointikynnykset epäonnistuneille tai epäselville automaation tuloksille.",
+  "resource.automation-trigger-handoff-exception-guide.tips": "Suunnittele poikkeuspolut työnkulun olennaisena osana, ei jälkikäteen.",
+  "resource.automation-trigger-handoff-exception-guide.tips.1": "Ota liiketoiminta- ja operointiroolit mukaan luovutusten validointiin.",
+  "resource.automation-testing-guide.title": "Automaation testausopas",
+  "resource.automation-testing-guide.description": "Ohje automatisoitujen työnkulkujen, päätösten, integraatioiden, poikkeusten, palautuksen, valvonnan ja käyttäjävaikutusten testaamiseen ennen julkaisua.",
+  "resource.automation-testing-guide.outcomes": "Validoitu automaation toiminta",
+  "resource.automation-testing-guide.outcomes.1": "Työnkulun, sääntöjen, poikkeusten ja integraatioiden testit on määritelty.",
+  "resource.automation-testing-guide.outcomes.2": "Julkaisuluottamus automatisoituihin ja ihmistä tukeviin polkuihin.",
+  "resource.automation-testing-guide.steps": "Luo testit onnistuneille poluille, reunatapauksille, poikkeuksille, uudelleenyrityksille ja luovutuksille.",
+  "resource.automation-testing-guide.steps.1": "Validoi liiketoimintasäännöt ja päätösten tulokset edustavalla datalla.",
+  "resource.automation-testing-guide.steps.2": "Testaa palautus, toipuminen, havainnoitavuus ja manuaalisen puuttumisen polut.",
+  "resource.automation-testing-guide.steps.3": "Ota käyttäjät ja operaattorit mukaan hyväksyntätestaukseen, kun automaatio muuttaa työtapoja.",
+  "resource.automation-testing-guide.tips": "Käytä tuotantoa vastaavia skenaarioita ja datamuotoja paljastamatta arkaluonteista dataa.",
+  "resource.automation-testing-guide.tips.1": "Pidä testausnäyttö saatavilla valmiuskatselmointia varten.",
+  "resource.automation-operational-ownership-guide.title": "Automaation operatiivisen omistajuuden opas",
+  "resource.automation-operational-ownership-guide.description": "Ohje automaatioiden omistajuuden, runbookien, valvonnan, tuen, seurannan, muutosten hallinnan ja jatkuvan parantamisen vastuiden määrittelyyn.",
+  "resource.automation-operational-ownership-guide.outcomes": "Selkeä automaation toimintamalli",
+  "resource.automation-operational-ownership-guide.outcomes.1": "Omistajuus-, tuki- ja eskalointivastuut on määritetty.",
+  "resource.automation-operational-ownership-guide.outcomes.2": "Seuranta- ja muutostavat ovat valmiit tuotantokäyttöä varten.",
+  "resource.automation-operational-ownership-guide.steps": "Määritä automaation liiketoiminta-, tekniset ja operatiiviset omistajat.",
+  "resource.automation-operational-ownership-guide.steps.1": "Dokumentoi runbookit, tukipolut, seurantasignaalit, palveluodotukset ja eskalointisäännöt.",
+  "resource.automation-operational-ownership-guide.steps.2": "Määritä muutosten hallinta- ja katselmointikäytännöt työnkulun, alustan ja sääntöjen päivityksille.",
+  "resource.automation-operational-ownership-guide.tips": "Älä julkaise automaatiota ilman nimettyä omistajaa poikkeuksille ja jatkuvalle parantamiselle.",
+  "resource.automation-operational-ownership-guide.tips.1": "Tee valvonnan tarpeet näkyviksi ennen toimitussuunnittelun valmistumista.",
+  "resource.automation-rollback-supervision-guide.title": "Automaation palautuksen ja valvonnan opas",
+  "resource.automation-rollback-supervision-guide.description": "Ohje automaatioiden palautuksen, keskeytyksen, manuaalisen ohituksen, seurannan, valvonnan ja toipumispolkujen suunnitteluun.",
+  "resource.automation-rollback-supervision-guide.outcomes": "Hallittavat automaation toipumispolut",
+  "resource.automation-rollback-supervision-guide.outcomes.1": "Palautus, keskeytys ja ohitus on dokumentoitu.",
+  "resource.automation-rollback-supervision-guide.outcomes.2": "Valvontatarpeet ja toipumisvastuut on määritelty.",
+  "resource.automation-rollback-supervision-guide.steps": "Tunnista toimet, jotka täytyy voida palauttaa, keskeyttää tai ohittaa manuaalisesti.",
+  "resource.automation-rollback-supervision-guide.steps.1": "Määritä palautus-, kompensaatio- ja toipumismenettelyt epäonnistuneille tai virheellisille automaation tuloksille.",
+  "resource.automation-rollback-supervision-guide.steps.2": "Dokumentoi valvontakynnykset, hälytykset ja manuaaliset päätöspisteet.",
+  "resource.automation-rollback-supervision-guide.steps.3": "Validoi toipumismenettelyt ennen julkaisua.",
+  "resource.automation-rollback-supervision-guide.tips": "Käsittele palautusta ja valvontaa osana työnkulun suunnittelua ja toimitussuunnitelmaa.",
+  "resource.automation-rollback-supervision-guide.tips.1": "Hyödynnä operatiivisia häiriöitä ja läheltä piti -tilanteita valvontakriteerien tarkentamiseen.",
+  "resource.automation-readiness-checklist.title": "Automaation valmiuden tarkistuslista",
+  "resource.automation-readiness-checklist.description": "Tarkistuslista automaation työnkulun, kontrollien, riskien, vaatimustenmukaisuuden, ihmisen valvonnan, testausnäytön, palautuksen, operoinnin ja julkaisuvalmiuden validointiin.",
+  "resource.automation-readiness-checklist.outcomes": "Dokumentoitu automaation valmius",
+  "resource.automation-readiness-checklist.outcomes.1": "Tunnetut valmiuspuutteet ja lievennykset on tunnistettu ennen julkaisua.",
+  "resource.automation-readiness-checklist.outcomes.2": "Näyttö laadusta, riskistä, vaatimustenmukaisuudesta, valvonnasta ja operatiivisesta hyväksynnästä.",
+  "resource.automation-readiness-checklist.steps": "Katselmoi työnkulun suunnittelu, liiketoimintasäännöt, kontrollit, pääsy, datankäsittely ja poikkeuspolut.",
+  "resource.automation-readiness-checklist.steps.1": "Varmista testausnäyttö, palautusmenettelyt, valvontamalli ja tuen valmius.",
+  "resource.automation-readiness-checklist.steps.2": "Vahvista omistajuus, runbookit, seuranta, muutosten hallinta ja julkaisuhyväksyntä.",
+  "resource.automation-readiness-checklist.steps.3": "Kirjaa avoimet puutteet, päätökset ja hyväksytyt riskit ennen julkaisua.",
+  "resource.automation-readiness-checklist.tips": "Käytä ennen julkaisua ja uudelleen olennaisten työnkulku- tai sääntömuutosten jälkeen.",
+  "resource.automation-readiness-checklist.tips.1": "Tee ihmisen valvonta ja poikkeusten käsittely näkyväksi näytössä.",
+  "resource.automation-rollout-enablement-guide.title": "Automaation käyttöönoton ja tuen opas",
+  "resource.automation-rollout-enablement-guide.description": "Ohje automaatioiden käyttöönottoon käyttäjäviestinnän, onboardingin, käyttöohjeiden, tukipolkujen, muutoksenhallinnan ja palautesilmukoiden avulla.",
+  "resource.automation-rollout-enablement-guide.outcomes": "Käyttäjät ja operaattorit on tuettu automaation käyttöön",
+  "resource.automation-rollout-enablement-guide.outcomes.1": "Käyttöönoton viestintä, onboarding ja tukipolut on valmisteltu.",
+  "resource.automation-rollout-enablement-guide.outcomes.2": "Käyttäjät ja operaattorit ymmärtävät, miten työ muuttuu automaation julkaisun jälkeen.",
+  "resource.automation-rollout-enablement-guide.steps": "Määritä käyttöönoton kohderyhmät, ajoitus, viestintäkanavat ja koulutustarpeet.",
+  "resource.automation-rollout-enablement-guide.steps.1": "Julkaise käyttöohjeet, tukipolut, poikkeusten käsittelyn ohjeet ja eskalointikontaktit.",
+  "resource.automation-rollout-enablement-guide.steps.2": "Suunnittele siirtymän tuki käyttäjille, operaattoreille ja prosessinomistajille.",
+  "resource.automation-rollout-enablement-guide.steps.3": "Kerää palautetta käyttöönoton jälkeen ja vie parannukset kehitysjonoon.",
+  "resource.automation-rollout-enablement-guide.tips": "Käytä automaatioille käyttöönoton kieltä sen sijaan, että käsittelet tukea API-julkaisuna.",
+  "resource.automation-rollout-enablement-guide.tips.1": "Ota mukaan sekä prosessin käyttäjät että automaatiosta vastaavat operaattorit.",
+  "resource.api-community-engagement-strategies.tips.2": "Käytä tätä resurssia, kun valittu toteutustapa on API.",
+  "resource.api-development-best-practices.tips.2": "Käytä tätä resurssia, kun valittu toteutustapa on API.",
+  "resource.api-metrics-and-analytics.tips.2": "Käytä tätä resurssia, kun valittu toteutustapa on API.",
+  "resource.api-testing-best-practices.tips.2": "Käytä tätä resurssia, kun valittu toteutustapa on API.",
+  "resource.apiops-CI-CD-for-apis.tips.2": "Käytä tätä resurssia, kun valittu toteutustapa on API.",
+  "resource.api-audit-checklist.tips.2": "Käytä tätä resurssia, kun valittu toteutustapa on API."
 }
diff --git a/src/data/method/fi/labels.stakeholders.json b/src/data/method/fi/labels.stakeholders.json
index 383b1fa..550f9a1 100644
--- a/src/data/method/fi/labels.stakeholders.json
+++ b/src/data/method/fi/labels.stakeholders.json
@@ -3,33 +3,47 @@
   "stakeholder.involvement.core": "Ydintiimi",
   "stakeholder.involvement.consulted": "Konsultoitava",
   "stakeholder.business-owner.title": "Liiketoiminnan omistaja",
-  "stakeholder.business-owner.description": "Edustaa liiketoiminnan tavoitteita, rahoitusta ja odotettuja tuloksia API-hankkeessa.",
+  "stakeholder.business-owner.description": "Edustaa liiketoimintatavoitteita, rahoitusta ja odotettuja tuloksia kyvykkyys-, API- tai automaatiohankkeessa.",
   "stakeholder.api-program-owner.title": "API-ohjelman omistaja",
   "stakeholder.api-program-owner.description": "Koordinoi API-portfolion käytäntöjä, organisaation suuntautumista ja pitkän aikavälin API-kyvykkyyksien kehitystä.",
   "stakeholder.api-product-owner.title": "API-tuoteomistaja",
   "stakeholder.api-product-owner.description": "Ohjaa API-mahdollisuutta, priorisointia ja tuotetasolla tehtyjä päätöksiä elinkaaren aikana.",
-  "stakeholder.domain-expert.title": "Liiketoiminta-asiantuntija",
-  "stakeholder.domain-expert.description": "Tuo syvällistä tietoa liiketoiminta-alasta, käsitteistä, säännöistä ja rajoituksista, joita APIn täytyy heijastaa.",
-  "stakeholder.customer-or-partner-representative.title": "Asiakas- tai kumppaniedustaja",
-  "stakeholder.customer-or-partner-representative.description": "Edustaa APIn ulkoisten asiakkaiden, kumppaneiden tai muiden hyödyntäjien tarpeita ja näkökulmia.",
-  "stakeholder.api-consumer-representative.title": "API-hyödyntäjien edustaja",
-  "stakeholder.api-consumer-representative.description": "Edustaa kehittäjien, integraattoreiden tai muiden API-hyödyntäjien tarpeita, jotka käyttävät APIa suoraan.",
+  "stakeholder.capability-owner.title": "Kyvykkyyden omistaja",
+  "stakeholder.capability-owner.description": "Vastaa kyvykkyyden visiosta, arvosta, priorisoinnista, elinkaaresta ja uudelleenkäytöstä eri hyödyntäjille.",
+  "stakeholder.domain-specialist.title": "Liiketoiminta-asiantuntija",
+  "stakeholder.domain-specialist.description": "Tuo syvällistä tietoa liiketoiminta-alueesta, käsitteistä, säännöistä ja rajoituksista, joita kyvykkyyden tai rajapinnan täytyy heijastaa.",
+  "stakeholder.customer-specialist.title": "Asiakas- tai kumppaniedustaja",
+  "stakeholder.customer-specialist.description": "Edustaa asiakkaan tai kumppanin näkökulmaa polkuun, arvoon ja yhteistyömalliin.",
+  "stakeholder.api-consumer-specialist.title": "API-hyödyntäjien edustaja",
+  "stakeholder.api-consumer-specialist.description": "Edustaa kehittäjien, integraattoreiden tai muiden API-hyödyntäjien tarpeita, jotka käyttävät APIa suoraan.",
   "stakeholder.platform-architect.title": "Alusta-arkkitehti",
-  "stakeholder.platform-architect.description": "Ohjaa alustan, integraation, skaalautuvuuden ja arkkitehtuurin päätöksiä, jotka määrittelevät, miten API on rakennettu ja toimii.",
+  "stakeholder.platform-architect.description": "Ohjaa alustan, integraation, skaalautuvuuden ja arkkitehtuurin päätöksiä, jotka määrittelevät, miten kyvykkyys tai API rakennetaan ja operoidaan.",
+  "stakeholder.api-architect.title": "API-arkkitehti",
+  "stakeholder.api-architect.description": "Vastaa API-arkkitehtuurista, suunnitteluperiaatteista ja rajapintasopimusten laadusta.",
+  "stakeholder.integration-architect.title": "Integraatioarkkitehti",
+  "stakeholder.integration-architect.description": "Suunnittelee integraatiotavat ja toteutustavat, joilla kyvykkyys tai API yhdistetään muihin järjestelmiin.",
+  "stakeholder.platform-owner.title": "Alustan omistaja",
+  "stakeholder.platform-owner.description": "Vastaa alustan kyvykkyyksistä, tiekartasta, operatiivisesta mallista ja palveluodotuksista.",
   "stakeholder.api-designer.title": "API-suunnittelija",
-  "stakeholder.api-designer.description": "Muokkaa API-sopimusta, vuorovaikutusmallia, johdonmukaisuutta ja käytettävyyttä exponoituja kykyjä.",
-  "stakeholder.delivery-engineer.title": "Ohjelmistokehittäjä",
-  "stakeholder.delivery-engineer.description": "Omistaa toteutuksen, automaation, testauksen ja julkaisun kulkuun liittyvät kysymykset, jotka ovat tarpeen toimittaa API luotettavasti.",
+  "stakeholder.api-designer.description": "Suunnittelee rajapintasopimuksen, vuorovaikutusmallin, johdonmukaisuuden, käytettävyyden ja tarjottavat kyvykkyydet.",
+  "stakeholder.api-engineer.title": "Toimituskehittäjä",
+  "stakeholder.api-engineer.description": "Vastaa toteutuksesta, automaatiosta, testauksesta ja julkaisun kulusta, joita kyvykkyyden, APIn tai automaation luotettava toimittaminen edellyttää.",
+  "stakeholder.automation-owner.title": "Automaation omistaja",
+  "stakeholder.automation-owner.description": "Vastaa automaation tavoitteista, liiketoiminta-arvosta, priorisoinnista, kontrolleista ja elinkaaren tuloksista.",
+  "stakeholder.process-owner.title": "Prosessin omistaja",
+  "stakeholder.process-owner.description": "Vastaa automatisoitavasta liiketoimintaprosessista, mukaan lukien tavoitteet, säännöt, tulokset ja kehittämisen prioriteetit.",
+  "stakeholder.automation-engineer.title": "Automaatiokehittäjä",
+  "stakeholder.automation-engineer.description": "Toteuttaa, testaa, integroi ja ylläpitää automaatioratkaisuja ja niitä tukevia työnkulkuja.",
   "stakeholder.security-specialist.title": "Turvallisuusasiantuntija",
-  "stakeholder.security-specialist.description": "Varmistaa, että turvallisuusriskit, kontrollit ja luottamusrajat käsitellään koko API-kehitysprosessin aikana.",
-  "stakeholder.compliance-legal-specialist.title": "Vaatimuksenmukaisuuden ja oikeudellinen asiantuntija",
-  "stakeholder.compliance-legal-specialist.description": "Selventää oikeudellisia, tietosuojaa koskevia, sääntelyä ja sopimusvaatimuksia, jotka vaikuttavat APIin.",
-  "stakeholder.governance-owner.title": "API-hallinnan omistaja",
-  "stakeholder.governance-owner.description": "Vastaa API-hallintaprosesseista, ohjeista ja päätöksenteosta, joka määrittelee, miten API-kehityspäätökset tehdään ja dokumentoidaan.",
-  "stakeholder.documentation-devrel-owner.title": "Dokumentoinnin ja kehittäjäsuhteiden omistaja",
-  "stakeholder.documentation-devrel-owner.description": "Varmistaa, että API-dokumentaatio, esimerkit, koulutus ja kehittäjäsuhteiden strategiat tukevat API-hyödyntäjien tarpeita.",
-  "stakeholder.support-operations-owner.title": "Tuki- ja operaatioiden omistaja",
-  "stakeholder.support-operations-owner.description": " Vastaa API-tuen, valvonnan, vianmäärityksen ja jatkuvan parantamisen prosesseista, jotka varmistavat APIn luotettavuuden ja hyödyntäjien tyytyväisyyden.",
-  "stakeholder.partner-vendor-manager.title": "Kumppani- ja toimittajavastaava",
-  "stakeholder.partner-vendor-manager.description": "Koordinoi ulkoisia kumppanisuhde, toimittajasuhteita ja vendor-suhteita, jotka vaikuttavat API-strategiaan ja -kehitykseen."
+  "stakeholder.security-specialist.description": "Varmistaa, että turvallisuusriskit, kontrollit ja luottamusrajat käsitellään koko elinkaaren aikana.",
+  "stakeholder.compliance-specialist.title": "Vaatimustenmukaisuus- ja lakiasiantuntija",
+  "stakeholder.compliance-specialist.description": "Selventää juridiset, tietosuojaan liittyvät, sääntelyyn liittyvät ja sopimukselliset vaatimukset, jotka vaikuttavat kyvykkyyteen, APIin, rajapintaan tai automaatioon.",
+  "stakeholder.governance-specialist.title": "API-hallinnan omistaja",
+  "stakeholder.governance-specialist.description": "Vastaa API-hallintaprosesseista, ohjeista ja päätöksenteosta, joka määrittelee, miten API-kehityspäätökset tehdään ja dokumentoidaan.",
+  "stakeholder.api-devrel-specialist.title": "Dokumentoinnin ja kehittäjäsuhteiden omistaja",
+  "stakeholder.api-devrel-specialist.description": "Varmistaa, että API-dokumentaatio, esimerkit, koulutus ja kehittäjäsuhteiden strategiat tukevat API-hyödyntäjien tarpeita.",
+  "stakeholder.operations-specialist.title": "Tuki- ja operaatioiden omistaja",
+  "stakeholder.operations-specialist.description": "Edustaa tuotannon tukea, häiriönhallintaa, havainnoitavuutta ja operatiivista valmiutta kyvykkyydelle, APIlle tai automaatiolle.",
+  "stakeholder.partner-specialist.title": "Kumppani- ja toimittajavastaava",
+  "stakeholder.partner-specialist.description": "Koordinoi ulkoisia kumppani-, toimittaja- ja alihankkijasuhteita, jotka vaikuttavat kyvykkyys- tai API-strategiaan ja toimitukseen."
 }
diff --git a/src/data/method/fi/labels.stations.json b/src/data/method/fi/labels.stations.json
index 5b2b36f..6d334b3 100644
--- a/src/data/method/fi/labels.stations.json
+++ b/src/data/method/fi/labels.stations.json
@@ -1,377 +1,467 @@
 {
- "group.core-stations.title": "APIn elinkaaren ydinasemat",
- "group.core-stations.description": "API Metron ydinasemat, joissa tiimit voivat oppia rakentamaan ja hallinnoimaan rajapintoja tehokkaasti.",
- "group.sub-stations.title": "APIn elinkaaren lähiöasemat",
- "group.sub-stations.description": "Lähiöasemat, jotka tarjoavat lisäresursseja, työkaluja ja parhaita käytäntöjä API-tiimeille.",
- "station.api-product-strategy.title": "API-tuotestrategia - Tee rajapinnoista strategisia tuotteita",
- "station.api-product-strategy.description": "Ennen kuin rakennat mitään, määrittele APIn arvo, käyttäjät ja liiketoiminnalliset tavoitteet heti alusta alkaen.",
- "station.api-product-strategy.why_it_matters": "Monet organisaatiot pitävät rajapintoja teknisinä projekteina, ei tuotteina. Tulos? Hämmentyneitä kuluttajia, heikkoa käyttöönottoa ja turhaa työtä. Tämä asema auttaa määrittelemään APIn tarkoituksen, kohderyhmän ja menestyskriteerit, jotta tiimit voivat tuottaa rajapintoja, jotka ratkaisevat todellisia ongelmia.",
- "station.api-product-strategy.apply_in_work": "Tarjotaan ohjeita ja malleja API-liiketoimintamallien, arvolupausten ja etenemissuunnitelmien luomista varten.",
- "station.api-product-strategy.outcomes": "Suoraviivainen API-arvolupaus ja yleisö",
- "station.api-product-strategy.how_it_works": "Tutki asiakkaan tai yhteistyökumppanin ongelmaa, jonka oletat voivasi ratkaista APIen avulla. Kartoita sidosryhmät, niiden matkat ja tulokset Customer Journey canvasin avulla.",
- "station.api-consumer-experience.title": "API-hyödyntäjäkokemus - Suunnittele APIn todellisia käyttäjiä varten.",
- "station.api-consumer-experience.description": "Varmistetaan, että API on löydettävissä, ymmärrettävissä ja käyttökelpoinen ennen käyttöönottoa ja sen jälkeen.",
- "station.api-consumer-experience.why_it_matters": "Hyvät aPIt eivät ainoastaan toimi - ne tuntuvat intuitiivisilta. Riippumatta siitä, onko hyödyntäjä sisäinen kehittäjä, ulkoinen kumppani vai tekoälyagentti, heidän kokemuksensa ratkaisee hyväksynnän. Ilman selkeää kokemussuunnitelmaa",
- "station.api-consumer-experience.how_it_works": "Tarkastele olemassa olevaa API Value Proposition Canvasta API-hyödyntäjän näkökulmasta. Säilytä tuetut liiketoimintatehtävät vakaina ja rikasta tuskaa lievittäviä ja hyötyjä mahdollistavia ominaisuuksia API-hyödyntäjien näkökulmalla, jotta ne voivat ohjata myöhempiä suunnittelupäätöksiä.",
- "station.api-consumer-experience.how_it_works.1": "Käytä Customer Journey Canvas -pohjaa API-käyttäjän matkan kuvaamiseen löytämisestä ja arvioinnista käyttöönottoon, integrointiin, vianmääritykseen ja jatkuvaan käyttöön.",
- "station.api-consumer-experience.how_it_works.2": "Käytä tuloksena saatua polkua parantaaksesi käyttöönottoa, dokumentaatiota, tukea ja palautesilmukoita API-käyttäjälle.",
- "station.api-consumer-experience.apply_in_work": "Tarjotaan ohjeita, työkaluja ja palautemekanismeja sisäisten ja ulkoisten kehittäjien ja kumppaneiden kokemusten ymmärtämiseksi, analysoimiseksi ja parantamiseksi.",
- "station.api-consumer-experience.outcomes": "Tunnista ja priorisoi API-asiakkaat",
- "station.api-platform-architecture.title": "API-alustan arkkitehtuuri",
- "station.api-platform-architecture.description": "Varmistetaan skaalautuvuus, uudelleenkäyttö ja hallinta API- ja alustakomponenttien välillä.",
- "station.api-platform-architecture.why_it_matters": "Kun rajapinnat skaalautuvat eri tiimeille, alustan on mahdollistettava hallinta ja uudelleenkäyttö nopeutta estämättä. Tällä asemalla kerrotaan, miten API-arkkitehtuurit voidaan suunnitella pitkäikäisiksi, turvallisiksi ja tehokkaiksi.",
- "station.api-platform-architecture.apply_in_work": "Perustetaan skaalautuva, turvallinen ja vaatimustenmukainen infrastruktuuri API-toimintoja varten. Annetaan ohjeita arkkitehtuurin parhaista käytännöistä.",
- "station.api-platform-architecture.outcomes": "Vähennä turhia API-rajapintoja ja vähennä pilvialustakustannuksia.",
- "station.api-platform-architecture.how_it_works": "Business Impact Canvas auttaa tunnistamaan ja lieventämään APIn saatavuuteen, tietoturvaan ja toiminnallisuuteen liittyviä riskejä ja tukemaan tietoon perustuvia arkkitehtuuripäätöksiä.",
- "station.api-design.title": "API-design - Suunnittele arvoa tuottavia rajapintoja",
- "station.api-design.description": "Luo API-suunnitelmia, jotka ovat johdonmukaisia, uudelleenkäytettäviä ja perustuvat liiketoiminnallisiin tavoitteisiin sekä yhteisiin standardeihin.",
- "station.api-design.why_it_matters": "APIen suunnittelu ei tarkoita pelkästään päätepisteiden (endpoints) nimeämistä. Hyvä suunnittelu varmistaa, että APIt ovat käyttökelpoisia, johdonmukaisia ja linjassa liiketoiminnallisten ja teknisten tavoitteiden kanssa. Huono suunnittelu johtaa tiukkoihin riippuvuuksiin, heikkoon uudelleenkäytettävyyteen ja kalliiseen uudelleen toteutukseen eri tiimien välillä.",
- "station.api-design.apply_in_work": "Tarjoa uudelleenkäytettäviä suunnittelumalleja, yhteisiä standardeja ja validointityökaluja API-määrityksille. Varmista, että suunnittelupäätökset ovat johdonmukaisia, tarkistettuja varhaisessa vaiheessa ja linjassa liiketoiminnallisten tavoitteiden kanssa.",
- "station.api-design.outcomes": "Hyvin dokumentoidut ja johdonmukaiset API-mallit",
- "station.api-design.how_it_works": "Määrittele keskeiset oliot, niiden attribuutit ja suhteet yhteisen käsitteellisen ymmärryksen luomiseksi eri rajapinnoille.",
- "station.api-delivery.title": "API-kehitys - Kehitä turvalliset ja luotettavat rajapinnat",
- "station.api-delivery.description": "Rakenna, testaa ja julkaise rajapintoja käyttämällä nykyaikaisia jakeluputkia ja parhaita teknisiä käytäntöjä.",
- "station.api-delivery.why_it_matters": "Parhaatkin API-suunnitelmat epäonnistuvat, jos kehitys on epäjohdonmukaista. Tällä asemalla varmistetaan, että rajapinnat rakennetaan laadukkaasti, testataan perusteellisesti ja otetaan käyttöön luotettavasti, mikä mahdollistaa nopeammat iteraatiot ja suuremman luottamuksen.",
- "station.api-delivery.apply_in_work": "Toimittaa koodauskehyksiä, kirjastoja ja standardeja API-toteutusta varten. CI/CD-putkien, laadunvarmistuskehysten ja käyttöönottoautomaatiotyökalujen toteuttaminen.",
- "station.api-delivery.outcomes": "Rajapinnat, jotka on toteutettu testattujen kehysten ja mallien avulla.",
- "station.api-delivery.how_it_works": "Käytä API-kehityksen parhaita käytäntöjä ohjeena validoidun sopimuksen toteuttamiseen vakiintuneilla kehysrakenteilla ja kirjastoilla varmistaen, että tulos on uudelleenkäytettävä ja ylläpidettävä.",
- "station.api-audit.title": "API-auditointi - API-rajapintojen tarkastus vaatimustenmukaisuuden ja laadun varmistamiseksi",
- "station.api-audit.description": "Varmista, että APIt täyttävät liiketoiminta-, suunnittelu- ja toimintastandardit ennen julkaisua ja käyttöönottoa.",
- "station.api-audit.why_it_matters": "APIt ovat pitkäikäisiä tuotteita, ja niiden on täytettävä laatu-, johdonmukaisuus- ja vaatimustenmukaisuusodotukset. Auditointi yhdistää suunnittelupäätökset, toteutuksen ja toimintavalmiuden määriteltyihin standardeihin, mikä vähentää riskejä ennen käyttöönottoa.",
- "station.api-audit.apply_in_work": "Luo johdonmukainen auditointiprosessi, joka arvioi APIn valmiutta elinkaaren eri vaiheissa määriteltyjen kriteerien, todisteiden ja standardien avulla. Varmista, että puutteet tunnistetaan varhaisessa vaiheessa ja korjataan ennen julkaisua.",
- "station.api-audit.outcomes": "APIt täyttävät sisäiset ja ulkoiset standardit",
- "station.api-audit.how_it_works": "Suorita tarkastuksia varmistaaksesi, että rajapinnat täyttävät organisatoriset, tekniset ja oikeudelliset standardit ennen julkaisemista.",
- "station.api-publishing.title": "API-julkaiseminen - Julkaise APIt luotettavasti",
- "station.api-publishing.description": "Esittele APIt turvallisesti ja selkeästi oikealle yleisölle oikean dokumentaation ja prosessien avulla.",
- "station.api-publishing.why_it_matters": "Julkaiseminen on muutakin kuin käyttöönottoa - kyse on löydettävyydestä, saatavuudesta ja tuesta. Jos rajapintoja ei julkaista oikein, niitä ei käytetä, käytetä uudelleen tai suojata tehokkaasti.",
- "station.api-publishing.apply_in_work": "Mahdollistetaan APIen julkaiseminen asiaankuuluvassa ympäristössä ja selkeät rekisteröinti- ja käyttöoikeusmekanismit (esim. API-avaimet, OAuth, tilaussuunnitelmat) API-hyödyntäjäsegmenttien sekä turvallisuus- ja vaatimustenmukaisuusvaatimusten mukaan.",
- "station.api-publishing.outcomes": "APIt julkaistaan oikeassa ympäristössä (yksityinen, kumppani, julkinen).",
- "station.api-publishing.how_it_works": "Julkaise rajapinnat asianmukaisiin yhdyskäytäviin ja ympäristöihin, jotta ne ovat uudelleenkäytettävissä useille rajapinnan käyttäjille.",
- "station.monitoring-and-improving.title": "Seuranta ja parantaminen - API-arvoa varten",
- "station.monitoring-and-improving.description": "Käytä mittareita ja palautetta API-suorituskyvyn seuraamiseen ja jatkuvan parantamisen edistämiseen.",
- "station.monitoring-and-improving.why_it_matters": "API-kehitys ei lopu käynnistykseen. Ilman seurantaa tiimit eivät voi parantaa käyttöönottoa, suorituskykyä tai ROI",
- "station.monitoring-and-improving.apply_in_work": "Ota käyttöön analytiikkakehykset suorituskyvyn ja sitoutumisen seuraamiseksi. Kehitetään palautesilmukoita, analytiikkatyökaluja ja sitouttamisstrategioita API-rajapintoja varten.",
- "station.monitoring-and-improving.outcomes": "Suorituskyvyn ja käytön mittarit määritellään ja niitä seurataan.",
- "station.monitoring-and-improving.how_it_works": "Seuraa suorituskykymittareita (esim. API-kutsut, viiveet, virhetasot) ja hyväksyntämittareita (esim. NPS).",
- "station.user-experience.title": "Käyttäjäkokemus - Suunnittele APIt käyttäjälähtöisesti",
- "station.user-experience.description": "Varmistetaan, että rajapinnat on suunniteltu loppukäyttäjää ajatellen ja että ne tarjoavat saumattoman ja intuitiivisen käyttökokemuksen.",
- "station.user-experience.why_it_matters": "APIt eivät ole vain teknisiä tuotteita, vaan ne ovat käyttäjäkohtaisia tuotteita. Huono käyttökokemus voi johtaa vähäiseen käyttöön ja turhautumiseen. Tämä asema auttaa tiimejä suunnittelemaan APIt, jotka ovat käyttäjäystävällisiä ja vastaavat kuluttajien tarpeita.",
- "station.user-experience.apply_in_work": "Tarjotaan käyttäjäkokemusta koskevia ohjeita, malleja ja työkaluja API-suunnittelua varten. Varmistetaan, että tiimit noudattavat käyttäjäkeskeisiä suunnittelukäytäntöjä ja sisällyttävät käyttäjäpalautteen API-iteraatioihin.",
- "station.user-experience.outcomes": "APIt on suunniteltu käyttäjien tarpeet mielessä pitäen",
- "station.user-experience.how_it_works": "Käyttäjäpersoonien käyttö loppukäyttäjien tarpeiden ja odotusten ymmärtämiseksi.",
- "station.market-insights.title": "Markkinatietoa - API-maiseman ymmärtäminen",
- "station.market-insights.description": "Analysoi markkinasuuntauksia, kilpailijoiden rajapintoja ja alan standardeja rajapintastrategian laatimiseksi.",
- "station.market-insights.why_it_matters": "Markkinatilanteen ymmärtäminen auttaa tiimejä tunnistamaan mahdollisuuksia, välttämään sudenkuoppia ja mukauttamaan rajapintansa alan standardeihin. Tämä asema tarjoaa työkaluja markkinasuuntausten ja kilpailijoiden tarjonnan analysointiin.",
- "station.market-insights.apply_in_work": "Tarjotaan markkinatutkimustyökaluja, kilpailija-analyysimalleja ja alan standardeja koskevia resursseja. Varmistetaan, että tiimit pysyvät ajan tasalla markkinasuuntauksista ja sisällyttävät näkemykset API-strategiaan.",
- "station.market-insights.outcomes": "Markkinatrendit ja kilpailijoiden APIt analysoitu",
- "station.market-insights.how_it_works": "Markkinatutkimuksen tekeminen API-toimialalla vallitsevien suuntausten, mahdollisuuksien ja uhkien tunnistamiseksi.",
- "station.business-goals.title": "Liiketoiminnalliset tavoitteet - Kohdista rajapinnat liiketoimintatavoitteisiin.",
- "station.business-goals.description": "Varmistetaan, että rajapinnat ovat linjassa liiketoiminnan tavoitteiden kanssa ja edistävät organisaation yleisiä tavoitteita.",
- "station.business-goals.why_it_matters": "Rajapintoja ei pidä rakentaa erillään, vaan niiden on tuettava ja edistettävä liiketoiminnan tavoitteita. Tämä asema auttaa tiimejä sovittamaan rajapinnat strategisiin tavoitteisiin ja varmistamaan, että ne tuottavat todellista liiketoiminta-arvoa.",
- "station.business-goals.apply_in_work": "Tarjotaan liiketoimintasuuntautumiskehyksiä, malleja ja työkaluja API-liiketoiminta-arvon määrittelyyn. Varmistetaan, että tiimit tarkistavat ja sovittavat sovellusrajapinnat säännöllisesti yhteen muuttuvien liiketoimintatavoitteiden kanssa.",
- "station.business-goals.outcomes": "APIt linjassa liiketoiminnan tavoitteiden kanssa",
- "station.business-goals.how_it_works": "Määrittele liiketoimintatavoitteet ja se, miten rajapinnat voivat tukea niitä käyttämällä **liiketoimintamallia (Business Model Canvas**). Jos liiketoimintasi tarkoituksena on tarjota rajapintoja, käy läpi *API-tuotestrategia-asema* ja täytä **API-liiketoimintamalli Canvas**.",
- "station.competitive-analysis.title": "Kilpailuanalyysi - pysy kärjessä API-markkinoilla",
- "station.competitive-analysis.description": "Analysoi kilpailijoiden rajapinnat vahvuuksien, heikkouksien ja erottautumismahdollisuuksien tunnistamiseksi.",
- "station.competitive-analysis.why_it_matters": "Kilpailutilanteen ymmärtäminen auttaa tiimejä tunnistamaan API-rajapintojensa puutteet, mahdollisuudet ja parannuskohteet. Tämä asema tarjoaa työkaluja kilpailijoiden analysointiin ja API-strategian laatimiseen.",
- "station.competitive-analysis.apply_in_work": "Tarjotaan kilpailuanalyysityökaluja, malleja ja resursseja. Varmistetaan, että tiimit analysoivat säännöllisesti kilpailijoita ja sisällyttävät näkemykset API-strategiaan ja -suunnitteluun.",
- "station.competitive-analysis.outcomes": "Kilpailijoiden rajapintojen vahvuudet ja heikkoudet analysoidaan.",
- "station.competitive-analysis.how_it_works": "Suorita kilpailija-analyysi tärkeimpien kilpailijoiden, niiden API-tarjonnan sekä niiden vahvuuksien ja heikkouksien tunnistamiseksi.",
- "station.ecosystem-vision.title": "Ekosysteemin visio - Rakenna rajapinnat kukoistavaa ekosysteemiä varten.",
- "station.ecosystem-vision.description": "Luo visio siitä, miten rajapintasi sopivat laajempaan ekosysteemiin, joka mahdollistaa yhteistyön ja innovoinnin.",
- "station.ecosystem-vision.why_it_matters": "APIt eivät ole itsenäisiä tuotteita, vaan osa laajempaa ekosysteemiä. Tämä asema auttaa tiimejä määrittelemään, miten niiden rajapinnat ovat vuorovaikutuksessa muiden järjestelmien, alustojen ja palvelujen kanssa, jotta voidaan luoda kukoistava ekosysteemi, joka edistää yhteistyötä ja innovointia.",
- "station.ecosystem-vision.apply_in_work": "Tarjotaan ekosysteemin visiokehykset, kumppanien sitouttamisstrategiat ja integrointiohjeet. Varmistaa, että tiimit suunnittelevat rajapinnat ekosysteemiä silmällä pitäen ja edistävät kumppanien välistä yhteistyötä.",
- "station.ecosystem-vision.outcomes": "Selkeä ekosysteemin visio rajapinnoille",
- "station.ecosystem-vision.how_it_works": "Määrittele rajapintojesi ekosysteemivisio, mukaan lukien se, miten ne ovat vuorovaikutuksessa muiden järjestelmien ja alustojen kanssa.",
- "station.scalable-infrastructure.title": "Skaalautuva infrastruktuuri - rakenna APIt vankalle perustalle",
- "station.scalable-infrastructure.description": "Varmistetaan, että API-infrastruktuurisi voi skaalautua vastaamaan kasvavaa kysyntää ja tukea korkeaa käytettävyyttä.",
- "station.scalable-infrastructure.why_it_matters": "APIt on rakennettava vankalle infrastruktuurille, joka kestää kasvavan liikenteen ja varmistaa korkean käytettävyyden. Tämä asema tarjoaa ohjeita APIn kasvua ja suorituskykyä tukevan skaalautuvan infrastruktuurin suunnitteluun ja toteuttamiseen.",
- "station.scalable-infrastructure.apply_in_work": "Tarjotaan infrastruktuurin suunnitteluohjeita, pilvipohjaisia malleja ja valvontatyökaluja. Varmistetaan, että tiimit ottavat käyttöön skaalautuvan infrastruktuurin, joka pystyy mukautumaan muuttuviin vaatimuksiin ja tukemaan API-suorituskykyä.",
- "station.scalable-infrastructure.outcomes": "Skaalautuva ja joustava API-infrastruktuuri",
- "station.scalable-infrastructure.how_it_works": "Suunnittele API-infrastruktuuri skaalautuvaksi ja joustavaksi käyttäen pilvipohjaisia malleja ja teknologioita.",
- "station.legal-and-compliance.title": "Lainsäädäntö ja vaatimustenmukaisuus - varmista, että APIt täyttävät sääntelystandardit.",
- "station.legal-and-compliance.description": "Varmistetaan, että rajapinnat noudattavat lakisääteisiä ja lainsäädännöllisiä vaatimuksia ja suojaavat organisaatiota ja käyttäjiä.",
- "station.legal-and-compliance.why_it_matters": "API-rajapintojen on noudatettava oikeudellisia ja sääntelystandardeja organisaation ja käyttäjien suojelemiseksi. Tämä asema tarjoaa työkaluja ja ohjeita, joilla varmistetaan, että rajapinnat täyttävät vaatimustenmukaisuusvaatimukset, vähennetään oikeudellisia riskejä ja varmistetaan tietosuoja.",
- "station.legal-and-compliance.apply_in_work": "Tarjotaan oikeudellisia ja vaatimustenmukaisuutta koskevia puitteita, tarkistuslistoja ja työkaluja API-vaatimustenmukaisuuden varmistamiseksi. Varmistetaan, että tiimit ymmärtävät ja panevat täytäntöön oikeudelliset vaatimukset APIn suunnittelussa, kehittämisessä ja julkaisemisessa.",
- "station.legal-and-compliance.outcomes": "Oikeudellisten ja sääntelystandardien mukaiset APIt",
- "station.legal-and-compliance.how_it_works": "Tunnista rajapintoihin sovellettavat oikeudelliset ja sääntelyvaatimukset, kuten tietosuojaa, yksityisyyttä ja tietoturvaa koskevat vaatimukset.",
- "station.security-and-privacy.title": "Tietoturva ja yksityisyys - Suojaa APIt ja käyttäjät",
- "station.security-and-privacy.description": "Toteuta tietoturva- ja yksityisyydensuojatoimenpiteet, joilla suojataan rajapintoja ja käyttäjätietoja uhkilta ja tietoturvaloukkauksilta.",
- "station.security-and-privacy.why_it_matters": "APIt ovat alttiita tietoturvauhkille ja tietomurroille. Tämä asema tarjoaa ohjeita tietoturva- ja yksityisyydensuojatoimenpiteiden toteuttamiseen, joilla suojataan rajapintoja ja käyttäjätietoja ja varmistetaan luottamus ja vaatimustenmukaisuus.",
- "station.security-and-privacy.apply_in_work": "Tarjotaan tietoturvakehyksiä, -työkaluja ja parhaita käytäntöjä rajapintojen turvallisuutta ja yksityisyyttä varten. Varmistaa, että tiimit toteuttavat tietoturvatoimenpiteitä koko APIn elinkaaren ajan suunnittelusta julkaisuun ja seurantaan.",
- "station.security-and-privacy.outcomes": "Uhkia ja haavoittuvuuksia vastaan suojatut rajapinnat",
- "station.security-and-privacy.how_it_works": "Toteuta turvatoimia, kuten todennus, valtuutus, salaus ja nopeuden rajoittaminen, suojaamaan rajapintoja uhkilta.",
- "station.design-standards.title": "Suunnittelustandardit - Varmistaa johdonmukainen ja laadukas API-suunnittelu.",
- "station.design-standards.description": "Suunnittelustandardien ja -ohjeiden laatiminen, jotta varmistetaan yhdenmukainen ja laadukas API-suunnittelu koko organisaatiossa.",
- "station.design-standards.why_it_matters": "Johdonmukainen ja laadukas API-suunnittelu on olennaisen tärkeää käytettävyyden, ylläpidettävyyden ja skaalautuvuuden kannalta. Tämä asema tarjoaa suunnittelustandardeja ja -ohjeita, joiden avulla tiimit voivat luoda rajapintoja, joita on helppo käyttää, ymmärtää ja ylläpitää.",
- "station.design-standards.apply_in_work": "Suunnittelustandardien dokumentointi, uudelleenkäytettävät komponentit ja suunnittelun tarkistusprosessit. Varmistetaan, että tiimit noudattavat suunnittelustandardeja ja tekevät säännöllisiä tarkistuksia laadukkaan API-suunnittelun ylläpitämiseksi.",
- "station.design-standards.outcomes": "Yhdenmukainen API-suunnittelu koko organisaatiossa",
- "station.design-standards.how_it_works": "Määrittele API-suunnittelun suunnittelustandardit ja -ohjeet, mukaan lukien nimeämiskäytännöt, vastausmuodot ja virheenkäsittely.",
- "station.vendor-management.title": "Toimittajan hallinta - Kolmannen osapuolen API-integraatioiden hallinta",
- "station.vendor-management.description": "Hallinnoi tehokkaasti kolmannen osapuolen API-toimittajia ja integraatioita luotettavuuden ja vaatimustenmukaisuuden varmistamiseksi.",
- "station.vendor-management.why_it_matters": "Kolmannen osapuolen rajapinnat voivat aiheuttaa riskejä ja riippuvuuksia, jotka vaikuttavat rajapintaekosysteemiisi. Tämä asema tarjoaa ohjeita toimittajasuhteiden hallintaan, luotettavuuden ja vaatimustenmukaisuuden varmistamiseen sekä API-strategian noudattamiseen.",
- "station.vendor-management.apply_in_work": "Tarjotaan toimittajien hallintakehykset, arviointikriteerit ja seurantatyökalut. Varmistetaan, että tiimit hallinnoivat tehokkaasti kolmannen osapuolen API-toimittajia ja varmistavat luotettavuuden, vaatimustenmukaisuuden ja organisaation standardien noudattamisen.",
- "station.vendor-management.outcomes": "Tehokkaat myyjien hallinnointiprosessit on otettu käyttöön",
- "station.vendor-management.how_it_works": "Ota käyttöön toimittajahallintaprosessit kolmansien osapuolten API-toimittajien arviointia, käyttöönottoa ja seurantaa varten.",
- "station.contract-design.title": "Sopimussuunnittelu - Määrittele selkeät API-sopimukset",
- "station.contract-design.description": "Luo selkeät ja hyvin määritellyt API-sopimukset, joissa hahmotellaan odotukset, vastuut ja käyttöohjeet.",
- "station.contract-design.why_it_matters": "API-sopimukset ovat olennaisen tärkeitä, jotta varmistetaan selkeys ja yhdenmukaisuus API-toimittajien ja kuluttajien välillä. Tämä asema tarjoaa ohjeita selkeiden, kattavien ja helposti ymmärrettävien API-sopimusten suunnitteluun.",
- "station.contract-design.apply_in_work": "Tarjotaan sopimussuunnittelumalleja, standardoituja muotoja ja tarkistusprosesseja. Varmistetaan, että tiimit luovat selkeät ja hyvin määritellyt API-sopimukset, joissa hahmotellaan odotukset, vastuut ja käyttöohjeet.",
- "station.contract-design.outcomes": "Kullekin ajapinnalle määritellyt selkeät API-sopimukset",
- "station.contract-design.how_it_works": "Määrittele API-sopimukset, joissa hahmotellaan kunkin APIn odotukset, vastuut ja käyttöohjeet.",
- "station.development.title": "Kehitys - Rakenna APIt parhaiden käytäntöjen avulla",
- "station.development.description": "Toteuta rajapinnat parhaiden käytäntöjen ja kehysten avulla laadun, ylläpidettävyyden ja skaalautuvuuden varmistamiseksi.",
- "station.development.why_it_matters": "APIn kehittäminen on kriittinen vaihe, joka määrittää APIn laadun ja luotettavuuden. Tämä asema tarjoaa parhaita käytäntöjä ja kehyksiä API-kehitystä varten, jotta varmistetaan, että APIt rakennetaan korkeiden standardien mukaisesti ja että niitä voidaan ylläpitää ja skaalata tehokkaasti.",
- "station.development.apply_in_work": "Kehityskehysten, kirjastojen ja koodausstandardien tarjoaminen API-toteutusta varten. Varmistaa, että tiimit noudattavat parhaita käytäntöjä, ja suorittaa koodin tarkistuksia API-kehityksen laadun ylläpitämiseksi.",
- "station.development.outcomes": "parhaita käytäntöjä ja kehyksiä hyödyntävät rajapinnat",
- "station.development.how_it_works": "Käytetään vakiintuneita kehyksiä ja kirjastoja rajapintojen toteuttamiseen ja varmistetaan, että ne ovat uudelleenkäytettäviä ja ylläpidettäviä.",
- "station.ci-cd.title": "CI/CD - Automatisoi API-kehitys",
- "station.ci-cd.description": "Ota käyttöön jatkuvan integroinnin ja jatkuvan toimituksen (CI/CD) putket API-kehityksen automatisoimiseksi ja tasaisen laadun varmistamiseksi.",
- "station.ci-cd.why_it_matters": "CI/CD on olennaisen tärkeää sen varmistamiseksi, että rajapinnat toimitetaan nopeasti, luotettavasti ja laadukkaasti. Tämä asema tarjoaa ohjeita CI/CD-putkien toteuttamiseen, jotka automatisoivat API-rajapintojen rakentamis-, testaus- ja käyttöönottoprosessit.",
- "station.ci-cd.apply_in_work": "CI/CD-kehysten, työkalujen ja parhaiden käytäntöjen tarjoaminen API-kehitystä varten. Varmistetaan, että tiimit ottavat käyttöön automatisoidut putket, jotka tukevat APIen jatkuvaa integrointia, testausta ja käyttöönottoa.",
- "station.ci-cd.outcomes": "Automaattiset CI/CD-putket API-toimituksia varten.",
- "station.ci-cd.how_it_works": "Käytetään CI/CD-putkia rakentamis-, testaus- ja käyttöönottoprosessien automatisoimiseksi varmistaen johdonmukaisen laadun ja jäljitettävyyden.",
- "station.test-automation.title": "Testausautomaatio - varmista API-laatu",
- "station.test-automation.description": "Ota käyttöön automatisoituja testauskäytäntöjä APIn laadun, luotettavuuden ja suorituskyvyn varmistamiseksi.",
- "station.test-automation.why_it_matters": "Automatisoitu testaus on ratkaisevan tärkeää sen varmistamiseksi, että rajapinnat toimivat oikein ja täyttävät laatuvaatimukset. Tämä asema tarjoaa ohjeita automaattisten testauskäytäntöjen käyttöönottoon, jotka kattavat APIen toiminnallisen, turvallisuus- ja suorituskykytestauksen.",
- "station.test-automation.apply_in_work": "Testausautomaatiokehysten, -työkalujen ja parhaiden käytäntöjen tarjoaminen API-testausta varten. Varmistetaan, että tiimit toteuttavat automatisoituja testejä, jotka kattavat APIen toiminnalliset, turvallisuus- ja suorituskykyyn liittyvät näkökohdat.",
- "station.test-automation.outcomes": "API-rajapintojen automatisoidut testauskäytännöt",
- "station.test-automation.how_it_works": "Käytetään automatisoituja testausvälineitä API-toiminnallisuuden, tietoturvan ja suorituskyvyn validointiin.",
- "station.release-management.title": "Julkaisunhallinta - Hallitse API-julkaisuja tehokkaasti",
- "station.release-management.description": "Ota käyttöön julkaisujen hallintakäytäntöjä sujuvien ja valvottujen API-julkaisujen varmistamiseksi.",
- "station.release-management.why_it_matters": "Tehokas julkaisujen hallinta on olennaisen tärkeää, jotta voidaan varmistaa, että API-julkaisut ovat sujuvia, hallittuja ja liiketoiminnan tarpeiden mukaisia. Tämä asema tarjoaa ohjeita API-julkaisujen hallintaan, mukaan lukien versiointi, käyttöönottostrategiat ja palautusmenettelyt.",
- "station.release-management.apply_in_work": "Tarjotaan julkaisunhallintakehykset, versiointiohjeet ja käyttöönottostrategiat. Varmistetaan, että tiimit noudattavat parhaita käytäntöjä API-julkaisujen hallinnassa, mukaan lukien versiointi, käyttöönotto ja palautusmenettelyt.",
- "station.release-management.outcomes": "Hallitut ja sujuvat API-julkaisut",
- "station.release-management.how_it_works": "Määrittele rajapintojen versiointistrategiat muutosten hallitsemiseksi ja taaksepäin yhteensopivuuden varmistamiseksi.",
- "station.service-agreements.title": "Palvelusopimukset - määrittele API-palvelutasot",
- "station.service-agreements.description": "Laadi palvelusopimukset, joissa määritellään API-toimittajien ja kuluttajien odotukset, palvelutasot ja vastuut.",
- "station.service-agreements.why_it_matters": "Palvelusopimukset ovat olennaisen tärkeitä, jotta voidaan varmistaa selkeys ja yhdenmukaisuus API-toimittajien ja kuluttajien välillä. Tämä asema tarjoaa ohjeita sellaisten palvelusopimusten laatimiseen, joissa hahmotellaan odotukset, palvelutasot ja vastuut, mikä vähentää väärinkäsityksiä ja riitoja.",
- "station.service-agreements.apply_in_work": "Tarjotaan palvelusopimusmalleja, standardoituja muotoja ja tarkistusprosesseja. Varmistetaan, että tiimit luovat selkeät ja tarkkaan määritellyt palvelusopimukset, joissa hahmotellaan API-toimittajien ja -kuluttajien odotukset, palvelutasot ja vastuut.",
- "station.service-agreements.outcomes": "Kullekin rajapinnalle määritellyt selkeät palvelusopimukset",
- "station.service-agreements.how_it_works": "Määrittele palvelusopimukset, joissa hahmotellaan odotukset, palvelutasot ja vastuualueet kutakin rajapintaa varten.",
- "station.api-consumer-adoption.title": "APIn käyttöönotto - APIn käytön edistäminen",
- "station.api-consumer-adoption.description": "Toteutat strategioita, joilla edistetään API-käyttäjien hyväksyntää ja sitoutumista ja varmistetaan, että API-rajapintoja käytetään tehokkaasti.",
- "station.api-consumer-adoption.why_it_matters": "API-käyttäjien hyväksynnän edistäminen on ratkaisevan tärkeää APIen arvon hyödyntämiseksi. Tämä asema tarjoaa strategioita ja parhaita käytäntöjä API-kuluttajien sitouttamiseksi ja sen varmistamiseksi, että he ymmärtävät, miten API-rajapintoja käytetään tehokkaasti ja miten niistä saadaan arvoa.",
- "station.api-consumer-adoption.apply_in_work": "Tarjotaan API-kuluttajille resursseja, koulutusmateriaalia ja sitouttamisstrategioita. Varmistetaan, että tiimit toteuttavat strategioita, jotka edistävät API-kuluttajien hyväksyntää, sitoutumista ja tyytyväisyyttä.",
- "station.api-consumer-adoption.outcomes": "APIn käyttöönottostrategioiden toteuttaminen kuluttajille",
- "station.api-consumer-adoption.how_it_works": "Kehitetään käyttöönottoprosesseja ja resursseja, joiden avulla API-käyttäjät ymmärtävät, miten Rajapintoja käytetään tehokkaasti.",
- "station.api-promotion.title": "API-näkyvyys - APIn näkyvyyden ja käytön lisääminen",
- "station.api-promotion.description": "Edistetään rajapintoja näkyvyyden, käytön ja hyväksynnän lisäämiseksi kohdeyleisöjen keskuudessa.",
- "station.api-promotion.why_it_matters": "API-rajapintojen tunnetuksi tekeminen on olennaisen tärkeää niiden näkyvyyden lisäämiseksi ja käytön edistämiseksi. Tämä asema tarjoaa strategioita ja parhaita käytäntöjä APIen tehokkaaseen markkinointiin kohdeyleisöille, jotta varmistetaan, että nämä ovat tietoisia APIista ja ymmärtävät niiden arvon.",
- "station.api-promotion.apply_in_work": "Tarjotaan markkinointistrategioita, myynninedistämismateriaalia ja resursseja yhteisön sitouttamiseen. Varmistaa, että tiimit toteuttavat tehokkaita APIn edistämisstrategioita, jotka lisäävät näkyvyyttä, käyttöä ja käyttöönottoa kohdeyleisöjen keskuudessa.",
- "station.api-promotion.outcomes": "Toteutetut API-edistämisstrategiat",
- "station.api-promotion.how_it_works": "Kehitä markkinointistrategioita APIen markkinoimiseksi kohdeyleisöille, mukaan lukien sosiaalinen media, blogit ja webinaarit.",
- "station.partner-integration.title": "Kumppanien integrointi - Tee yhteistyötä kumppaneiden kanssa",
- "station.partner-integration.description": "Helpota kumppani-integraatioita API-ominaisuuksien parantamiseksi ja tavoittavuuden laajentamiseksi.",
- "station.partner-integration.why_it_matters": "Kumppani-integraatiot voivat parantaa API-ominaisuuksia ja laajentaa tavoitettavuutta. Tämä asema tarjoaa ohjeita kumppanien kanssa tehtävään yhteistyöhön niiden rajapintojen integroimiseksi, jotta varmistetaan saumaton yhteentoimivuus ja arvon luominen.",
- "station.partner-integration.apply_in_work": "Tarjotaan kumppaneiden integrointikehykset, ohjeet ja seurantatyökalut. Varmistaa, että tiimit tekevät tehokasta yhteistyötä kumppaneiden kanssa API-ominaisuuksien parantamiseksi, ulottuvuuden laajentamiseksi ja innovoinnin edistämiseksi.",
- "station.partner-integration.outcomes": "Kumppaneiden integrointiprosessit on luotu",
- "station.partner-integration.how_it_works": "Tunnista mahdolliset kumppanit, joiden APIt voivat parantaa API-valmiuksiasi ja arvolupaustasi.",
- "station.api-mindset.title": "API-ajattelutapa - API-first -kulttuurin edistäminen",
- "station.api-mindset.description": "Kehitä API-first -ajattelutapaa koko organisaatiossa innovoinnin ja yhteistyön edistämiseksi.",
- "station.api-mindset.why_it_matters": "API-first -ajattelutapa on olennaisen tärkeä innovoinnin ja yhteistyön edistämiseksi koko organisaatiossa. Tämä asema tarjoaa strategioita API-first -kulttuurin kehittämiseksi ja sen varmistamiseksi, että rajapinnat nähdään strategisina voimavaroina, jotka tuottavat liiketoiminta-arvoa.",
- "station.api-mindset.apply_in_work": "Tarjotaan koulutusohjelmia, resursseja ja viestintästrategioita API-first -kulttuurin edistämiseksi. Varmistetaan, että tiimit ymmärtävät APIen arvon ja että niillä on valtuudet johtaa API-strategiaa ja -aloitteita.",
- "station.api-mindset.outcomes": "API-first -kulttuuri on vakiintunut koko organisaatioon",
- "station.api-mindset.how_it_works": "Edistetään rajapintojen arvoa strategisina voimavaroina, jotka lisäävät liiketoiminnan arvoa ja innovointia.",
- "station.roles-and-responsibilities.title": "Roolit ja vastuualueet - API-tiimien rakenteiden määrittelyt",
- "station.roles-and-responsibilities.description": "Määrittele API-tiimeille selkeät roolit ja vastuualueet tehokkaan yhteistyön ja vastuuvelvollisuuden varmistamiseksi.",
- "station.roles-and-responsibilities.why_it_matters": "Selkeät roolit ja vastuualueet ovat olennaisen tärkeitä tehokkaan yhteistyön ja vastuuvelvollisuuden kannalta API-tiimeissä. Tämä asema tarjoaa ohjeita tiimirakenteiden, roolien ja vastuualueiden määrittelyyn ja varmistaa, että kaikki ymmärtävät oman panoksensa API-aloitteisiin.",
- "station.roles-and-responsibilities.apply_in_work": "Tarjotaan tiimirakenneohjeet, roolimäärittelyt ja viestintästrategiat. Varmistetaan, että tiimeillä on selkeät roolit ja vastuut, jotka edistävät tehokasta yhteistyötä ja vastuullisuutta API-aloitteissa.",
- "station.roles-and-responsibilities.outcomes": "API-tiimeille on määritelty selkeät roolit ja vastuut",
- "station.roles-and-responsibilities.how_it_works": "Määrittele API-tiimien tiimirakenteet ja roolit, mukaan lukien API-tuotteen omistajat, kehittäjät, arkkitehdit ja toiminnot.",
- "station.upskilling.title": "Osaamisen kehittäminen - API-taitojen ja -tiedon parantaminen",
- "station.upskilling.description": "Tarjotaan koulutusta ja resursseja API-taitojen ja -tiedon parantamiseksi koko organisaatiossa.",
- "station.upskilling.why_it_matters": "Jatkuva oppiminen ja täydennyskoulutus ovat olennaisen tärkeitä, jotta API-tiimit pysyvät ajan tasalla uusimmista teknologioista, käytännöistä ja suuntauksista. Tämä asema tarjoaa koulutusohjelmia ja resursseja API-taitojen ja -tiedon parantamiseen, jotta tiimit ovat valmiita toimittamaan korkealaatuisia API-rajapintoja.",
- "station.upskilling.apply_in_work": "Tarjotaan koulutusohjelmia, resursseja ja arviointivälineitä API-taitojen ja -tietojen parantamiseksi. Varmistetaan, että tiimeillä on mahdollisuus jatkuvaan oppimiseen, joka antaa heille mahdollisuuden edistää API-innovaatioita ja laatua.",
- "station.upskilling.outcomes": "API-taitojen ja -tiedon parantaminen koko organisaatiossa",
- "station.upskilling.how_it_works": "Tunnistetaan keskeiset API-taidot ja -tiedot, joita on kehitettävä, kuten API-suunnittelu, tietoturva ja suorituskyky.",
- "station.operating-guidelines.title": "Toimintaohjeet - API-hallinnon perustaminen",
- "station.operating-guidelines.description": "Laaditaan toimintaohjeet ja hallintokäytännöt, joilla varmistetaan APIn johdonmukainen hallinta ja laatu.",
- "station.operating-guidelines.why_it_matters": "Tehokas API-hallinta on olennaisen tärkeää, jotta voidaan varmistaa yhdenmukainen API-hallinta, laatu ja vaatimustenmukaisuus. Tämä asema tarjoaa toimintaohjeita ja hallintakäytäntöjä, jotka auttavat tiimejä hallinnoimaan API-rajapintoja tehokkaasti ja varmistamaan, että ne ovat organisaation standardien ja parhaiden käytäntöjen mukaisia.",
- "station.operating-guidelines.apply_in_work": "Toimintaohjeiden, hallintakehysten ja seurantatyökalujen tarjoaminen API-hallintaa varten. Varmistaa, että tiimit noudattavat vakiintuneita käytäntöjä, jotka edistävät johdonmukaista API-hallintaa, laatua ja organisaation standardien noudattamista.",
- "station.operating-guidelines.outcomes": "APIn hallintokäytännöt on vahvistettu",
- "station.operating-guidelines.how_it_works": "Määrittele APIOps Cyclesiin perustuvat toimintaohjeet, joissa hahmotellaan API-hallinnan prosessit, standardit ja parhaat käytännöt.",
- "station.portfolio-management.title": "Portfolionhallinta - hallinnoi API-portfoliota tehokkaasti",
- "station.portfolio-management.description": "Hallinnoida API-salkkua tehokkaasti varmistaaksesi, että se on linjassa liiketoiminnan tavoitteiden ja strategisten aloitteiden kanssa.",
- "station.portfolio-management.why_it_matters": "Tehokas rajapintasalkun hallinta on olennaisen tärkeää sen varmistamiseksi, että rajapinnat ovat linjassa liiketoiminnan tavoitteiden ja strategisten aloitteiden kanssa. Tämä asema tarjoaa ohjeita API-salkun hallintaan ja varmistaa, että APIt priorisoidaan, seurataan ja optimoidaan siten, että ne tuottavat mahdollisimman paljon arvoa.",
- "station.portfolio-management.apply_in_work": "Tarjotaan salkunhallintakehykset, priorisointikriteerit ja seurantatyökalut API-hallintaa varten. Varmistaa, että tiimit hallinnoivat API-salkkua tehokkaasti ja varmistavat, että se on linjassa liiketoimintatavoitteiden ja strategisten aloitteiden kanssa ja tuottaa mahdollisimman paljon arvoa.",
- "station.portfolio-management.outcomes": "API-salkunhallintakäytäntöjen käyttöönotto",
- "station.portfolio-management.how_it_works": "Määrittele salkunhallintakäytännöt, joissa hahmotellaan API-salkun hallinnointiprosessit, mukaan lukien priorisointi, seuranta ja optimointi.",
- "station.budget-and-resource-management.title": "Budjetin ja resurssien hallinta - Optimoi API-investoinnit",
- "station.budget-and-resource-management.description": "Optimoi API-aloitteiden budjetin ja resurssien hallinta tehokkaiden investointien ja resurssien kohdentamisen varmistamiseksi.",
- "station.budget-and-resource-management.why_it_matters": "Tehokas talousarvio- ja resurssienhallinta on olennaisen tärkeää, jotta voidaan varmistaa, että API-aloitteet ovat hyvin rahoitettuja ja resursoituja. Tämä asema tarjoaa ohjeita budjetin ja resurssien hallinnan optimoimiseksi ja sen varmistamiseksi, että API-aloitteet ovat linjassa liiketoimintatavoitteiden kanssa ja tuottavat maksimaalista arvoa.",
- "station.budget-and-resource-management.apply_in_work": "Tarjotaan API-aloitteille budjettihallintakehykset, priorisointikriteerit ja seurantatyökalut. Varmistaa, että tiimit hallinnoivat tehokkaasti budjetteja ja resursseja ja optimoivat API-kehitykseen ja -hallintaan tehdyt investoinnit mahdollisimman suuren arvon tuottamiseksi.",
- "station.budget-and-resource-management.outcomes": "API-aloitteita varten laaditut budjetti- ja resurssienhallintakäytännöt",
- "station.budget-and-resource-management.how_it_works": "Määrittele budjetti- ja resurssienhallintakäytännöt, joissa hahmotellaan API-aloitteiden budjettien ja resurssien hallinnointiprosessit.",
- "station.api-product-strategy.outcomes.1": "Yhteinen kieli tuotteen, suunnittelun ja tekniikan välillä",
- "station.api-product-strategy.outcomes.2": "vankka esitys tai peruste rahoituksen/hyväksynnän saamiseksi.",
- "station.api-product-strategy.how_it_works.1": "Määrittele keskeiset entiteetit, niiden ominaisuudet ja suhteet, jotta voidaan luoda yhteinen käsitteellinen ymmärrys eri matkojen ja lopulta APIen välille.",
- "station.api-product-strategy.how_it_works.2": "Käytä API Value Proposition Canvas -pohjaa tallentaaksesi tuetut liiketoimintatehtävät sekä API-käyttäjien ongelmat, hyödyt ja ominaisuudet, jotka muovaavat uusia tai uudelleenkäytettäviä API-rajapintoja.",
- "station.api-product-strategy.how_it_works.3": "Määrittele arvo - käyttäjille ja liiketoiminnalle - API-liiketoimintamallin avulla, jotta API-strategiastasi tulee visuaalinen, jaettavissa oleva ja helposti validoitava API-asiakkaiden kanssa seuraavalla asemalla.",
- "station.api-consumer-experience.outcomes.1": "Määrittele API-kokemuksen matka",
- "station.api-consumer-experience.outcomes.2": "Suunnittele sisäänajo, dokumentointi ja palaute",
- "station.api-consumer-experience.outcomes.3": "Paranna hyväksyntää aidon empatian ja kehittäjäkokemuksen (DX) avulla.",
- "station.api-platform-architecture.outcomes.1": "Johdonmukaisen hallinnon toteuttaminen ilman raskasta ylhäältä alaspäin suuntautuvaa valvontaa",
- "station.api-platform-architecture.outcomes.2": "Suunnittelu sisäistä uudelleenkäyttöä ja ulkoista skaalautuvuutta varten",
- "station.api-platform-architecture.how_it_works.1": "Kartoita API-palveluntarjoajien ja kuluttajien sääntely-, vaatimustenmukaisuus- ja verkkoasiointipaikat käytettävyyden ja vaatimustenmukaisuuden varmistamiseksi.",
- "station.api-platform-architecture.how_it_works.2": "Capacity Canvas -ohjelmassa sovitetaan yhteen liiketoimintatapahtumien mallit, tulevat kulutustrendit ja tekniset ratkaisut, jotta voidaan varmistaa APIn skaalautuvuus ja suorituskyky. Se tarjoaa kriittisen panoksen skaalautumispäätöksiä ja infrastruktuurin suunnittelua varten.",
- "station.api-platform-architecture.how_it_works.3": "Määrittele ja seuraa suorituskykymittareita (esim. API-kutsut, viiveet, virhetasot) ja hyväksyntämittareita (esim. NPS).",
- "station.api-design.outcomes.1": "Uudelleenkäytettävät ja validoidut API-sopimukset",
- "station.api-design.outcomes.2": "Toimialamallien ja vuorovaikutusmallien mukaiset mallit",
- "station.api-design.outcomes.3": "Suunnittelun jäljitettävyys liiketoiminnan arvoon",
- "station.api-design.how_it_works.1": "Määrittele Interaction Canvasin avulla, miten hyödyntäjät ovat vuorovaikutuksessa APIn kanssa, ja Varmistetaan, että se vastaa heidän tarpeitaan ja odotuksiaan.",
- "station.api-design.how_it_works.2": "Sovellat REST-suunnittelumalleja luodaksesi johdonmukaisia, uudelleenkäytettäviä API-sopimuksia, jotka validoidaan sidosryhmien kanssa.",
- "station.api-design.how_it_works.3": "Sovellat tapahtumapohjaisia suunnittelumalleja luodaksesi johdonmukaisia, uudelleenkäytettäviä API-sopimuksia, jotka validoidaan sidosryhmien kanssa.",
- "station.api-design.how_it_works.4": "Sovellat GraphQL-suunnittelumalleja luodaksesi johdonmukaisia, uudelleenkäytettäviä API-sopimuksia, jotka validoidaan sidosryhmien kanssa.",
- "station.api-design.how_it_works.5": "Käytä suunnitteluperiaatteita ja API-tyyliohjetta, jotta suunnittelupäätöksesi ovat linjassa yhteisten sääntöjen kanssa ja mahdollistavat johdonmukaisen auditoinnin ja validoinnin.",
- "station.api-design.how_it_works.6": "Varmistetaan API-auditoinnin tarkistuslistan avulla, että API-suunnittelu täyttää toiminnalliset ja muut kuin toiminnalliset vaatimukset, mukaan lukien tietoturva, suorituskyky ja vaatimustenmukaisuus.",
- "station.api-design.how_it_works.7": "Käytä API-tarkastuslistaa varmistaaksesi, että API-suunnittelu täyttää toiminnalliset ja ei-toiminnalliset vaatimukset, mukaan lukien turvallisuus, suorituskyky ja vaatimustenmukaisuus.",
- "station.api-delivery.outcomes.1": "Luotettavat ja automatisoidut CI/CD-putket",
- "station.api-delivery.outcomes.2": "Toiminnallinen ja ei-toiminnallinen testaus integroitu",
- "station.api-delivery.outcomes.3": "Turvalliset ja vaatimustenmukaiset kehitysputket",
- "station.api-delivery.how_it_works.1": "Rakenna API-toteutus validoidun sopimuksen pohjalta käyttäen vakiintuneita kehysrakenteita, kirjastoja ja tiimin standardeja.",
- "station.api-delivery.how_it_works.2": "Testaa rajapintojen toimivuutta, turvallisuutta ja suorituskykyä automaattisten testausvälineiden avulla.",
- "station.api-delivery.how_it_works.3": "Käytetään CI/CD-putkia rakentamis-, testaus- ja käyttöönottoprosessien automatisoimiseksi varmistaen johdonmukaisen laadun ja jäljitettävyyden.",
- "station.api-delivery.how_it_works.4": "Varmistetaan, että rajapinnat täyttävät turvallisuus- ja vaatimustenmukaisuusvaatimukset automaattisten tarkastusten ja auditointien avulla.",
- "station.api-delivery.how_it_works.5": "Varmistetaan API-auditoinnin tarkistuslistan avulla, että API täyttää toiminnalliset ja muut kuin toiminnalliset vaatimukset, mukaan lukien tietoturva, suorituskyky ja vaatimustenmukaisuus.",
- "station.api-audit.outcomes.1": "Selkeä dokumentaatio API-suunnittelusta ja toteutuspäätöksistä",
- "station.api-audit.outcomes.2": "Turvallisuus, suorituskyky ja vaatimustenmukaisuus validoitu",
- "station.api-audit.outcomes.3": "Tuotannossa ilmenevien ongelmien riskin pienentäminen",
- "station.api-audit.how_it_works.1": "Käytä tarkistuslistoja, automatisoituja tarkistustyökaluja eli linttereitä ja testausvälineitä varmistaaksesi johdonmukaisuuden ja standardien noudattamisen.",
- "station.api-audit.how_it_works.2": "Tee yhteistyötä hallintotiimien ja toimialan asiantuntijoiden kanssa varmistaaksesi, että rajapinnat ovat valmiita tuotantoon.",
- "station.api-publishing.outcomes.1": "Selkeät API-käyttöönotto- ja rekisteröintiprosessit",
- "station.api-publishing.outcomes.2": "Dokumentaatio, turvallisuusmallit ja -käytännöt saatavilla",
- "station.api-publishing.outcomes.3": "APIt valmiina skaalautumiseen ja hallintaan",
- "station.api-publishing.how_it_works.1": "Dokumentoi, miten hyödyntäjät löytävät ja käyttävät rajapintaa, mukaan lukien sisäänkirjautumisprosessit ja rekisteröinti.",
- "station.api-publishing.how_it_works.2": "Varmistetaan, että turvamallit, yhdyskäytävän kokoonpano ja oikeudelliset ehdot ovat selkeitä ja kuluttajien saatavilla.",
- "station.monitoring-and-improving.outcomes.1": "Kehittäjien palautekierrokset käytössä",
- "station.monitoring-and-improving.outcomes.2": "Jatkuvasti tunnistetut ja käsitellyt ongelmat",
- "station.monitoring-and-improving.outcomes.3": "APIn iterointi käyttäjien tarpeiden mukaisesti",
- "station.monitoring-and-improving.how_it_works.1": "Analysoi APIn käyttömittareita ja ota käyttäjien palaute huomioon API-iteraatioissa.",
- "station.monitoring-and-improving.how_it_works.2": "Ota tavaksi tarkastella mittareita ja suunnitella jatkuvan parantamisen toimia.",
- "station.user-experience.outcomes.1": "Intuitiiviset ja johdonmukaiset käyttöliittymät",
- "station.user-experience.outcomes.2": "Käyttäjien palaute sisällytetty APIn suunnitteluun",
- "station.user-experience.outcomes.3": "Parempi käyttäjätyytyväisyys ja hyväksyntä",
- "station.user-experience.how_it_works.1": "Suorita käyttäjätutkimus kerätäksesi tietoa siitä, miten hyödyntäjät ovat vuorovaikutuksessa ekosysteemipalveluiden tai API-sovelluksia käyttävien sovellusten kanssa.",
- "station.user-experience.how_it_works.2": "Dokumentoi käyttäjäkokemusta koskevat vaatimukset, jotta niitä voidaan käyttää API-suunnittelussa ja varmistaa, että ne ovat intuitiivisia ja helppokäyttöisiä.",
- "station.market-insights.outcomes.1": "Määritetyt alan standardit ja parhaat käytännöt",
- "station.market-insights.outcomes.2": "API-strategia linjassa markkinoiden tarpeiden kanssa",
- "station.market-insights.outcomes.3": "Markkinatietoon perustuva tietoon perustuva päätöksenteko",
- "station.market-insights.how_it_works.1": "Analysoi kilpailijoiden rajapinnat ymmärtämään niiden vahvuudet, heikkoudet ja ainutlaatuiset myyntivaltit.",
- "station.market-insights.how_it_works.2": "Tunnistetaan alan standardit ja parhaat käytännöt, jotta voidaan varmistaa, että rajapinnat ovat kilpailukykyisiä ja yhteensopivia.",
- "station.business-goals.outcomes.1": "Kullekin Rajapinnalle määritelty selkeä liiketoiminta-arvo",
- "station.business-goals.outcomes.2": "Sidosryhmien sitoutuminen ja tuki API-aloitteille",
- "station.business-goals.outcomes.3": "APIt edistävät organisaation menestystä",
- "station.business-goals.how_it_works.1": "Määritä keskeiset suorituskykyindikaattorit (KPI), joilla mitataan APIn onnistumista suhteessa liiketoiminnan tavoitteisiin.",
- "station.business-goals.how_it_works.2": "Sidosryhmien sitouttaminen varmistamaan API-aloitteiden yhdenmukaisuus ja tuki.",
- "station.competitive-analysis.outcomes.1": "Eriyttämismahdollisuudet tunnistettu",
- "station.competitive-analysis.outcomes.2": "API-strategia, joka perustuu kilpailutietoon",
- "station.competitive-analysis.outcomes.3": "Lisääntynyt kilpailukyky API-markkinoilla",
- "station.competitive-analysis.how_it_works.1": "Tunnista markkinapuutteet, jotka rajapintasi voivat täyttää kilpailijoiden tarjonnan perusteella.",
- "station.competitive-analysis.how_it_works.2": "Kehitä erottautumisstrategia, jossa korostetaan rajapintojesi ainutlaatuisia ominaisuuksia ja etuja.",
- "station.ecosystem-vision.outcomes.1": "APIt, jotka on suunniteltu mahdollistamaan yhteistyö ja integrointi",
- "station.ecosystem-vision.outcomes.2": "Ekosysteemikumppanit tunnistetaan ja otetaan mukaan",
- "station.ecosystem-vision.outcomes.3": "APIt edistävät elinvoimaista ekosysteemiä",
- "station.ecosystem-vision.how_it_works.1": "Tunnistetaan tärkeimmät ekosysteemikumppanit ja sidosryhmät, jotka hyötyvät ekosysteemistä tai osallistuvat siihen.",
- "station.ecosystem-vision.how_it_works.2": "Suunnittele rajapinnat, jotka mahdollistavat saumattoman integroinnin ja yhteistyön ekosysteemissä.",
- "station.scalable-infrastructure.outcomes.1": "Korkea käytettävyys ja suorituskyky kuormitettuna",
- "station.scalable-infrastructure.outcomes.2": "Tulevaa kasvua varten suunniteltu infrastruktuuri",
- "station.scalable-infrastructure.outcomes.3": "Vähentää käyttökatkoksia ja parantaa käyttäjäkokemusta",
- "station.scalable-infrastructure.how_it_works.1": "Toteuta kuorman tasapainottaminen, välimuistitallennus ja muut tekniikat korkean käytettävyyden ja suorituskyvyn varmistamiseksi. Kerää infrastruktuurivaatimukset API-tiimeiltä Capacity Canvasin avulla.",
- "station.scalable-infrastructure.how_it_works.2": "Seuraa infrastruktuurin suorituskykyä ja kapasiteettia sen varmistamiseksi, että se pystyy vastaamaan kasvavaan kysyntään.",
- "station.legal-and-compliance.outcomes.1": "Tietosuojaa ja yksityisyyden suojaa koskevat vaatimukset täyttyvät",
- "station.legal-and-compliance.outcomes.2": "Oikeudellisten riskien tunnistaminen ja lieventäminen",
- "station.legal-and-compliance.outcomes.3": "Vaatimustenmukaisuustoimenpiteiden selkeä dokumentointi",
- "station.legal-and-compliance.how_it_works.1": "Toteuta toimenpiteitä, joilla varmistetaan, että rajapinnat täyttävät nämä vaatimukset, mukaan lukien tietojen salaus, käyttöoikeuksien valvonta ja kirjausketjut.",
- "station.legal-and-compliance.how_it_works.2": "dokumentoida vaatimustenmukaisuustoimenpiteet ja varmistaa, että niistä tiedotetaan sidosryhmille ja kuluttajille.",
- "station.security-and-privacy.outcomes.1": "Käyttäjätiedot suojattu yksityisyydensuojatoimenpiteiden avulla",
- "station.security-and-privacy.outcomes.2": "Parhaat turvallisuuskäytännöt API-suunnittelussa ja -kehityksessä",
- "station.security-and-privacy.outcomes.3": "Turvallisuusstandardien ja -säännösten noudattaminen",
- "station.security-and-privacy.how_it_works.1": "Varmistetaan käyttäjien tietojen yksityisyys toteuttamalla tietosuojatoimenpiteitä, kuten anonymisointi ja käyttöoikeuksien valvonta.",
- "station.security-and-privacy.how_it_works.2": "Suorittaa säännöllisiä tietoturvatarkastuksia ja haavoittuvuusarviointeja riskien tunnistamiseksi ja vähentämiseksi.",
- "station.design-standards.outcomes.1": "Laadukkaat APIt, jotka vastaavat käyttäjien tarpeita",
- "station.design-standards.outcomes.2": "Uudelleenkäytettävät suunnittelumallit ja komponentit",
- "station.design-standards.outcomes.3": "Vähennetään suunnittelun epäjohdonmukaisuuksia ja teknistä velkaa.",
- "station.design-standards.how_it_works.1": "Luo uudelleenkäytettäviä suunnittelumalleja ja -komponentteja, joita tiimit voivat hyödyntää yhdenmukaisuuden ja laadun varmistamiseksi.",
- "station.design-standards.how_it_works.2": "Suoritat suunnittelun tarkastuksia ja auditointeja varmistaaksesi suunnittelustandardien noudattamisen ja yksilöidäksesi parannuskohteet.",
- "station.vendor-management.outcomes.1": "Kolmannen osapuolen APIt integroituvat luotettavasti ja turvallisesti.",
- "station.vendor-management.outcomes.2": "Myyjä noudattaa organisaation standardeja",
- "station.vendor-management.outcomes.3": "Kolmannen osapuolen riippuvuuksiin liittyvien riskien vähentäminen",
- "station.vendor-management.how_it_works.1": "Määrittele kriteerit toimittajien rajapintojen arviointia varten, mukaan lukien luotettavuus, turvallisuus ja vaatimustenmukaisuus.",
- "station.vendor-management.how_it_works.2": "Seuraa toimittajien suorituskykyä ja palvelutasosopimusten (SLA) ja organisaation standardien noudattamista.",
- "station.contract-design.outcomes.1": "API-toimittajien ja kuluttajien odotukset ja vastuut hahmoteltuina",
- "station.contract-design.outcomes.2": "Käyttöohjeet ja parhaat käytännöt dokumentoitu",
- "station.contract-design.outcomes.3": "APIn käyttöä koskevien väärinkäsitysten ja riitojen väheneminen.",
- "station.contract-design.how_it_works.1": "Käytä standardoituja formaatteja (esim. OpenAPI, AsyncAPI) luodaksesi koneellisesti luettavia API-sopimuksia, joita on helppo jakaa ja validoida.",
- "station.contract-design.how_it_works.2": "Varmistetaan, että sidosryhmät tarkistavat ja hyväksyvät API-sopimukset, jotta varmistetaan niiden yhdenmukaisuus ja selkeys.",
- "station.development.outcomes.1": "Laadukkaat, ylläpidettävät ja skaalautuvat rajapinnat.",
- "station.development.outcomes.2": "Johdonmukaiset koodausstandardit ja -käytännöt",
- "station.development.outcomes.3": "Vähentää kehitysaikaa ja teknistä velkaa",
- "station.development.how_it_works.1": "Sovellat sopimuslähtöisiä tai suunnittelulähtöisiä lähestymistapoja varmistaaksesi, että API-sopimukset validoidaan ennen toteutusta.",
- "station.development.how_it_works.2": "Noudata koodausstandardeja ja parhaita käytäntöjä varmistaaksesi johdonmukaisen ja laadukkaan API-kehityksen.",
- "station.ci-cd.outcomes.1": "API-kehityksen tasainen laatu ja jäljitettävyys",
- "station.ci-cd.outcomes.2": "Nopeammat iteraatiot ja lyhyempi aika markkinoille saattamiseen",
- "station.ci-cd.outcomes.3": "Parempi yhteistyö ja palautekierrokset API-kehityksessä",
- "station.ci-cd.how_it_works.1": "Integroi toiminnallinen ja ei-toiminnallinen testaus CI/CD-putkeen varmistaaksesi, että rajapinnat täyttävät laatuvaatimukset.",
- "station.ci-cd.how_it_works.2": "Toteuta automaattiset tietoturvatarkastukset ja vaatimustenmukaisuuden validoinnit CI/CD-putkessa varmistaaksesi, että rajapinnat ovat turvallisia ja vaatimustenmukaisia.",
- "station.test-automation.outcomes.1": "Automaattiset toiminnalliset, turvallisuus- ja suorituskykytestit",
- "station.test-automation.outcomes.2": "Vähentää manuaalisen testauksen työmäärää ja lisää testien kattavuutta",
- "station.test-automation.outcomes.3": "APIn luotettavuuden ja laadun parantaminen",
- "station.test-automation.how_it_works.1": "Toteuta testiautomaatiokehykset, jotka tukevat sopimustestausta, integrointitestausta ja päästä päähän -testausta.",
- "station.test-automation.how_it_works.2": "Integroi automatisoidut testit CI/CD-putkeen API-laadun jatkuvan validoinnin varmistamiseksi.",
- "station.release-management.outcomes.1": "Versiointi- ja käyttöönottostrategioiden määrittely",
- "station.release-management.outcomes.2": "API-julkaisuja varten vahvistetut palautusmenettelyt",
- "station.release-management.outcomes.3": "API-muutoksiin liittyvien riskien vähentäminen",
- "station.release-management.how_it_works.1": "Ota käyttöön käyttöönottostrategioita (esim. sinivihreät käyttöönotot, canary releaset) API-julkaisuihin liittyvien riskien minimoimiseksi.",
- "station.release-management.how_it_works.2": "Ota käyttöön palautusmenettelyt, jotta muutokset voidaan palauttaa nopeasti, jos API-julkaisujen aikana ilmenee ongelmia.",
- "station.service-agreements.outcomes.1": "API-toimittajien ja kuluttajien odotukset ja palvelutasot hahmoteltuina",
- "station.service-agreements.outcomes.2": "Dokumentoidut vastuualueet ja tukiprosessit",
- "station.service-agreements.outcomes.3": "Parempi viestintä ja yhteistyö API-tiimien välillä",
- "station.service-agreements.how_it_works.1": "Luo koneellisesti luettavia palvelusopimuksia, joita on helppo jakaa ja validoida, käyttämällä standardoituja muotoja.",
- "station.service-agreements.how_it_works.2": "Varmistetaan, että sidosryhmät tarkistavat ja hyväksyvät palvelusopimukset, jotta varmistetaan niiden yhdenmukaisuus ja selkeys.",
- "station.api-consumer-adoption.outcomes.1": "APIn käytön ja sitoutumisen lisääminen",
- "station.api-consumer-adoption.outcomes.2": "APIn hyödyntäjät saavat tietoa APIn ominaisuuksista ja hyödyistä",
- "station.api-consumer-adoption.outcomes.3": "Parempi API-hyödyntäjätyytyväisyys ja -uskollisuus",
- "station.api-consumer-adoption.how_it_works.1": "Luo opetusmateriaalia (esim. opetusohjelmia, dokumentaatiota), jossa selitetään APIn ominaisuuksia, hyötyjä ja käyttötapoja.",
- "station.api-consumer-adoption.how_it_works.2": "Kytkeydy API-käyttäjiin palautekierrosten, tukikanavien ja yhteisöfoorumien kautta ymmärtämään heidän tarpeitaan ja parantamaan APIn käyttöönottoa.",
- "station.api-promotion.outcomes.1": "APIn näkyvyyden ja tietoisuuden lisääminen",
- "station.api-promotion.outcomes.2": "Korkeampi APIn käyttö- ja hyväksymisaste",
- "station.api-promotion.outcomes.3": "Parempi API-kuluttajien sitoutuminen ja tyytyväisyys",
- "station.api-promotion.how_it_works.1": "Luo myynninedistämismateriaalia (esim. tapaustutkimuksia, menestystarinoita), jossa korostetaan rajapintojen arvoa ja hyötyjä.",
- "station.api-promotion.how_it_works.2": "Osallistu API-yhteisöihin ja -foorumeihin API-päivitysten jakamiseksi, palautteen keräämiseksi ja APIn käytön edistämiseksi.",
- "station.partner-integration.outcomes.1": "Parannetut API-ominaisuudet kumppani-APIen avulla",
- "station.partner-integration.outcomes.2": "Kumppanuuksien avulla laajennettu ulottuvuus ja markkinamahdollisuudet",
- "station.partner-integration.outcomes.3": "Parempi yhteistyö ja innovointi kumppaneiden kanssa",
- "station.partner-integration.how_it_works.1": "Luodaan integraatioprosessit ja -ohjeet yhteistyökumppaneiden kanssa tehtävää yhteistyötä varten, mukaan lukien tekninen integraatio, tietojen jakaminen ja tuki.",
- "station.partner-integration.how_it_works.2": "Seuraa kumppaneiden API-suorituskykyä ja vaatimustenmukaisuutta varmistaaksesi luotettavuuden ja yhteensopivuuden API-strategiasi kanssa.",
- "station.api-mindset.outcomes.1": "Innovaation ja yhteistyön lisääminen rajapintojen avulla",
- "station.api-mindset.outcomes.2": "API-tiimit, joilla on valtuudet johtaa API-strategiaa ja -aloitteita.",
- "station.api-mindset.outcomes.3": "Liiketoiminnan tavoitteiden ja API-kehityksen parempi yhteensovittaminen.",
- "station.api-mindset.how_it_works.1": "Kannustaa API-tiimien, liiketoimintayksiköiden ja sidosryhmien välistä monialaista yhteistyötä, jotta API-aloitteet voidaan sovittaa yhteen liiketoiminnan tavoitteiden kanssa.",
- "station.api-mindset.how_it_works.2": "Tarjotaan koulutusta ja resursseja, jotta tiimit voivat omaksua API-first -ajattelutavan ja ymmärtää APIen edut.",
- "station.roles-and-responsibilities.outcomes.1": "Tehokas yhteistyö ja vastuuvelvollisuus API-tiimeissä",
- "station.roles-and-responsibilities.outcomes.2": "Parempi viestintä ja yhdenmukaistaminen tiimin jäsenten välillä",
- "station.roles-and-responsibilities.outcomes.3": "Sekaannusten ja päällekkäisyyksien vähentäminen vastuualueilla",
- "station.roles-and-responsibilities.how_it_works.1": "Määritä selkeät vastuualueet kullekin roolille, mukaan lukien API-suunnittelu, kehittäminen, testaus ja toiminta.",
- "station.roles-and-responsibilities.how_it_works.2": "Varmistaa, että roolit ja vastuualueet ilmoitetaan kaikille tiimin jäsenille ja sidosryhmille, jotta varmistetaan niiden yhdenmukaisuus.",
- "station.upskilling.outcomes.1": "API-suunnittelun, -kehityksen ja -hallinnan lisääntynyt osaaminen.",
- "station.upskilling.outcomes.2": "Parempi kyky omaksua uutta teknologiaa ja uusia käytäntöjä",
- "station.upskilling.outcomes.3": "Valtuutetaan tiimit edistämään API-innovaatioita ja laatua.",
- "station.upskilling.how_it_works.1": "Tarjotaan koulutusohjelmia, työpajoja ja resursseja, joiden avulla tiimit voivat parantaa API-taitojaan ja -tietämystään.",
- "station.upskilling.how_it_works.2": "Kannustetaan jatkuvaan oppimiseen verkkokurssien, sertifikaattien ja yhteisöllisen sitoutumisen avulla.",
- "station.operating-guidelines.outcomes.1": "Yhdenmukainen API-hallinta ja laatu koko organisaatiossa",
- "station.operating-guidelines.outcomes.2": "organisaation standardien ja parhaiden käytäntöjen noudattaminen",
- "station.operating-guidelines.outcomes.3": "Parempi näkyvyys ja API-aloitteiden hallinta",
- "station.operating-guidelines.how_it_works.1": "Ota käyttöön hallintokäytännöt, joilla varmistetaan, että rajapintoja hallinnoidaan johdonmukaisesti, mukaan lukien tarkistukset, auditoinnit ja vaatimustenmukaisuuden tarkastukset.",
- "station.operating-guidelines.how_it_works.2": "Seuraa API-aloitteita varmistaaksesi toimintaohjeiden ja hallintokäytäntöjen noudattamisen.",
- "station.portfolio-management.outcomes.1": "APIt linjassa liiketoiminnan tavoitteiden ja strategisten aloitteiden kanssa.",
- "station.portfolio-management.outcomes.2": "APIen priorisointi ja optimointi arvon ja vaikutusten perusteella.",
- "station.portfolio-management.outcomes.3": "Parempi näkyvyys ja API-portfolion hallinta",
- "station.portfolio-management.how_it_works.1": "Laaditaan kriteerit rajapintojen arvioimiseksi ja priorisoimiseksi liiketoiminta-arvon, vaikutusten ja strategisten aloitteiden kanssa yhteensopivuuden perusteella.",
- "station.portfolio-management.how_it_works.2": "Seuraa API-portfoliota varmistaaksesi, että APIt tuottavat arvoa, täyttävät suorituskykyodotukset ja ovat linjassa liiketoiminnan tavoitteiden kanssa.",
- "station.budget-and-resource-management.outcomes.1": "Resurssien tehokas kohdentaminen API-aloitteisiin",
- "station.budget-and-resource-management.outcomes.2": "Optimoidut investoinnit API-kehitykseen ja -hallintaan",
- "station.budget-and-resource-management.outcomes.3": "Parempi taloudellinen näkyvyys ja API-aloitteiden valvonta.",
- "station.budget-and-resource-management.how_it_works.1": "Laaditaan kriteerit budjettimäärärahojen arvioimiseksi ja priorisoimiseksi liiketoiminta-arvon, vaikutusten ja strategisten aloitteiden mukaisuuden perusteella.",
- "station.budget-and-resource-management.how_it_works.2": "Seuraa budjettia ja resurssien käyttöä varmistaaksesi tehokkaat investoinnit ja resurssien jakamisen API-aloitteisiin."
+  "group.core-stations.title": "Kyvykkyyden elinkaaren ydinasemat",
+  "group.core-stations.description": "Menetelmän ydinasemat, joissa tiimit oppivat suunnittelemaan, toimittamaan, hallitsemaan ja parantamaan uudelleenkäytettäviä kyvykkyyksiä APIen, tapahtumien, tiedostojen, virtojen, datatuotteiden ja muiden integraatiotapojen yli.",
+  "group.sub-stations.title": "APIn elinkaaren lähiöasemat",
+  "group.sub-stations.description": "Lähiöasemat, jotka tarjoavat lisäresursseja, työkaluja ja parhaita käytäntöjä API-tiimeille.",
+  "station.api-product-strategy.title": "Strategia",
+  "station.api-product-strategy.description": "Kehystä liiketoimintatarve uudelleenkäytettävänä kyvykkyytenä ennen toteutustavan valintaa.",
+  "station.api-product-strategy.why_it_matters": "Integraatio- ja API-työssä hypätään usein liian nopeasti tekniseen malliin. Tämä asema pitää tiimin keskittyneenä liiketoimintapolkuun, toimialan merkitykseen, arvoon, uudelleenkäyttöpotentiaaliin, omistajuuteen ja elinkelpoisuuteen ennen APIen, tapahtumien, tiedostojen, virtojen, datatuotteiden tai suoran integraation valintaa.",
+  "station.api-product-strategy.apply_in_work": "Käytä yhteisiä polku-, toimiala-, arvolupaus- ja liiketoimintamallipohjia teknologiariippumattomien vaatimusten kokoamiseen ja päätä, pitäisikö kyvykkyyden olla uudelleenkäytettävä.",
+  "station.api-product-strategy.outcomes": "Teknologiariippumaton kyvykkyysmahdollisuuden kuvaus",
+  "station.api-product-strategy.how_it_works": "Kuvaa asiakkaan tai kumppanin polku, joka synnyttää kyvykkyystarpeen ja paljastaa tehtävät, ongelmat, hyödyt, syötteet, tuotokset ja päätöspisteet.",
+  "station.api-consumer-experience.title": "Hyödyntäjien vaatimukset ja käyttöönotto",
+  "station.api-consumer-experience.description": "Kokoa hyödyntäjien käyttöönotto, standardit, ei-toiminnalliset vaatimukset, palveluodotukset, rajoitteet, tietoturvatarpeet, sallitut protokollat, datan tuoreus, palvelutasot, havainnoitavuus, palautuminen, käyttöönoton vaatimukset ja tuottajan vastuut.",
+  "station.api-consumer-experience.why_it_matters": "Oikea arkkitehtuuri riippuu hyödyntäjien tavoitteista, käyttöönotto-odotuksista, palvelutasoista, datan laatutarpeista, muutosten sietokyvystä, havainnoitavuudesta, tuesta ja tuottajan rajoitteista.",
+  "station.api-consumer-experience.how_it_works": "Käytä Consumer Experience Requirements Canvas -pohjaa hyödyntäjien tavoitteiden, saatavuuden, tuoreuden, volyymin, suorituskyvyn, datan laadun, tietoturvan, käyttöönoton, muutoksen, havainnoitavuuden ja palautumisen odotusten kuvaamiseen.",
+  "station.api-consumer-experience.how_it_works.1": "Kuvaa käyttöönotto-ohjeistuksen avulla, miten hyödyntäjät löytävät kyvykkyyden, pyytävät sen käyttöä, testaavat sitä, saavat hyväksynnän ja aloittavat käytön.",
+  "station.api-consumer-experience.how_it_works.2": "Käytä syntyvää polkua ja vaatimuksia kyvykkyyden hyödyntäjien käyttöönoton, dokumentaation, tuen ja palautesilmukoiden parantamiseen.",
+  "station.api-consumer-experience.apply_in_work": "Käytä hyödyntäjäkokemuksen ja käyttöönoton ohjeistusta, jotta odotukset ovat selkeitä sekä hyödyntäjille että tuottajille.",
+  "station.api-consumer-experience.outcomes": "Dokumentoidut hyödyntäjävaatimukset ja käyttöönotto-odotukset",
+  "station.api-platform-architecture.title": "Arkkitehtuuri- ja alustapäätökset",
+  "station.api-platform-architecture.description": "Käytä vaatimuksia ja rajoitteita oikean arkkitehtuurimallin ja tarvittavien alustakyvykkyyksien valintaan.",
+  "station.api-platform-architecture.why_it_matters": "Arkkitehtuurivalintojen tulee perustua näyttöön liiketoimintavaikutuksesta, sijainneista, luottamusrajoista, kapasiteetista, viiveestä, datan omistajuudesta, yhdenmukaisuudesta, operoitavuudesta, tietoturvasta, tietosuojasta, hallintamallista ja kustannuksista.",
+  "station.api-platform-architecture.apply_in_work": "Vertaa mahdollisia arkkitehtuurityylejä koottuihin vaatimuksiin ja dokumentoi valittu malli sekä sen perustelut.",
+  "station.api-platform-architecture.outcomes": "Perusteltu arkkitehtuurivalinta",
+  "station.api-platform-architecture.how_it_works": "Käytä Business Impact Canvas -pohjaa saatavuus-, tietoturva- ja datariskien tunnistamiseen, koska ne vaikuttavat arkkitehtuurivaihtoehtoihin.",
+  "station.api-design.title": "Ratkaisu- ja rajapintasuunnittelu",
+  "station.api-design.description": "Suunnittele rajapintasopimus ja vuorovaikutusmalli sen jälkeen, kun arkkitehtuurivalinta on perusteltu.",
+  "station.api-design.why_it_matters": "Kun arkkitehtuurimalli on tiedossa, suunnittelun on muutettava kyvykkyysvaatimukset selkeiksi rajapintasopimuksiksi, vuorovaikutuksiksi, skeemoiksi, datasäännöiksi, elinkaariodotuksiksi ja hyödyntäjien velvoitteiksi.",
+  "station.api-design.apply_in_work": "Valitse valittuun toteutustapaan sopivat suunnitteluresurssit ja dokumentoi rajapintasopimus ennen toteutusta.",
+  "station.api-design.outcomes": "Validoitu rajapintasopimus valitulle toteutustavalle",
+  "station.api-design.how_it_works": "Käytä Domain Canvas -pohjaa uudelleen liiketoimintaolioiden, termien, sääntöjen ja omistajuuden vahvistamiseen ennen sopimussuunnittelua.",
+  "station.api-delivery.title": "Toimitus ja operointi",
+  "station.api-delivery.description": "Toimita valittu toteutustapa asianmukaisilla suunnittelu-, testaus-, tietoturva-, automaatio- ja operointikäytännöillä.",
+  "station.api-delivery.why_it_matters": "Uudelleenkäytettävä kyvykkyys tarvitsee luotettavan toimituksen ja operoinnin riippumatta siitä, toteutuuko se APIlla, tapahtumavirtana, tiedostosiirtona, datatuotteena vai suorana integraationa.",
+  "station.api-delivery.apply_in_work": "Sovella toimituksen, testauksen, CI/CD:n, operoinnin ja tietoturvan ohjeistusta valittuun toteutustapaan.",
+  "station.api-delivery.outcomes": "Toimitettu kyvykkyys, joka vastaa validoitua rajapintasopimusta",
+  "station.api-delivery.how_it_works": "Käytä kehityksen parhaita käytäntöjä validoidun rajapintasopimuksen toteuttamiseen vakiintuneilla kehyksillä, kirjastoilla ja tiimin standardeilla.",
+  "station.api-audit.title": "Laadun ja valmiuden varmistus",
+  "station.api-audit.description": "Auditoi kyvykkyyden rajapintasopimus, kontrollit, tukimalli, havainnoitavuus, dokumentaatio ja elinkaarivalmius ennen julkaisua.",
+  "station.api-audit.why_it_matters": "Uudelleenkäytettävät kyvykkyydet luovat operatiivisia, dataan, tietoturvaan, tietosuojaan, vaatimustenmukaisuuteen ja hyödyntäjiin liittyviä riskejä. Valmiustarkastukset vähentävät yllätyksiä ennen julkaisua tai tuotantokäyttöä.",
+  "station.api-audit.apply_in_work": "Käytä auditointi- ja vaatimustenmukaisuusresursseja varmistaaksesi, että kyvykkyys on valmis hallittuun julkaisuun ja uudelleenkäyttöön.",
+  "station.api-audit.outcomes": "Dokumentoitu valmius julkaisuun ja uudelleenkäyttöön",
+  "station.api-audit.how_it_works": "Käytä auditoinnin tarkistuslistaa uudelleenkäytettävänä laatutarkistuslistana rajapintasopimuksen, dokumentaation, tietoturvan, suorituskyvyn ja vaatimustenmukaisuuden valmiudelle.",
+  "station.api-publishing.title": "Julkaisu ja käyttöönoton mahdollistaminen",
+  "station.api-publishing.description": "Julkaise uudelleenkäytettävän kyvykkyyden tiedot, jotta hyödyntäjät voivat löytää sen, pyytää käyttöä, ottaa sen käyttöön, käyttää sitä ja saada tukea.",
+  "station.api-publishing.why_it_matters": "Uudelleenkäytettävät kyvykkyydet tuottavat arvoa vain, kun hyödyntäjät löytävät ne, ymmärtävät rajapintasopimuksen ja palveluodotukset, voivat pyytää käyttöoikeutta ja tietävät, kuka omistaa tuen ja elinkaaripäätökset.",
+  "station.api-publishing.apply_in_work": "Julkaise omistajuus, dokumentaatio, käyttöönotto, tukiyhteystiedot, palveluodotukset, elinkaaren tila ja käyttöoikeuspyyntöjen polut.",
+  "station.api-publishing.outcomes": "Löydettävä uudelleenkäytettävä kyvykkyys",
+  "station.api-publishing.how_it_works": "Julkaise kyvykkyyden tiedot asianmukaisiin katalogeihin, portaaleihin, yhdyskäytäviin tai ympäristöihin, jotta useat hyödyntäjät voivat käyttää sitä uudelleen.",
+  "station.monitoring-and-improving.title": "Seuranta ja parantaminen",
+  "station.monitoring-and-improving.description": "Seuraa käyttöä, luotettavuutta, datan laatua, hyödyntäjien tuloksia, operatiivisia kustannuksia ja uudelleenkäytön mahdollisuuksia julkaisun jälkeen.",
+  "station.monitoring-and-improving.why_it_matters": "Kyvykkyydet tarvitsevat jatkuvaa palautetta pysyäkseen luotettavina, arvokkaina, kustannustehokkaina ja uudelleenkäytettävinä, kun hyödyntäjät, järjestelmät, data ja alustat muuttuvat.",
+  "station.monitoring-and-improving.apply_in_work": "Käytä mittareita, analytiikkaa ja osallistamisen käytäntöjä kyvykkyyden jatkuvaan parantamiseen.",
+  "station.monitoring-and-improving.outcomes": "Mitattu kyvykkyyden tila ja arvo",
+  "station.monitoring-and-improving.how_it_works": "Käytä mittari- ja analytiikkaohjeistusta kyvykkyyden käytön, luotettavuuden, datan laadun, kustannusten, käyttöönoton ja hyödyntäjäarvon mittareiden määrittelyyn.",
+  "station.user-experience.title": "Käyttäjäkokemus - Suunnittele APIt käyttäjälähtöisesti",
+  "station.user-experience.description": "Varmistetaan, että rajapinnat on suunniteltu loppukäyttäjää ajatellen ja että ne tarjoavat saumattoman ja intuitiivisen käyttökokemuksen.",
+  "station.user-experience.why_it_matters": "APIt eivät ole vain teknisiä tuotteita, vaan ne ovat myös käyttäjälle näkyviä tuotteita. Huono käyttökokemus voi johtaa vähäiseen käyttöön ja turhautumiseen. Tämä asema auttaa tiimejä suunnittelemaan APIt, jotka ovat käyttäjäystävällisiä ja vastaavat hyödyntäjien tarpeita.",
+  "station.user-experience.apply_in_work": "Tarjotaan käyttäjäkokemusta koskevia ohjeita, malleja ja työkaluja API-suunnittelua varten. Varmistetaan, että tiimit noudattavat käyttäjäkeskeisiä suunnittelukäytäntöjä ja sisällyttävät käyttäjäpalautteen API-iteraatioihin.",
+  "station.user-experience.outcomes": "APIt on suunniteltu käyttäjien tarpeet mielessä pitäen",
+  "station.user-experience.how_it_works": "Käyttäjäpersoonien käyttö loppukäyttäjien tarpeiden ja odotusten ymmärtämiseksi.",
+  "station.market-insights.title": "Markkinatietoa - API-maiseman ymmärtäminen",
+  "station.market-insights.description": "Analysoi markkinasuuntauksia, kilpailijoiden rajapintoja ja alan standardeja rajapintastrategian laatimiseksi.",
+  "station.market-insights.why_it_matters": "Markkinatilanteen ymmärtäminen auttaa tiimejä tunnistamaan mahdollisuuksia, välttämään sudenkuoppia ja mukauttamaan rajapintansa alan standardeihin. Tämä asema tarjoaa työkaluja markkinasuuntausten ja kilpailijoiden tarjonnan analysointiin.",
+  "station.market-insights.apply_in_work": "Tarjotaan markkinatutkimustyökaluja, kilpailija-analyysimalleja ja alan standardeja koskevia resursseja. Varmistetaan, että tiimit pysyvät ajan tasalla markkinasuuntauksista ja sisällyttävät näkemykset API-strategiaan.",
+  "station.market-insights.outcomes": "Markkinatrendit ja kilpailijoiden APIt analysoitu",
+  "station.market-insights.how_it_works": "Markkinatutkimuksen tekeminen API-toimialalla vallitsevien suuntausten, mahdollisuuksien ja uhkien tunnistamiseksi.",
+  "station.business-goals.title": "Liiketoiminnalliset tavoitteet - Kohdista rajapinnat liiketoimintatavoitteisiin.",
+  "station.business-goals.description": "Varmistetaan, että rajapinnat ovat linjassa liiketoiminnan tavoitteiden kanssa ja edistävät organisaation yleisiä tavoitteita.",
+  "station.business-goals.why_it_matters": "Rajapintoja ei pidä rakentaa erillään, vaan niiden on tuettava ja edistettävä liiketoiminnan tavoitteita. Tämä asema auttaa tiimejä sovittamaan rajapinnat strategisiin tavoitteisiin ja varmistamaan, että ne tuottavat todellista liiketoiminta-arvoa.",
+  "station.business-goals.apply_in_work": "Tarjotaan liiketoimintasuuntautumiskehyksiä, malleja ja työkaluja API-liiketoiminta-arvon määrittelyyn. Varmistetaan, että tiimit tarkistavat ja sovittavat sovellusrajapinnat säännöllisesti yhteen muuttuvien liiketoimintatavoitteiden kanssa.",
+  "station.business-goals.outcomes": "APIt linjassa liiketoiminnan tavoitteiden kanssa",
+  "station.business-goals.how_it_works": "Määrittele liiketoimintatavoitteet ja se, miten rajapinnat voivat tukea niitä käyttämällä **liiketoimintamallia (Business Model Canvas**). Jos liiketoimintasi tarkoituksena on tarjota rajapintoja, käy läpi *API-tuotestrategia-asema* ja täytä **API-liiketoimintamalli Canvas**.",
+  "station.competitive-analysis.title": "Kilpailuanalyysi - pysy kärjessä API-markkinoilla",
+  "station.competitive-analysis.description": "Analysoi kilpailijoiden rajapinnat vahvuuksien, heikkouksien ja erottautumismahdollisuuksien tunnistamiseksi.",
+  "station.competitive-analysis.why_it_matters": "Kilpailutilanteen ymmärtäminen auttaa tiimejä tunnistamaan API-rajapintojensa puutteet, mahdollisuudet ja parannuskohteet. Tämä asema tarjoaa työkaluja kilpailijoiden analysointiin ja API-strategian laatimiseen.",
+  "station.competitive-analysis.apply_in_work": "Tarjotaan kilpailuanalyysityökaluja, malleja ja resursseja. Varmistetaan, että tiimit analysoivat säännöllisesti kilpailijoita ja sisällyttävät näkemykset API-strategiaan ja -suunnitteluun.",
+  "station.competitive-analysis.outcomes": "Kilpailijoiden rajapintojen vahvuudet ja heikkoudet analysoidaan.",
+  "station.competitive-analysis.how_it_works": "Suorita kilpailija-analyysi tärkeimpien kilpailijoiden, niiden API-tarjonnan sekä niiden vahvuuksien ja heikkouksien tunnistamiseksi.",
+  "station.ecosystem-vision.title": "Ekosysteemin visio - Rakenna rajapinnat kukoistavaa ekosysteemiä varten.",
+  "station.ecosystem-vision.description": "Luo visio siitä, miten rajapintasi sopivat laajempaan ekosysteemiin, joka mahdollistaa yhteistyön ja innovoinnin.",
+  "station.ecosystem-vision.why_it_matters": "APIt eivät ole itsenäisiä tuotteita, vaan osa laajempaa ekosysteemiä. Tämä asema auttaa tiimejä määrittelemään, miten niiden rajapinnat ovat vuorovaikutuksessa muiden järjestelmien, alustojen ja palvelujen kanssa, jotta voidaan luoda kukoistava ekosysteemi, joka edistää yhteistyötä ja innovointia.",
+  "station.ecosystem-vision.apply_in_work": "Tarjotaan ekosysteemin visiokehykset, kumppanien sitouttamisstrategiat ja integrointiohjeet. Varmistaa, että tiimit suunnittelevat rajapinnat ekosysteemiä silmällä pitäen ja edistävät kumppanien välistä yhteistyötä.",
+  "station.ecosystem-vision.outcomes": "Selkeä ekosysteemin visio rajapinnoille",
+  "station.ecosystem-vision.how_it_works": "Määrittele rajapintojesi ekosysteemivisio, mukaan lukien se, miten ne ovat vuorovaikutuksessa muiden järjestelmien ja alustojen kanssa.",
+  "station.scalable-infrastructure.title": "Skaalautuva infrastruktuuri - rakenna APIt vankalle perustalle",
+  "station.scalable-infrastructure.description": "Varmistetaan, että API-infrastruktuurisi voi skaalautua vastaamaan kasvavaa kysyntää ja tukea korkeaa käytettävyyttä.",
+  "station.scalable-infrastructure.why_it_matters": "APIt on rakennettava vankalle infrastruktuurille, joka kestää kasvavan liikenteen ja varmistaa korkean käytettävyyden. Tämä asema tarjoaa ohjeita APIn kasvua ja suorituskykyä tukevan skaalautuvan infrastruktuurin suunnitteluun ja toteuttamiseen.",
+  "station.scalable-infrastructure.apply_in_work": "Tarjotaan infrastruktuurin suunnitteluohjeita, pilvipohjaisia malleja ja valvontatyökaluja. Varmistetaan, että tiimit ottavat käyttöön skaalautuvan infrastruktuurin, joka pystyy mukautumaan muuttuviin vaatimuksiin ja tukemaan API-suorituskykyä.",
+  "station.scalable-infrastructure.outcomes": "Skaalautuva ja joustava API-infrastruktuuri",
+  "station.scalable-infrastructure.how_it_works": "Suunnittele API-infrastruktuuri skaalautuvaksi ja joustavaksi käyttäen pilvipohjaisia malleja ja teknologioita.",
+  "station.legal-and-compliance.title": "Lainsäädäntö ja vaatimustenmukaisuus - varmista, että APIt täyttävät sääntelystandardit.",
+  "station.legal-and-compliance.description": "Varmistetaan, että rajapinnat noudattavat lakisääteisiä ja lainsäädännöllisiä vaatimuksia ja suojaavat organisaatiota ja käyttäjiä.",
+  "station.legal-and-compliance.why_it_matters": "API-rajapintojen on noudatettava oikeudellisia ja sääntelystandardeja organisaation ja käyttäjien suojelemiseksi. Tämä asema tarjoaa työkaluja ja ohjeita, joilla varmistetaan, että rajapinnat täyttävät vaatimustenmukaisuusvaatimukset, vähennetään oikeudellisia riskejä ja varmistetaan tietosuoja.",
+  "station.legal-and-compliance.apply_in_work": "Tarjotaan oikeudellisia ja vaatimustenmukaisuutta koskevia puitteita, tarkistuslistoja ja työkaluja API-vaatimustenmukaisuuden varmistamiseksi. Varmistetaan, että tiimit ymmärtävät ja panevat täytäntöön oikeudelliset vaatimukset APIn suunnittelussa, kehittämisessä ja julkaisemisessa.",
+  "station.legal-and-compliance.outcomes": "Oikeudellisten ja sääntelystandardien mukaiset APIt",
+  "station.legal-and-compliance.how_it_works": "Tunnista rajapintoihin sovellettavat oikeudelliset ja sääntelyvaatimukset, kuten tietosuojaa, yksityisyyttä ja tietoturvaa koskevat vaatimukset.",
+  "station.security-and-privacy.title": "Tietoturva ja yksityisyys - Suojaa APIt ja käyttäjät",
+  "station.security-and-privacy.description": "Toteuta tietoturva- ja yksityisyydensuojatoimenpiteet, joilla suojataan rajapintoja ja käyttäjätietoja uhkilta ja tietoturvaloukkauksilta.",
+  "station.security-and-privacy.why_it_matters": "APIt ovat alttiita tietoturvauhkille ja tietomurroille. Tämä asema tarjoaa ohjeita tietoturva- ja yksityisyydensuojatoimenpiteiden toteuttamiseen, joilla suojataan rajapintoja ja käyttäjätietoja ja varmistetaan luottamus ja vaatimustenmukaisuus.",
+  "station.security-and-privacy.apply_in_work": "Tarjotaan tietoturvakehyksiä, -työkaluja ja parhaita käytäntöjä rajapintojen turvallisuutta ja yksityisyyttä varten. Varmistaa, että tiimit toteuttavat tietoturvatoimenpiteitä koko APIn elinkaaren ajan suunnittelusta julkaisuun ja seurantaan.",
+  "station.security-and-privacy.outcomes": "Uhkia ja haavoittuvuuksia vastaan suojatut rajapinnat",
+  "station.security-and-privacy.how_it_works": "Toteuta turvatoimia, kuten todennus, valtuutus, salaus ja nopeuden rajoittaminen, suojaamaan rajapintoja uhkilta.",
+  "station.design-standards.title": "Suunnittelustandardit - Varmistaa johdonmukainen ja laadukas API-suunnittelu.",
+  "station.design-standards.description": "Suunnittelustandardien ja -ohjeiden laatiminen, jotta varmistetaan yhdenmukainen ja laadukas API-suunnittelu koko organisaatiossa.",
+  "station.design-standards.why_it_matters": "Johdonmukainen ja laadukas API-suunnittelu on olennaisen tärkeää käytettävyyden, ylläpidettävyyden ja skaalautuvuuden kannalta. Tämä asema tarjoaa suunnittelustandardeja ja -ohjeita, joiden avulla tiimit voivat luoda rajapintoja, joita on helppo käyttää, ymmärtää ja ylläpitää.",
+  "station.design-standards.apply_in_work": "Suunnittelustandardien dokumentointi, uudelleenkäytettävät komponentit ja suunnittelun tarkistusprosessit. Varmistetaan, että tiimit noudattavat suunnittelustandardeja ja tekevät säännöllisiä tarkistuksia laadukkaan API-suunnittelun ylläpitämiseksi.",
+  "station.design-standards.outcomes": "Yhdenmukainen API-suunnittelu koko organisaatiossa",
+  "station.design-standards.how_it_works": "Määrittele API-suunnittelun suunnittelustandardit ja -ohjeet, mukaan lukien nimeämiskäytännöt, vastausmuodot ja virheenkäsittely.",
+  "station.vendor-management.title": "Toimittajan hallinta - Kolmannen osapuolen API-integraatioiden hallinta",
+  "station.vendor-management.description": "Hallinnoi tehokkaasti kolmannen osapuolen API-toimittajia ja integraatioita luotettavuuden ja vaatimustenmukaisuuden varmistamiseksi.",
+  "station.vendor-management.why_it_matters": "Kolmannen osapuolen rajapinnat voivat aiheuttaa riskejä ja riippuvuuksia, jotka vaikuttavat rajapintaekosysteemiisi. Tämä asema tarjoaa ohjeita toimittajasuhteiden hallintaan, luotettavuuden ja vaatimustenmukaisuuden varmistamiseen sekä API-strategian noudattamiseen.",
+  "station.vendor-management.apply_in_work": "Tarjotaan toimittajien hallintakehykset, arviointikriteerit ja seurantatyökalut. Varmistetaan, että tiimit hallinnoivat tehokkaasti kolmannen osapuolen API-toimittajia ja varmistavat luotettavuuden, vaatimustenmukaisuuden ja organisaation standardien noudattamisen.",
+  "station.vendor-management.outcomes": "Tehokkaat myyjien hallinnointiprosessit on otettu käyttöön",
+  "station.vendor-management.how_it_works": "Ota käyttöön toimittajahallintaprosessit kolmansien osapuolten API-toimittajien arviointia, käyttöönottoa ja seurantaa varten.",
+  "station.contract-design.title": "Sopimussuunnittelu - Määrittele selkeät API-sopimukset",
+  "station.contract-design.description": "Luo selkeät ja hyvin määritellyt API-sopimukset, joissa hahmotellaan odotukset, vastuut ja käyttöohjeet.",
+  "station.contract-design.why_it_matters": "API-rajapintasopimukset ovat olennaisen tärkeitä, jotta API-toimittajien ja hyödyntäjien välillä on selkeys ja yhdenmukaisuus. Tämä asema tarjoaa ohjeita selkeiden, kattavien ja helposti ymmärrettävien API-rajapintasopimusten suunnitteluun.",
+  "station.contract-design.apply_in_work": "Tarjotaan sopimussuunnittelumalleja, standardoituja muotoja ja tarkistusprosesseja. Varmistetaan, että tiimit luovat selkeät ja hyvin määritellyt API-sopimukset, joissa hahmotellaan odotukset, vastuut ja käyttöohjeet.",
+  "station.contract-design.outcomes": "Kullekin ajapinnalle määritellyt selkeät API-sopimukset",
+  "station.contract-design.how_it_works": "Määrittele API-sopimukset, joissa hahmotellaan kunkin APIn odotukset, vastuut ja käyttöohjeet.",
+  "station.development.title": "Kehitys - Rakenna APIt parhaiden käytäntöjen avulla",
+  "station.development.description": "Toteuta rajapinnat parhaiden käytäntöjen ja kehysten avulla laadun, ylläpidettävyyden ja skaalautuvuuden varmistamiseksi.",
+  "station.development.why_it_matters": "APIn kehittäminen on kriittinen vaihe, joka määrittää APIn laadun ja luotettavuuden. Tämä asema tarjoaa parhaita käytäntöjä ja kehyksiä API-kehitystä varten, jotta varmistetaan, että APIt rakennetaan korkeiden standardien mukaisesti ja että niitä voidaan ylläpitää ja skaalata tehokkaasti.",
+  "station.development.apply_in_work": "Kehityskehysten, kirjastojen ja koodausstandardien tarjoaminen API-toteutusta varten. Varmistaa, että tiimit noudattavat parhaita käytäntöjä, ja suorittaa koodin tarkistuksia API-kehityksen laadun ylläpitämiseksi.",
+  "station.development.outcomes": "parhaita käytäntöjä ja kehyksiä hyödyntävät rajapinnat",
+  "station.development.how_it_works": "Käytetään vakiintuneita kehyksiä ja kirjastoja rajapintojen toteuttamiseen ja varmistetaan, että ne ovat uudelleenkäytettäviä ja ylläpidettäviä.",
+  "station.ci-cd.title": "CI/CD - Automatisoi API-kehitys",
+  "station.ci-cd.description": "Ota käyttöön jatkuvan integroinnin ja jatkuvan toimituksen (CI/CD) putket API-kehityksen automatisoimiseksi ja tasaisen laadun varmistamiseksi.",
+  "station.ci-cd.why_it_matters": "CI/CD on olennaisen tärkeää sen varmistamiseksi, että rajapinnat toimitetaan nopeasti, luotettavasti ja laadukkaasti. Tämä asema tarjoaa ohjeita CI/CD-putkien toteuttamiseen, jotka automatisoivat API-rajapintojen rakentamis-, testaus- ja käyttöönottoprosessit.",
+  "station.ci-cd.apply_in_work": "CI/CD-kehysten, työkalujen ja parhaiden käytäntöjen tarjoaminen API-kehitystä varten. Varmistetaan, että tiimit ottavat käyttöön automatisoidut putket, jotka tukevat APIen jatkuvaa integrointia, testausta ja käyttöönottoa.",
+  "station.ci-cd.outcomes": "Automaattiset CI/CD-putket API-toimituksia varten.",
+  "station.ci-cd.how_it_works": "Käytetään CI/CD-putkia rakentamis-, testaus- ja käyttöönottoprosessien automatisoimiseksi varmistaen johdonmukaisen laadun ja jäljitettävyyden.",
+  "station.test-automation.title": "Testausautomaatio - varmista API-laatu",
+  "station.test-automation.description": "Ota käyttöön automatisoituja testauskäytäntöjä APIn laadun, luotettavuuden ja suorituskyvyn varmistamiseksi.",
+  "station.test-automation.why_it_matters": "Automatisoitu testaus on ratkaisevan tärkeää sen varmistamiseksi, että rajapinnat toimivat oikein ja täyttävät laatuvaatimukset. Tämä asema tarjoaa ohjeita automaattisten testauskäytäntöjen käyttöönottoon, jotka kattavat APIen toiminnallisen, turvallisuus- ja suorituskykytestauksen.",
+  "station.test-automation.apply_in_work": "Testausautomaatiokehysten, -työkalujen ja parhaiden käytäntöjen tarjoaminen API-testausta varten. Varmistetaan, että tiimit toteuttavat automatisoituja testejä, jotka kattavat APIen toiminnalliset, turvallisuus- ja suorituskykyyn liittyvät näkökohdat.",
+  "station.test-automation.outcomes": "API-rajapintojen automatisoidut testauskäytännöt",
+  "station.test-automation.how_it_works": "Käytetään automatisoituja testausvälineitä API-toiminnallisuuden, tietoturvan ja suorituskyvyn validointiin.",
+  "station.release-management.title": "Julkaisunhallinta - Hallitse API-julkaisuja tehokkaasti",
+  "station.release-management.description": "Ota käyttöön julkaisujen hallintakäytäntöjä sujuvien ja valvottujen API-julkaisujen varmistamiseksi.",
+  "station.release-management.why_it_matters": "Tehokas julkaisujen hallinta on olennaisen tärkeää, jotta voidaan varmistaa, että API-julkaisut ovat sujuvia, hallittuja ja liiketoiminnan tarpeiden mukaisia. Tämä asema tarjoaa ohjeita API-julkaisujen hallintaan, mukaan lukien versiointi, käyttöönottostrategiat ja palautusmenettelyt.",
+  "station.release-management.apply_in_work": "Tarjotaan julkaisunhallintakehykset, versiointiohjeet ja käyttöönottostrategiat. Varmistetaan, että tiimit noudattavat parhaita käytäntöjä API-julkaisujen hallinnassa, mukaan lukien versiointi, käyttöönotto ja palautusmenettelyt.",
+  "station.release-management.outcomes": "Hallitut ja sujuvat API-julkaisut",
+  "station.release-management.how_it_works": "Määrittele rajapintojen versiointistrategiat muutosten hallitsemiseksi ja taaksepäin yhteensopivuuden varmistamiseksi.",
+  "station.service-agreements.title": "Palvelusopimukset - määrittele API-palvelutasot",
+  "station.service-agreements.description": "Laadi palvelusopimukset, joissa määritellään API-toimittajien ja hyödyntäjien odotukset, palvelutasot ja vastuut.",
+  "station.service-agreements.why_it_matters": "Palvelusopimukset ovat olennaisen tärkeitä, jotta API-toimittajien ja hyödyntäjien välillä on selkeys ja yhdenmukaisuus. Tämä asema tarjoaa ohjeita palvelusopimusten laatimiseen niin, että odotukset, palvelutasot ja vastuut ovat selvät ja väärinkäsitysten riski pienenee.",
+  "station.service-agreements.apply_in_work": "Tarjoa palvelusopimusmalleja, standardoituja muotoja ja katselmointiprosesseja. Varmista, että tiimit luovat selkeät ja tarkkaan määritellyt palvelusopimukset, joissa kuvataan API-toimittajien ja hyödyntäjien odotukset, palvelutasot ja vastuut.",
+  "station.service-agreements.outcomes": "Kullekin rajapinnalle määritellyt selkeät palvelusopimukset",
+  "station.service-agreements.how_it_works": "Määrittele palvelusopimukset, joissa hahmotellaan odotukset, palvelutasot ja vastuualueet kutakin rajapintaa varten.",
+  "station.api-consumer-adoption.title": "APIn käyttöönotto - APIn käytön edistäminen",
+  "station.api-consumer-adoption.description": "Toteuta strategioita, joilla edistetään API-hyödyntäjien käyttöönottoa ja sitoutumista sekä varmistetaan, että API-rajapintoja käytetään tehokkaasti.",
+  "station.api-consumer-adoption.why_it_matters": "API-hyödyntäjien käyttöönoton edistäminen on ratkaisevan tärkeää APIen arvon hyödyntämiseksi. Tämä asema tarjoaa strategioita ja parhaita käytäntöjä API-hyödyntäjien sitouttamiseen ja sen varmistamiseen, että he ymmärtävät, miten API-rajapintoja käytetään tehokkaasti ja miten niistä saadaan arvoa.",
+  "station.api-consumer-adoption.apply_in_work": "Tarjoa API-hyödyntäjille resursseja, koulutusmateriaalia ja sitouttamisstrategioita. Varmista, että tiimit toteuttavat strategioita, jotka edistävät API-hyödyntäjien käyttöönottoa, sitoutumista ja tyytyväisyyttä.",
+  "station.api-consumer-adoption.outcomes": "APIn käyttöönottoa edistävät strategiat hyödyntäjille",
+  "station.api-consumer-adoption.how_it_works": "Kehitä käyttöönoton prosesseja ja resursseja, joiden avulla API-hyödyntäjät ymmärtävät, miten rajapintoja käytetään tehokkaasti.",
+  "station.api-promotion.title": "API-näkyvyys - APIn näkyvyyden ja käytön lisääminen",
+  "station.api-promotion.description": "Edistetään rajapintoja näkyvyyden, käytön ja hyväksynnän lisäämiseksi kohdeyleisöjen keskuudessa.",
+  "station.api-promotion.why_it_matters": "API-rajapintojen tunnetuksi tekeminen on olennaisen tärkeää niiden näkyvyyden lisäämiseksi ja käytön edistämiseksi. Tämä asema tarjoaa strategioita ja parhaita käytäntöjä APIen tehokkaaseen markkinointiin kohdeyleisöille, jotta varmistetaan, että nämä ovat tietoisia APIista ja ymmärtävät niiden arvon.",
+  "station.api-promotion.apply_in_work": "Tarjotaan markkinointistrategioita, myynninedistämismateriaalia ja resursseja yhteisön sitouttamiseen. Varmistaa, että tiimit toteuttavat tehokkaita APIn edistämisstrategioita, jotka lisäävät näkyvyyttä, käyttöä ja käyttöönottoa kohdeyleisöjen keskuudessa.",
+  "station.api-promotion.outcomes": "Toteutetut API-edistämisstrategiat",
+  "station.api-promotion.how_it_works": "Kehitä markkinointistrategioita APIen markkinoimiseksi kohdeyleisöille, mukaan lukien sosiaalinen media, blogit ja webinaarit.",
+  "station.partner-integration.title": "Kumppanien integrointi - Tee yhteistyötä kumppaneiden kanssa",
+  "station.partner-integration.description": "Helpota kumppani-integraatioita API-ominaisuuksien parantamiseksi ja tavoittavuuden laajentamiseksi.",
+  "station.partner-integration.why_it_matters": "Kumppani-integraatiot voivat parantaa API-ominaisuuksia ja laajentaa tavoitettavuutta. Tämä asema tarjoaa ohjeita kumppanien kanssa tehtävään yhteistyöhön niiden rajapintojen integroimiseksi, jotta varmistetaan saumaton yhteentoimivuus ja arvon luominen.",
+  "station.partner-integration.apply_in_work": "Tarjotaan kumppaneiden integrointikehykset, ohjeet ja seurantatyökalut. Varmistaa, että tiimit tekevät tehokasta yhteistyötä kumppaneiden kanssa API-ominaisuuksien parantamiseksi, ulottuvuuden laajentamiseksi ja innovoinnin edistämiseksi.",
+  "station.partner-integration.outcomes": "Kumppaneiden integrointiprosessit on luotu",
+  "station.partner-integration.how_it_works": "Tunnista mahdolliset kumppanit, joiden APIt voivat parantaa API-valmiuksiasi ja arvolupaustasi.",
+  "station.api-mindset.title": "API-ajattelutapa - API-first -kulttuurin edistäminen",
+  "station.api-mindset.description": "Kehitä API-first -ajattelutapaa koko organisaatiossa innovoinnin ja yhteistyön edistämiseksi.",
+  "station.api-mindset.why_it_matters": "API-first -ajattelutapa on olennaisen tärkeä innovoinnin ja yhteistyön edistämiseksi koko organisaatiossa. Tämä asema tarjoaa strategioita API-first -kulttuurin kehittämiseksi ja sen varmistamiseksi, että rajapinnat nähdään strategisina voimavaroina, jotka tuottavat liiketoiminta-arvoa.",
+  "station.api-mindset.apply_in_work": "Tarjotaan koulutusohjelmia, resursseja ja viestintästrategioita API-first -kulttuurin edistämiseksi. Varmistetaan, että tiimit ymmärtävät APIen arvon ja että niillä on valtuudet johtaa API-strategiaa ja -aloitteita.",
+  "station.api-mindset.outcomes": "API-first -kulttuuri on vakiintunut koko organisaatioon",
+  "station.api-mindset.how_it_works": "Edistetään rajapintojen arvoa strategisina voimavaroina, jotka lisäävät liiketoiminnan arvoa ja innovointia.",
+  "station.roles-and-responsibilities.title": "Roolit ja vastuualueet - API-tiimien rakenteiden määrittelyt",
+  "station.roles-and-responsibilities.description": "Määrittele API-tiimeille selkeät roolit ja vastuualueet tehokkaan yhteistyön ja vastuuvelvollisuuden varmistamiseksi.",
+  "station.roles-and-responsibilities.why_it_matters": "Selkeät roolit ja vastuualueet ovat olennaisen tärkeitä tehokkaan yhteistyön ja vastuuvelvollisuuden kannalta API-tiimeissä. Tämä asema tarjoaa ohjeita tiimirakenteiden, roolien ja vastuualueiden määrittelyyn ja varmistaa, että kaikki ymmärtävät oman panoksensa API-aloitteisiin.",
+  "station.roles-and-responsibilities.apply_in_work": "Tarjotaan tiimirakenneohjeet, roolimäärittelyt ja viestintästrategiat. Varmistetaan, että tiimeillä on selkeät roolit ja vastuut, jotka edistävät tehokasta yhteistyötä ja vastuullisuutta API-aloitteissa.",
+  "station.roles-and-responsibilities.outcomes": "API-tiimeille on määritelty selkeät roolit ja vastuut",
+  "station.roles-and-responsibilities.how_it_works": "Määrittele API-tiimien tiimirakenteet ja roolit, mukaan lukien API-tuotteen omistajat, kehittäjät, arkkitehdit ja toiminnot.",
+  "station.upskilling.title": "Osaamisen kehittäminen - API-taitojen ja -tiedon parantaminen",
+  "station.upskilling.description": "Tarjotaan koulutusta ja resursseja API-taitojen ja -tiedon parantamiseksi koko organisaatiossa.",
+  "station.upskilling.why_it_matters": "Jatkuva oppiminen ja täydennyskoulutus ovat olennaisen tärkeitä, jotta API-tiimit pysyvät ajan tasalla uusimmista teknologioista, käytännöistä ja suuntauksista. Tämä asema tarjoaa koulutusohjelmia ja resursseja API-taitojen ja -tiedon parantamiseen, jotta tiimit ovat valmiita toimittamaan korkealaatuisia API-rajapintoja.",
+  "station.upskilling.apply_in_work": "Tarjotaan koulutusohjelmia, resursseja ja arviointivälineitä API-taitojen ja -tietojen parantamiseksi. Varmistetaan, että tiimeillä on mahdollisuus jatkuvaan oppimiseen, joka antaa heille mahdollisuuden edistää API-innovaatioita ja laatua.",
+  "station.upskilling.outcomes": "API-taitojen ja -tiedon parantaminen koko organisaatiossa",
+  "station.upskilling.how_it_works": "Tunnistetaan keskeiset API-taidot ja -tiedot, joita on kehitettävä, kuten API-suunnittelu, tietoturva ja suorituskyky.",
+  "station.operating-guidelines.title": "Toimintaohjeet - API-hallinnon perustaminen",
+  "station.operating-guidelines.description": "Laaditaan toimintaohjeet ja hallintokäytännöt, joilla varmistetaan APIn johdonmukainen hallinta ja laatu.",
+  "station.operating-guidelines.why_it_matters": "Tehokas API-hallinta on olennaisen tärkeää, jotta voidaan varmistaa yhdenmukainen API-hallinta, laatu ja vaatimustenmukaisuus. Tämä asema tarjoaa toimintaohjeita ja hallintakäytäntöjä, jotka auttavat tiimejä hallinnoimaan API-rajapintoja tehokkaasti ja varmistamaan, että ne ovat organisaation standardien ja parhaiden käytäntöjen mukaisia.",
+  "station.operating-guidelines.apply_in_work": "Toimintaohjeiden, hallintakehysten ja seurantatyökalujen tarjoaminen API-hallintaa varten. Varmistaa, että tiimit noudattavat vakiintuneita käytäntöjä, jotka edistävät johdonmukaista API-hallintaa, laatua ja organisaation standardien noudattamista.",
+  "station.operating-guidelines.outcomes": "APIn hallintokäytännöt on vahvistettu",
+  "station.operating-guidelines.how_it_works": "Määrittele APIOps Cyclesiin perustuvat toimintaohjeet, joissa hahmotellaan API-hallinnan prosessit, standardit ja parhaat käytännöt.",
+  "station.portfolio-management.title": "Portfolionhallinta - hallinnoi API-portfoliota tehokkaasti",
+  "station.portfolio-management.description": "Hallinnoida API-salkkua tehokkaasti varmistaaksesi, että se on linjassa liiketoiminnan tavoitteiden ja strategisten aloitteiden kanssa.",
+  "station.portfolio-management.why_it_matters": "Tehokas rajapintasalkun hallinta on olennaisen tärkeää sen varmistamiseksi, että rajapinnat ovat linjassa liiketoiminnan tavoitteiden ja strategisten aloitteiden kanssa. Tämä asema tarjoaa ohjeita API-salkun hallintaan ja varmistaa, että APIt priorisoidaan, seurataan ja optimoidaan siten, että ne tuottavat mahdollisimman paljon arvoa.",
+  "station.portfolio-management.apply_in_work": "Tarjotaan salkunhallintakehykset, priorisointikriteerit ja seurantatyökalut API-hallintaa varten. Varmistaa, että tiimit hallinnoivat API-salkkua tehokkaasti ja varmistavat, että se on linjassa liiketoimintatavoitteiden ja strategisten aloitteiden kanssa ja tuottaa mahdollisimman paljon arvoa.",
+  "station.portfolio-management.outcomes": "API-salkunhallintakäytäntöjen käyttöönotto",
+  "station.portfolio-management.how_it_works": "Määrittele salkunhallintakäytännöt, joissa hahmotellaan API-salkun hallinnointiprosessit, mukaan lukien priorisointi, seuranta ja optimointi.",
+  "station.budget-and-resource-management.title": "Budjetin ja resurssien hallinta - Optimoi API-investoinnit",
+  "station.budget-and-resource-management.description": "Optimoi API-aloitteiden budjetin ja resurssien hallinta tehokkaiden investointien ja resurssien kohdentamisen varmistamiseksi.",
+  "station.budget-and-resource-management.why_it_matters": "Tehokas talousarvio- ja resurssienhallinta on olennaisen tärkeää, jotta voidaan varmistaa, että API-aloitteet ovat hyvin rahoitettuja ja resursoituja. Tämä asema tarjoaa ohjeita budjetin ja resurssien hallinnan optimoimiseksi ja sen varmistamiseksi, että API-aloitteet ovat linjassa liiketoimintatavoitteiden kanssa ja tuottavat maksimaalista arvoa.",
+  "station.budget-and-resource-management.apply_in_work": "Tarjotaan API-aloitteille budjettihallintakehykset, priorisointikriteerit ja seurantatyökalut. Varmistaa, että tiimit hallinnoivat tehokkaasti budjetteja ja resursseja ja optimoivat API-kehitykseen ja -hallintaan tehdyt investoinnit mahdollisimman suuren arvon tuottamiseksi.",
+  "station.budget-and-resource-management.outcomes": "API-aloitteita varten laaditut budjetti- ja resurssienhallintakäytännöt",
+  "station.budget-and-resource-management.how_it_works": "Määrittele budjetti- ja resurssienhallintakäytännöt, joissa hahmotellaan API-aloitteiden budjettien ja resurssien hallinnointiprosessit.",
+  "station.api-product-strategy.outcomes.1": "Yhteinen ymmärrys hyödyntäjistä, tuottajista, toimialan käsitteistä ja uudelleenkäyttöpotentiaalista",
+  "station.api-product-strategy.outcomes.2": "Kyvykkyyden arvolupaus ja liiketoimintamalli ennen arkkitehtuurin valintaa",
+  "station.api-product-strategy.how_it_works.1": "Määrittele keskeiset oliot, attribuutit, suhteet, omistajuus ja liiketoimintasäännöt, joita kyvykkyyden on noudatettava.",
+  "station.api-product-strategy.how_it_works.2": "Käytä Capability Value Proposition Canvas -pohjaa hyödyntäjien tehtävien, hyötyjen, ongelmien ja uudelleenkäytettävien kyvykkyysominaisuuksien kuvaamiseen nimeämättä toimitusteknologiaa liian aikaisin.",
+  "station.api-product-strategy.how_it_works.3": "Käytä Capability Business Model Canvas -pohjaa omistajuuden, kumppaneiden, kanavien, kustannusten, hyötyjen, tuen ja elinkaariodotusten selkeyttämiseen uudelleenkäytettävälle kyvykkyydelle.",
+  "station.api-consumer-experience.outcomes.1": "Selkeät tuottajan vastuut ja tukiin liittyvät odotukset",
+  "station.api-consumer-experience.outcomes.2": "Arkkitehtuurin kannalta olennaiset rajoitteet valmiina päätöksentekoon",
+  "station.api-consumer-experience.outcomes.3": "Parempi käyttöönotto hyödyntäjäymmärryksen, standardien ja tuottajan selkeyden kautta",
+  "station.api-platform-architecture.outcomes.1": "Dokumentoidut riskit sekä sijainti-, kapasiteetti-, tietoturva-, tietosuoja- ja operoitavuusrajoitteet",
+  "station.api-platform-architecture.outcomes.2": "Selkeä perustelu API-, tapahtuma-, tiedosto-, virta-, datatuote-, suora integraatio- tai hybriditoteutukselle",
+  "station.api-platform-architecture.how_it_works.1": "Käytä Locations Canvas -pohjaa geopoliittisten, sääntelyyn liittyvien, verkko-, datan sijainti- ja luottamusrajarajoitteiden kuvaamiseen.",
+  "station.api-platform-architecture.how_it_works.2": "Käytä Capacity Canvas -pohjaa nykyisten ja tulevien volyymien, huippujen, viiveen, välimuistin, nopeusrajoitusten ja skaalautumisodotusten kuvaamiseen.",
+  "station.api-platform-architecture.how_it_works.3": "Käytä mittari- ja analytiikkaohjeistusta määrittelemään, miten valittua kyvykkyyttä seurataan ja parannetaan.",
+  "station.api-design.outcomes.1": "Johdonmukaiset vuorovaikutus-, data-, tapahtuma-, tiedosto-, työnkulku- tai API-rajapintasopimuspäätökset",
+  "station.api-design.outcomes.2": "Suunnittelun jäljitettävyys kyvykkyyden ja hyödyntäjien vaatimuksiin",
+  "station.api-design.outcomes.3": "Suunnitelmat linjassa toimialamallien ja vuorovaikutusmallien kanssa",
+  "station.api-design.how_it_works.1": "Kuvaa Interaction Canvas -pohjan avulla, miten hyödyntäjät, järjestelmät tai käyttäjät ovat vuorovaikutuksessa kyvykkyyden kanssa.",
+  "station.api-design.how_it_works.2": "Käytä REST-suunnitteluresursseja, kun valittu rajapinta on REST API.",
+  "station.api-design.how_it_works.3": "Käytä Event Canvas -resursseja, kun valittu rajapinta on tapahtumapohjainen.",
+  "station.api-design.how_it_works.4": "Käytä GraphQL-suunnitteluresursseja, kun valittu rajapinta on GraphQL.",
+  "station.api-design.how_it_works.5": "Käytä suunnitteluperiaatteita ja tyyliopasta, jotta suunnittelupäätökset ovat linjassa yhteisten sääntöjen kanssa ja auditointi voi validoida ne johdonmukaisesti.",
+  "station.api-design.how_it_works.6": "Sovella contract-first- tai design-first-lähestymistapaa rajapintasopimuksen kuvaamiseen ja validointiin ennen toteutusta.",
+  "station.api-design.how_it_works.7": "Käytä auditoinnin tarkistuslistaa varmistaaksesi, että suunnittelu täyttää toiminnalliset ja ei-toiminnalliset vaatimukset, mukaan lukien tietoturva, suorituskyky ja vaatimustenmukaisuus.",
+  "station.api-delivery.outcomes.1": "Automatisoitu testaus, julkaisu ja ympäristökontrollit",
+  "station.api-delivery.outcomes.2": "Valittuun malliin sopivat tietoturva-, operointi- ja laatukäytännöt",
+  "station.api-delivery.outcomes.3": "Jäljitettävät toimitus- ja julkaisukontrollit",
+  "station.api-delivery.how_it_works.1": "Rakenna toteutus validoidun rajapintasopimuksen pohjalta vakiintuneilla kehyksillä, kirjastoilla ja tiimin standardeilla.",
+  "station.api-delivery.how_it_works.2": "Käytä testausohjeistusta toiminnallisuuden, datan laadun, yhteensopivuuden, tietoturvan, suorituskyvyn, resilienssin ja palautumisodotusten varmistamiseen.",
+  "station.api-delivery.how_it_works.3": "Käytä CI/CD-ohjeistusta koonnin, testauksen, julkaisun, konfiguraation ja jäljitettävyyden automatisointiin.",
+  "station.api-delivery.how_it_works.4": "Käytä tietoturvaohjeistusta datan, käyttöoikeuksien, tunnistetietojen ja alustarajojen suojaamiseen.",
+  "station.api-delivery.how_it_works.5": "Käytä auditoinnin tarkistuslistaa varmistaaksesi, että ratkaisu täyttää toiminnalliset ja ei-toiminnalliset vaatimukset, mukaan lukien tietoturva, suorituskyky ja vaatimustenmukaisuus.",
+  "station.api-audit.outcomes.1": "Tunnetut puutteet ja korjaustoimet ennen julkaisua",
+  "station.api-audit.outcomes.2": "Näyttö hallintamallin, vaatimustenmukaisuuden, tuen ja operatiivisen hyväksynnän tueksi",
+  "station.api-audit.outcomes.3": "Pienempi riski tuotannon ongelmille",
+  "station.api-audit.how_it_works.1": "Käytä tarkistuslistoja, linttereitä ja testausvälineitä johdonmukaisuuden ja standardien noudattamisen varmistamiseen.",
+  "station.api-audit.how_it_works.2": "Tee yhteistyötä hallintatiimien ja toimialan asiantuntijoiden kanssa varmistaaksesi, että kyvykkyys on valmis tuotantoon.",
+  "station.api-publishing.outcomes.1": "Selkeät käyttöönotto-, käyttöoikeus-, tuki- ja palveluodotukset",
+  "station.api-publishing.outcomes.2": "Elinkaari- ja omistajuustiedot hyödyntäjien ja hallintatiimien saatavilla",
+  "station.api-publishing.outcomes.3": "Hyödyntäjät voivat käyttää ja uudelleenkäyttää kyvykkyyttä",
+  "station.api-publishing.how_it_works.1": "Dokumentoi, miten hyödyntäjät löytävät kyvykkyyden ja käyttävät sitä, mukaan lukien käyttöönotto- ja rekisteröintiprosessit.",
+  "station.api-publishing.how_it_works.2": "Varmista, että tietoturvamallit, käyttöoikeuskonfiguraatio ja oikeudelliset ehdot ovat selkeitä ja hyödyntäjien saatavilla.",
+  "station.monitoring-and-improving.outcomes.1": "Parannusjono, joka perustuu operatiiviseen ja hyödyntäjien palautteeseen",
+  "station.monitoring-and-improving.outcomes.2": "Uudelleenkäytön, luotettavuuden, datan laadun ja kustannusten signaalit omistajien saatavilla",
+  "station.monitoring-and-improving.outcomes.3": "Jatkuva parantaminen linjassa hyödyntäjien tarpeiden kanssa",
+  "station.monitoring-and-improving.how_it_works.1": "Analysoi käyttömittareita ja ota hyödyntäjien palaute mukaan kyvykkyyden kehitysversioihin.",
+  "station.monitoring-and-improving.how_it_works.2": "Luo tapa tarkastella mittareita ja suunnitella jatkuvan parantamisen toimia.",
+  "station.user-experience.outcomes.1": "Intuitiiviset ja johdonmukaiset käyttöliittymät",
+  "station.user-experience.outcomes.2": "Käyttäjien palaute sisällytetty APIn suunnitteluun",
+  "station.user-experience.outcomes.3": "Parempi käyttäjätyytyväisyys ja hyväksyntä",
+  "station.user-experience.how_it_works.1": "Suorita käyttäjätutkimus kerätäksesi tietoa siitä, miten hyödyntäjät ovat vuorovaikutuksessa ekosysteemipalveluiden tai API-sovelluksia käyttävien sovellusten kanssa.",
+  "station.user-experience.how_it_works.2": "Dokumentoi käyttäjäkokemusta koskevat vaatimukset, jotta niitä voidaan käyttää API-suunnittelussa ja varmistaa, että ne ovat intuitiivisia ja helppokäyttöisiä.",
+  "station.market-insights.outcomes.1": "Määritetyt alan standardit ja parhaat käytännöt",
+  "station.market-insights.outcomes.2": "API-strategia linjassa markkinoiden tarpeiden kanssa",
+  "station.market-insights.outcomes.3": "Markkinatietoon perustuva tietoon perustuva päätöksenteko",
+  "station.market-insights.how_it_works.1": "Analysoi kilpailijoiden rajapinnat ymmärtämään niiden vahvuudet, heikkoudet ja ainutlaatuiset myyntivaltit.",
+  "station.market-insights.how_it_works.2": "Tunnistetaan alan standardit ja parhaat käytännöt, jotta voidaan varmistaa, että rajapinnat ovat kilpailukykyisiä ja yhteensopivia.",
+  "station.business-goals.outcomes.1": "Kullekin Rajapinnalle määritelty selkeä liiketoiminta-arvo",
+  "station.business-goals.outcomes.2": "Sidosryhmien sitoutuminen ja tuki API-aloitteille",
+  "station.business-goals.outcomes.3": "APIt edistävät organisaation menestystä",
+  "station.business-goals.how_it_works.1": "Määritä keskeiset suorituskykyindikaattorit (KPI), joilla mitataan APIn onnistumista suhteessa liiketoiminnan tavoitteisiin.",
+  "station.business-goals.how_it_works.2": "Sidosryhmien sitouttaminen varmistamaan API-aloitteiden yhdenmukaisuus ja tuki.",
+  "station.competitive-analysis.outcomes.1": "Eriyttämismahdollisuudet tunnistettu",
+  "station.competitive-analysis.outcomes.2": "API-strategia, joka perustuu kilpailutietoon",
+  "station.competitive-analysis.outcomes.3": "Lisääntynyt kilpailukyky API-markkinoilla",
+  "station.competitive-analysis.how_it_works.1": "Tunnista markkinapuutteet, jotka rajapintasi voivat täyttää kilpailijoiden tarjonnan perusteella.",
+  "station.competitive-analysis.how_it_works.2": "Kehitä erottautumisstrategia, jossa korostetaan rajapintojesi ainutlaatuisia ominaisuuksia ja etuja.",
+  "station.ecosystem-vision.outcomes.1": "APIt, jotka on suunniteltu mahdollistamaan yhteistyö ja integrointi",
+  "station.ecosystem-vision.outcomes.2": "Ekosysteemikumppanit tunnistetaan ja otetaan mukaan",
+  "station.ecosystem-vision.outcomes.3": "APIt edistävät elinvoimaista ekosysteemiä",
+  "station.ecosystem-vision.how_it_works.1": "Tunnistetaan tärkeimmät ekosysteemikumppanit ja sidosryhmät, jotka hyötyvät ekosysteemistä tai osallistuvat siihen.",
+  "station.ecosystem-vision.how_it_works.2": "Suunnittele rajapinnat, jotka mahdollistavat saumattoman integroinnin ja yhteistyön ekosysteemissä.",
+  "station.scalable-infrastructure.outcomes.1": "Korkea käytettävyys ja suorituskyky kuormitettuna",
+  "station.scalable-infrastructure.outcomes.2": "Tulevaa kasvua varten suunniteltu infrastruktuuri",
+  "station.scalable-infrastructure.outcomes.3": "Vähentää käyttökatkoksia ja parantaa käyttäjäkokemusta",
+  "station.scalable-infrastructure.how_it_works.1": "Toteuta kuorman tasapainottaminen, välimuistitallennus ja muut tekniikat korkean käytettävyyden ja suorituskyvyn varmistamiseksi. Kerää infrastruktuurivaatimukset API-tiimeiltä Capacity Canvasin avulla.",
+  "station.scalable-infrastructure.how_it_works.2": "Seuraa infrastruktuurin suorituskykyä ja kapasiteettia sen varmistamiseksi, että se pystyy vastaamaan kasvavaan kysyntään.",
+  "station.legal-and-compliance.outcomes.1": "Tietosuojaa ja yksityisyyden suojaa koskevat vaatimukset täyttyvät",
+  "station.legal-and-compliance.outcomes.2": "Oikeudellisten riskien tunnistaminen ja lieventäminen",
+  "station.legal-and-compliance.outcomes.3": "Vaatimustenmukaisuustoimenpiteiden selkeä dokumentointi",
+  "station.legal-and-compliance.how_it_works.1": "Toteuta toimenpiteitä, joilla varmistetaan, että rajapinnat täyttävät nämä vaatimukset, mukaan lukien tietojen salaus, käyttöoikeuksien valvonta ja kirjausketjut.",
+  "station.legal-and-compliance.how_it_works.2": "Dokumentoi vaatimustenmukaisuustoimenpiteet ja varmista, että niistä tiedotetaan sidosryhmille ja hyödyntäjille.",
+  "station.security-and-privacy.outcomes.1": "Käyttäjätiedot suojattu yksityisyydensuojatoimenpiteiden avulla",
+  "station.security-and-privacy.outcomes.2": "Parhaat turvallisuuskäytännöt API-suunnittelussa ja -kehityksessä",
+  "station.security-and-privacy.outcomes.3": "Turvallisuusstandardien ja -säännösten noudattaminen",
+  "station.security-and-privacy.how_it_works.1": "Varmistetaan käyttäjien tietojen yksityisyys toteuttamalla tietosuojatoimenpiteitä, kuten anonymisointi ja käyttöoikeuksien valvonta.",
+  "station.security-and-privacy.how_it_works.2": "Suorittaa säännöllisiä tietoturvatarkastuksia ja haavoittuvuusarviointeja riskien tunnistamiseksi ja vähentämiseksi.",
+  "station.design-standards.outcomes.1": "Laadukkaat APIt, jotka vastaavat käyttäjien tarpeita",
+  "station.design-standards.outcomes.2": "Uudelleenkäytettävät suunnittelumallit ja komponentit",
+  "station.design-standards.outcomes.3": "Vähennetään suunnittelun epäjohdonmukaisuuksia ja teknistä velkaa.",
+  "station.design-standards.how_it_works.1": "Luo uudelleenkäytettäviä suunnittelumalleja ja -komponentteja, joita tiimit voivat hyödyntää yhdenmukaisuuden ja laadun varmistamiseksi.",
+  "station.design-standards.how_it_works.2": "Suoritat suunnittelun tarkastuksia ja auditointeja varmistaaksesi suunnittelustandardien noudattamisen ja yksilöidäksesi parannuskohteet.",
+  "station.vendor-management.outcomes.1": "Kolmannen osapuolen APIt integroituvat luotettavasti ja turvallisesti.",
+  "station.vendor-management.outcomes.2": "Myyjä noudattaa organisaation standardeja",
+  "station.vendor-management.outcomes.3": "Kolmannen osapuolen riippuvuuksiin liittyvien riskien vähentäminen",
+  "station.vendor-management.how_it_works.1": "Määrittele kriteerit toimittajien rajapintojen arviointia varten, mukaan lukien luotettavuus, turvallisuus ja vaatimustenmukaisuus.",
+  "station.vendor-management.how_it_works.2": "Seuraa toimittajien suorituskykyä ja palvelutasosopimusten (SLA) ja organisaation standardien noudattamista.",
+  "station.contract-design.outcomes.1": "API-toimittajien ja hyödyntäjien odotukset ja vastuut kuvattuina",
+  "station.contract-design.outcomes.2": "Käyttöohjeet ja parhaat käytännöt dokumentoitu",
+  "station.contract-design.outcomes.3": "APIn käyttöä koskevien väärinkäsitysten ja riitojen väheneminen.",
+  "station.contract-design.how_it_works.1": "Käytä standardoituja formaatteja (esim. OpenAPI, AsyncAPI) luodaksesi koneellisesti luettavia API-sopimuksia, joita on helppo jakaa ja validoida.",
+  "station.contract-design.how_it_works.2": "Varmistetaan, että sidosryhmät tarkistavat ja hyväksyvät API-sopimukset, jotta varmistetaan niiden yhdenmukaisuus ja selkeys.",
+  "station.development.outcomes.1": "Laadukkaat, ylläpidettävät ja skaalautuvat rajapinnat.",
+  "station.development.outcomes.2": "Johdonmukaiset koodausstandardit ja -käytännöt",
+  "station.development.outcomes.3": "Vähentää kehitysaikaa ja teknistä velkaa",
+  "station.development.how_it_works.1": "Sovellat sopimuslähtöisiä tai suunnittelulähtöisiä lähestymistapoja varmistaaksesi, että API-sopimukset validoidaan ennen toteutusta.",
+  "station.development.how_it_works.2": "Noudata koodausstandardeja ja parhaita käytäntöjä varmistaaksesi johdonmukaisen ja laadukkaan API-kehityksen.",
+  "station.ci-cd.outcomes.1": "API-kehityksen tasainen laatu ja jäljitettävyys",
+  "station.ci-cd.outcomes.2": "Nopeammat iteraatiot ja lyhyempi aika markkinoille saattamiseen",
+  "station.ci-cd.outcomes.3": "Parempi yhteistyö ja palautekierrokset API-kehityksessä",
+  "station.ci-cd.how_it_works.1": "Integroi toiminnallinen ja ei-toiminnallinen testaus CI/CD-putkeen varmistaaksesi, että rajapinnat täyttävät laatuvaatimukset.",
+  "station.ci-cd.how_it_works.2": "Toteuta automaattiset tietoturvatarkastukset ja vaatimustenmukaisuuden validoinnit CI/CD-putkessa varmistaaksesi, että rajapinnat ovat turvallisia ja vaatimustenmukaisia.",
+  "station.test-automation.outcomes.1": "Automaattiset toiminnalliset, turvallisuus- ja suorituskykytestit",
+  "station.test-automation.outcomes.2": "Vähentää manuaalisen testauksen työmäärää ja lisää testien kattavuutta",
+  "station.test-automation.outcomes.3": "APIn luotettavuuden ja laadun parantaminen",
+  "station.test-automation.how_it_works.1": "Toteuta testiautomaatiokehykset, jotka tukevat sopimustestausta, integrointitestausta ja päästä päähän -testausta.",
+  "station.test-automation.how_it_works.2": "Integroi automatisoidut testit CI/CD-putkeen API-laadun jatkuvan validoinnin varmistamiseksi.",
+  "station.release-management.outcomes.1": "Versiointi- ja käyttöönottostrategioiden määrittely",
+  "station.release-management.outcomes.2": "API-julkaisuja varten vahvistetut palautusmenettelyt",
+  "station.release-management.outcomes.3": "API-muutoksiin liittyvien riskien vähentäminen",
+  "station.release-management.how_it_works.1": "Ota käyttöön käyttöönottostrategioita (esim. sinivihreät käyttöönotot, canary releaset) API-julkaisuihin liittyvien riskien minimoimiseksi.",
+  "station.release-management.how_it_works.2": "Ota käyttöön palautusmenettelyt, jotta muutokset voidaan palauttaa nopeasti, jos API-julkaisujen aikana ilmenee ongelmia.",
+  "station.service-agreements.outcomes.1": "API-toimittajien ja hyödyntäjien odotukset ja palvelutasot kuvattuina",
+  "station.service-agreements.outcomes.2": "Dokumentoidut vastuualueet ja tukiprosessit",
+  "station.service-agreements.outcomes.3": "Parempi viestintä ja yhteistyö API-tiimien välillä",
+  "station.service-agreements.how_it_works.1": "Luo koneellisesti luettavia palvelusopimuksia, joita on helppo jakaa ja validoida, käyttämällä standardoituja muotoja.",
+  "station.service-agreements.how_it_works.2": "Varmistetaan, että sidosryhmät tarkistavat ja hyväksyvät palvelusopimukset, jotta varmistetaan niiden yhdenmukaisuus ja selkeys.",
+  "station.api-consumer-adoption.outcomes.1": "APIn käytön ja sitoutumisen lisääminen",
+  "station.api-consumer-adoption.outcomes.2": "APIn hyödyntäjät saavat tietoa APIn ominaisuuksista ja hyödyistä",
+  "station.api-consumer-adoption.outcomes.3": "Parempi API-hyödyntäjätyytyväisyys ja -uskollisuus",
+  "station.api-consumer-adoption.how_it_works.1": "Luo opetusmateriaalia (esim. opetusohjelmia, dokumentaatiota), jossa selitetään APIn ominaisuuksia, hyötyjä ja käyttötapoja.",
+  "station.api-consumer-adoption.how_it_works.2": "Ole vuorovaikutuksessa API-hyödyntäjien kanssa palautekierrosten, tukikanavien ja yhteisöfoorumien kautta, jotta heidän tarpeensa ymmärretään ja APIn käyttöönottoa voidaan parantaa.",
+  "station.api-promotion.outcomes.1": "APIn näkyvyyden ja tietoisuuden lisääminen",
+  "station.api-promotion.outcomes.2": "Korkeampi APIn käyttö- ja hyväksymisaste",
+  "station.api-promotion.outcomes.3": "Parempi API-hyödyntäjien sitoutuminen ja tyytyväisyys",
+  "station.api-promotion.how_it_works.1": "Luo myynninedistämismateriaalia (esim. tapaustutkimuksia, menestystarinoita), jossa korostetaan rajapintojen arvoa ja hyötyjä.",
+  "station.api-promotion.how_it_works.2": "Osallistu API-yhteisöihin ja -foorumeihin API-päivitysten jakamiseksi, palautteen keräämiseksi ja APIn käytön edistämiseksi.",
+  "station.partner-integration.outcomes.1": "Parannetut API-ominaisuudet kumppani-APIen avulla",
+  "station.partner-integration.outcomes.2": "Kumppanuuksien avulla laajennettu ulottuvuus ja markkinamahdollisuudet",
+  "station.partner-integration.outcomes.3": "Parempi yhteistyö ja innovointi kumppaneiden kanssa",
+  "station.partner-integration.how_it_works.1": "Luodaan integraatioprosessit ja -ohjeet yhteistyökumppaneiden kanssa tehtävää yhteistyötä varten, mukaan lukien tekninen integraatio, tietojen jakaminen ja tuki.",
+  "station.partner-integration.how_it_works.2": "Seuraa kumppaneiden API-suorituskykyä ja vaatimustenmukaisuutta varmistaaksesi luotettavuuden ja yhteensopivuuden API-strategiasi kanssa.",
+  "station.api-mindset.outcomes.1": "Innovaation ja yhteistyön lisääminen rajapintojen avulla",
+  "station.api-mindset.outcomes.2": "API-tiimit, joilla on valtuudet johtaa API-strategiaa ja -aloitteita.",
+  "station.api-mindset.outcomes.3": "Liiketoiminnan tavoitteiden ja API-kehityksen parempi yhteensovittaminen.",
+  "station.api-mindset.how_it_works.1": "Kannustaa API-tiimien, liiketoimintayksiköiden ja sidosryhmien välistä monialaista yhteistyötä, jotta API-aloitteet voidaan sovittaa yhteen liiketoiminnan tavoitteiden kanssa.",
+  "station.api-mindset.how_it_works.2": "Tarjotaan koulutusta ja resursseja, jotta tiimit voivat omaksua API-first -ajattelutavan ja ymmärtää APIen edut.",
+  "station.roles-and-responsibilities.outcomes.1": "Tehokas yhteistyö ja vastuuvelvollisuus API-tiimeissä",
+  "station.roles-and-responsibilities.outcomes.2": "Parempi viestintä ja yhdenmukaistaminen tiimin jäsenten välillä",
+  "station.roles-and-responsibilities.outcomes.3": "Sekaannusten ja päällekkäisyyksien vähentäminen vastuualueilla",
+  "station.roles-and-responsibilities.how_it_works.1": "Määritä selkeät vastuualueet kullekin roolille, mukaan lukien API-suunnittelu, kehittäminen, testaus ja toiminta.",
+  "station.roles-and-responsibilities.how_it_works.2": "Varmistaa, että roolit ja vastuualueet ilmoitetaan kaikille tiimin jäsenille ja sidosryhmille, jotta varmistetaan niiden yhdenmukaisuus.",
+  "station.upskilling.outcomes.1": "API-suunnittelun, -kehityksen ja -hallinnan lisääntynyt osaaminen.",
+  "station.upskilling.outcomes.2": "Parempi kyky omaksua uutta teknologiaa ja uusia käytäntöjä",
+  "station.upskilling.outcomes.3": "Valtuutetaan tiimit edistämään API-innovaatioita ja laatua.",
+  "station.operating-guidelines.outcomes.1": "Yhdenmukainen API-hallinta ja laatu koko organisaatiossa",
+  "station.operating-guidelines.outcomes.2": "organisaation standardien ja parhaiden käytäntöjen noudattaminen",
+  "station.operating-guidelines.outcomes.3": "Parempi näkyvyys ja API-aloitteiden hallinta",
+  "station.operating-guidelines.how_it_works.1": "Ota käyttöön hallintokäytännöt, joilla varmistetaan, että rajapintoja hallinnoidaan johdonmukaisesti, mukaan lukien tarkistukset, auditoinnit ja vaatimustenmukaisuuden tarkastukset.",
+  "station.operating-guidelines.how_it_works.2": "Seuraa API-aloitteita varmistaaksesi toimintaohjeiden ja hallintokäytäntöjen noudattamisen.",
+  "station.portfolio-management.outcomes.1": "APIt linjassa liiketoiminnan tavoitteiden ja strategisten aloitteiden kanssa.",
+  "station.portfolio-management.outcomes.2": "APIen priorisointi ja optimointi arvon ja vaikutusten perusteella.",
+  "station.portfolio-management.outcomes.3": "Parempi näkyvyys ja API-portfolion hallinta",
+  "station.budget-and-resource-management.outcomes.1": "Resurssien tehokas kohdentaminen API-aloitteisiin",
+  "station.budget-and-resource-management.outcomes.2": "Optimoidut investoinnit API-kehitykseen ja -hallintaan",
+  "station.budget-and-resource-management.outcomes.3": "Parempi taloudellinen näkyvyys ja API-aloitteiden valvonta.",
+  "cycle.api-productization-cycle.station.api-product-strategy.title": "API-tuotestrategia - Tee rajapinnoista strategisia tuotteita",
+  "cycle.api-productization-cycle.station.api-product-strategy.description": "Ennen kuin rakennat mitään, määrittele APIn arvo, hyödyntäjät ja liiketoiminnalliset tavoitteet heti alusta alkaen.",
+  "cycle.api-productization-cycle.station.api-product-strategy.why_it_matters": "Monet organisaatiot pitävät rajapintoja teknisinä projekteina, eivät tuotteina. Tulos? Hämmentyneitä hyödyntäjiä, heikkoa käyttöönottoa ja turhaa työtä. Tämä asema auttaa määrittelemään APIn tarkoituksen, kohderyhmän ja menestyskriteerit, jotta tiimit voivat tuottaa rajapintoja, jotka ratkaisevat todellisia ongelmia.",
+  "cycle.api-productization-cycle.station.api-product-strategy.apply_in_work": "Tarjotaan ohjeita ja malleja API-liiketoimintamallien, arvolupausten ja etenemissuunnitelmien luomista varten.",
+  "cycle.api-productization-cycle.station.api-product-strategy.outcomes": "Suoraviivainen API-arvolupaus ja yleisö",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works": "Tutki asiakkaan tai yhteistyökumppanin ongelmaa, jonka oletat voivasi ratkaista APIen avulla. Kartoita sidosryhmät, niiden matkat ja tulokset Customer Journey canvasin avulla.",
+  "cycle.api-productization-cycle.station.api-product-strategy.outcomes.1": "Yhteinen kieli tuotteen, suunnittelun ja tekniikan välillä",
+  "cycle.api-productization-cycle.station.api-product-strategy.outcomes.2": "vankka esitys tai peruste rahoituksen/hyväksynnän saamiseksi.",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works.1": "Määrittele keskeiset entiteetit, niiden ominaisuudet ja suhteet, jotta voidaan luoda yhteinen käsitteellinen ymmärrys eri matkojen ja lopulta APIen välille.",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works.2": "Käytä API Value Proposition Canvas -pohjaa tuettujen liiketoimintatehtävien sekä API-hyödyntäjien ongelmien, hyötyjen ja ominaisuuksien kuvaamiseen. Nämä ohjaavat uusien tai uudelleenkäytettävien API-rajapintojen muotoilua.",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works.3": "Määrittele arvo API-hyödyntäjille ja liiketoiminnalle API Business Model Canvas -pohjan avulla, jotta API-strategiasta tulee visuaalinen, jaettava ja helposti validoitava seuraavalla asemalla.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.title": "API-hyödyntäjäkokemus - Suunnittele APIn todellisia hyödyntäjiä varten",
+  "cycle.api-productization-cycle.station.api-consumer-experience.description": "Varmistetaan, että API on löydettävissä, ymmärrettävissä ja käyttökelpoinen ennen käyttöönottoa ja sen jälkeen.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.why_it_matters": "Hyvät aPIt eivät ainoastaan toimi - ne tuntuvat intuitiivisilta. Riippumatta siitä, onko hyödyntäjä sisäinen kehittäjä, ulkoinen kumppani vai tekoälyagentti, heidän kokemuksensa ratkaisee hyväksynnän. Ilman selkeää kokemussuunnitelmaa",
+  "cycle.api-productization-cycle.station.api-consumer-experience.how_it_works": "Tarkastele olemassa olevaa API Value Proposition Canvasta API-hyödyntäjän näkökulmasta. Säilytä tuetut liiketoimintatehtävät vakaina ja rikasta tuskaa lievittäviä ja hyötyjä mahdollistavia ominaisuuksia API-hyödyntäjien näkökulmalla, jotta ne voivat ohjata myöhempiä suunnittelupäätöksiä.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.how_it_works.1": "Käytä Customer Journey Canvas -pohjaa API-hyödyntäjän matkan kuvaamiseen löytämisestä ja arvioinnista käyttöönottoon, integrointiin, vianmääritykseen ja jatkuvaan käyttöön.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.how_it_works.2": "Käytä tuloksena saatua polkua parantaaksesi käyttöönottoa, dokumentaatiota, tukea ja palautesilmukoita API-hyödyntäjille.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.apply_in_work": "Tarjotaan ohjeita, työkaluja ja palautemekanismeja sisäisten ja ulkoisten kehittäjien ja kumppaneiden kokemusten ymmärtämiseksi, analysoimiseksi ja parantamiseksi.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes": "Tunnista ja priorisoi API-asiakkaat",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes.1": "Määrittele API-kokemuksen matka",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes.2": "Suunnittele sisäänajo, dokumentointi ja palaute",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes.3": "Paranna hyväksyntää aidon empatian ja kehittäjäkokemuksen (DX) avulla.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.title": "API-alustan arkkitehtuuri",
+  "cycle.api-productization-cycle.station.api-platform-architecture.description": "Varmistetaan skaalautuvuus, uudelleenkäyttö ja hallinta API- ja alustakomponenttien välillä.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.why_it_matters": "Kun rajapinnat skaalautuvat eri tiimeille, alustan on mahdollistettava hallinta ja uudelleenkäyttö nopeutta estämättä. Tällä asemalla kerrotaan, miten API-arkkitehtuurit voidaan suunnitella pitkäikäisiksi, turvallisiksi ja tehokkaiksi.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.apply_in_work": "Perustetaan skaalautuva, turvallinen ja vaatimustenmukainen infrastruktuuri API-toimintoja varten. Annetaan ohjeita arkkitehtuurin parhaista käytännöistä.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.outcomes": "Vähennä turhia API-rajapintoja ja vähennä pilvialustakustannuksia.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works": "Business Impact Canvas auttaa tunnistamaan ja lieventämään APIn saatavuuteen, tietoturvaan ja toiminnallisuuteen liittyviä riskejä ja tukemaan tietoon perustuvia arkkitehtuuripäätöksiä.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.outcomes.1": "Johdonmukaisen hallinnon toteuttaminen ilman raskasta ylhäältä alaspäin suuntautuvaa valvontaa",
+  "cycle.api-productization-cycle.station.api-platform-architecture.outcomes.2": "Suunnittelu sisäistä uudelleenkäyttöä ja ulkoista skaalautuvuutta varten",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works.1": "Kartoita API-palveluntarjoajien ja hyödyntäjien sääntely-, vaatimustenmukaisuus- ja verkkoasiointipaikat käytettävyyden ja vaatimustenmukaisuuden varmistamiseksi.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works.2": "Capacity Canvas -ohjelmassa sovitetaan yhteen liiketoimintatapahtumien mallit, tulevat kulutustrendit ja tekniset ratkaisut, jotta voidaan varmistaa APIn skaalautuvuus ja suorituskyky. Se tarjoaa kriittisen panoksen skaalautumispäätöksiä ja infrastruktuurin suunnittelua varten.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works.3": "Määrittele ja seuraa suorituskykymittareita (esim. API-kutsut, viiveet, virhetasot) ja hyväksyntämittareita (esim. NPS).",
+  "cycle.api-productization-cycle.station.api-design.title": "API-design - Suunnittele arvoa tuottavia rajapintoja",
+  "cycle.api-productization-cycle.station.api-design.description": "Luo API-suunnitelmia, jotka ovat johdonmukaisia, uudelleenkäytettäviä ja perustuvat liiketoiminnallisiin tavoitteisiin sekä yhteisiin standardeihin.",
+  "cycle.api-productization-cycle.station.api-design.why_it_matters": "APIen suunnittelu ei tarkoita pelkästään päätepisteiden (endpoints) nimeämistä. Hyvä suunnittelu varmistaa, että APIt ovat käyttökelpoisia, johdonmukaisia ja linjassa liiketoiminnallisten ja teknisten tavoitteiden kanssa. Huono suunnittelu johtaa tiukkoihin riippuvuuksiin, heikkoon uudelleenkäytettävyyteen ja kalliiseen uudelleen toteutukseen eri tiimien välillä.",
+  "cycle.api-productization-cycle.station.api-design.apply_in_work": "Tarjoa uudelleenkäytettäviä suunnittelumalleja, yhteisiä standardeja ja validointityökaluja API-määrityksille. Varmista, että suunnittelupäätökset ovat johdonmukaisia, tarkistettuja varhaisessa vaiheessa ja linjassa liiketoiminnallisten tavoitteiden kanssa.",
+  "cycle.api-productization-cycle.station.api-design.outcomes": "Hyvin dokumentoidut ja johdonmukaiset API-mallit",
+  "cycle.api-productization-cycle.station.api-design.how_it_works": "Määrittele keskeiset oliot, niiden attribuutit ja suhteet yhteisen käsitteellisen ymmärryksen luomiseksi eri rajapinnoille.",
+  "cycle.api-productization-cycle.station.api-design.outcomes.1": "Uudelleenkäytettävät ja validoidut API-sopimukset",
+  "cycle.api-productization-cycle.station.api-design.outcomes.2": "Toimialamallien ja vuorovaikutusmallien mukaiset mallit",
+  "cycle.api-productization-cycle.station.api-design.outcomes.3": "Suunnittelun jäljitettävyys liiketoiminnan arvoon",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.1": "Määrittele Interaction Canvasin avulla, miten hyödyntäjät ovat vuorovaikutuksessa APIn kanssa, ja Varmistetaan, että se vastaa heidän tarpeitaan ja odotuksiaan.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.2": "Sovellat REST-suunnittelumalleja luodaksesi johdonmukaisia, uudelleenkäytettäviä API-sopimuksia, jotka validoidaan sidosryhmien kanssa.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.3": "Sovellat tapahtumapohjaisia suunnittelumalleja luodaksesi johdonmukaisia, uudelleenkäytettäviä API-sopimuksia, jotka validoidaan sidosryhmien kanssa.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.4": "Sovellat GraphQL-suunnittelumalleja luodaksesi johdonmukaisia, uudelleenkäytettäviä API-sopimuksia, jotka validoidaan sidosryhmien kanssa.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.5": "Käytä suunnitteluperiaatteita ja API-tyyliohjetta, jotta suunnittelupäätöksesi ovat linjassa yhteisten sääntöjen kanssa ja mahdollistavat johdonmukaisen auditoinnin ja validoinnin.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.6": "Varmistetaan API-auditoinnin tarkistuslistan avulla, että API-suunnittelu täyttää toiminnalliset ja muut kuin toiminnalliset vaatimukset, mukaan lukien tietoturva, suorituskyky ja vaatimustenmukaisuus.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.7": "Käytä API-tarkastuslistaa varmistaaksesi, että API-suunnittelu täyttää toiminnalliset ja ei-toiminnalliset vaatimukset, mukaan lukien turvallisuus, suorituskyky ja vaatimustenmukaisuus.",
+  "cycle.api-productization-cycle.station.api-delivery.title": "API-kehitys - Kehitä turvalliset ja luotettavat rajapinnat",
+  "cycle.api-productization-cycle.station.api-delivery.description": "Rakenna, testaa ja julkaise rajapintoja käyttämällä nykyaikaisia jakeluputkia ja parhaita teknisiä käytäntöjä.",
+  "cycle.api-productization-cycle.station.api-delivery.why_it_matters": "Parhaatkin API-suunnitelmat epäonnistuvat, jos kehitys on epäjohdonmukaista. Tällä asemalla varmistetaan, että rajapinnat rakennetaan laadukkaasti, testataan perusteellisesti ja otetaan käyttöön luotettavasti, mikä mahdollistaa nopeammat iteraatiot ja suuremman luottamuksen.",
+  "cycle.api-productization-cycle.station.api-delivery.apply_in_work": "Toimittaa koodauskehyksiä, kirjastoja ja standardeja API-toteutusta varten. CI/CD-putkien, laadunvarmistuskehysten ja käyttöönottoautomaatiotyökalujen toteuttaminen.",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes": "Rajapinnat, jotka on toteutettu testattujen kehysten ja mallien avulla.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works": "Käytä API-kehityksen parhaita käytäntöjä ohjeena validoidun sopimuksen toteuttamiseen vakiintuneilla kehysrakenteilla ja kirjastoilla varmistaen, että tulos on uudelleenkäytettävä ja ylläpidettävä.",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes.1": "Luotettavat ja automatisoidut CI/CD-putket",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes.2": "Toiminnallinen ja ei-toiminnallinen testaus integroitu",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes.3": "Turvalliset ja vaatimustenmukaiset kehitysputket",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.1": "Rakenna API-toteutus validoidun sopimuksen pohjalta käyttäen vakiintuneita kehysrakenteita, kirjastoja ja tiimin standardeja.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.2": "Testaa rajapintojen toimivuutta, turvallisuutta ja suorituskykyä automaattisten testausvälineiden avulla.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.3": "Käytetään CI/CD-putkia rakentamis-, testaus- ja käyttöönottoprosessien automatisoimiseksi varmistaen johdonmukaisen laadun ja jäljitettävyyden.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.4": "Varmistetaan, että rajapinnat täyttävät turvallisuus- ja vaatimustenmukaisuusvaatimukset automaattisten tarkastusten ja auditointien avulla.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.5": "Varmistetaan API-auditoinnin tarkistuslistan avulla, että API täyttää toiminnalliset ja muut kuin toiminnalliset vaatimukset, mukaan lukien tietoturva, suorituskyky ja vaatimustenmukaisuus.",
+  "cycle.api-productization-cycle.station.api-audit.title": "API-auditointi - API-rajapintojen tarkastus vaatimustenmukaisuuden ja laadun varmistamiseksi",
+  "cycle.api-productization-cycle.station.api-audit.description": "Varmista, että APIt täyttävät liiketoiminta-, suunnittelu- ja toimintastandardit ennen julkaisua ja käyttöönottoa.",
+  "cycle.api-productization-cycle.station.api-audit.why_it_matters": "APIt ovat pitkäikäisiä tuotteita, ja niiden on täytettävä laatu-, johdonmukaisuus- ja vaatimustenmukaisuusodotukset. Auditointi yhdistää suunnittelupäätökset, toteutuksen ja toimintavalmiuden määriteltyihin standardeihin, mikä vähentää riskejä ennen käyttöönottoa.",
+  "cycle.api-productization-cycle.station.api-audit.apply_in_work": "Luo johdonmukainen auditointiprosessi, joka arvioi APIn valmiutta elinkaaren eri vaiheissa määriteltyjen kriteerien, todisteiden ja standardien avulla. Varmista, että puutteet tunnistetaan varhaisessa vaiheessa ja korjataan ennen julkaisua.",
+  "cycle.api-productization-cycle.station.api-audit.outcomes": "APIt täyttävät sisäiset ja ulkoiset standardit",
+  "cycle.api-productization-cycle.station.api-audit.how_it_works": "Suorita tarkastuksia varmistaaksesi, että rajapinnat täyttävät organisatoriset, tekniset ja oikeudelliset standardit ennen julkaisemista.",
+  "cycle.api-productization-cycle.station.api-audit.outcomes.1": "Selkeä dokumentaatio API-suunnittelusta ja toteutuspäätöksistä",
+  "cycle.api-productization-cycle.station.api-audit.outcomes.2": "Turvallisuus, suorituskyky ja vaatimustenmukaisuus validoitu",
+  "cycle.api-productization-cycle.station.api-audit.outcomes.3": "Tuotannossa ilmenevien ongelmien riskin pienentäminen",
+  "cycle.api-productization-cycle.station.api-audit.how_it_works.1": "Käytä tarkistuslistoja, automatisoituja tarkistustyökaluja eli linttereitä ja testausvälineitä varmistaaksesi johdonmukaisuuden ja standardien noudattamisen.",
+  "cycle.api-productization-cycle.station.api-audit.how_it_works.2": "Tee yhteistyötä hallintotiimien ja toimialan asiantuntijoiden kanssa varmistaaksesi, että rajapinnat ovat valmiita tuotantoon.",
+  "cycle.api-productization-cycle.station.api-publishing.title": "API-julkaiseminen - Julkaise APIt luotettavasti",
+  "cycle.api-productization-cycle.station.api-publishing.description": "Esittele APIt turvallisesti ja selkeästi oikealle yleisölle oikean dokumentaation ja prosessien avulla.",
+  "cycle.api-productization-cycle.station.api-publishing.why_it_matters": "Julkaiseminen on muutakin kuin käyttöönottoa - kyse on löydettävyydestä, saatavuudesta ja tuesta. Jos rajapintoja ei julkaista oikein, niitä ei käytetä, käytetä uudelleen tai suojata tehokkaasti.",
+  "cycle.api-productization-cycle.station.api-publishing.apply_in_work": "Mahdollistetaan APIen julkaiseminen asiaankuuluvassa ympäristössä ja selkeät rekisteröinti- ja käyttöoikeusmekanismit (esim. API-avaimet, OAuth, tilaussuunnitelmat) API-hyödyntäjäsegmenttien sekä turvallisuus- ja vaatimustenmukaisuusvaatimusten mukaan.",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes": "APIt julkaistaan oikeassa ympäristössä (yksityinen, kumppani, julkinen).",
+  "cycle.api-productization-cycle.station.api-publishing.how_it_works": "Julkaise rajapinnat asianmukaisiin yhdyskäytäviin ja ympäristöihin, jotta ne ovat uudelleenkäytettävissä useille API-hyödyntäjille.",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes.1": "Selkeät API-käyttöönotto- ja rekisteröintiprosessit",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes.2": "Dokumentaatio, turvallisuusmallit ja -käytännöt saatavilla",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes.3": "APIt valmiina skaalautumiseen ja hallintaan",
+  "cycle.api-productization-cycle.station.api-publishing.how_it_works.1": "Dokumentoi, miten hyödyntäjät löytävät ja käyttävät rajapintaa, mukaan lukien sisäänkirjautumisprosessit ja rekisteröinti.",
+  "cycle.api-productization-cycle.station.api-publishing.how_it_works.2": "Varmista, että turvamallit, yhdyskäytävän kokoonpano ja oikeudelliset ehdot ovat selkeitä ja hyödyntäjien saatavilla.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.title": "Seuranta ja parantaminen - API-arvoa varten",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.description": "Käytä mittareita ja palautetta API-suorituskyvyn seuraamiseen ja jatkuvan parantamisen edistämiseen.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.why_it_matters": "API-kehitys ei lopu käynnistykseen. Ilman seurantaa tiimit eivät voi parantaa käyttöönottoa, suorituskykyä tai ROI",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.apply_in_work": "Ota käyttöön analytiikkakehykset suorituskyvyn ja sitoutumisen seuraamiseksi. Kehitetään palautesilmukoita, analytiikkatyökaluja ja sitouttamisstrategioita API-rajapintoja varten.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes": "Suorituskyvyn ja käytön mittarit määritellään ja niitä seurataan.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.how_it_works": "Seuraa suorituskykymittareita (esim. API-kutsut, viiveet, virhetasot) ja hyväksyntämittareita (esim. NPS).",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes.1": "Kehittäjien palautekierrokset käytössä",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes.2": "Jatkuvasti tunnistetut ja käsitellyt ongelmat",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes.3": "APIn iterointi hyödyntäjien tarpeiden mukaisesti",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.how_it_works.1": "Analysoi APIn käyttömittareita ja ota hyödyntäjien palaute huomioon API-iteraatioissa.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.how_it_works.2": "Ota tavaksi tarkastella mittareita ja suunnitella jatkuvan parantamisen toimia."
 }
diff --git a/src/data/method/fr/labels.criteria.json b/src/data/method/fr/labels.criteria.json
index be8b511..c40e9cd 100644
--- a/src/data/method/fr/labels.criteria.json
+++ b/src/data/method/fr/labels.criteria.json
@@ -1,25 +1,26 @@
 {
   "exit_criteria": "Critères de sortie",
   "entry_criteria": "Critères d'entrée",
-  "criterion.metrics-feedback-available": "Des signaux de marché pertinents, des retours d'expérience ou des informations opérationnelles sont disponibles pour guider cette opportunité d'API.",
-  "criterion.business-goals-defined": "Les objectifs commerciaux sont définis.",
-  "criterion.market-research-done": "Une étude de marché identifie les opportunités en matière d'API.",
-  "criterion.stakeholder-approval": "Les parties prenantes pertinentes conviennent que cette opportunité d'API vaut la peine d'être explorée et priorisée.",
-  "criterion.api-opportunity-documented": "Les opportunités individuelles en matière d'API sont identifiées et documentées.",
-  "criterion.api-reusability": "L'API répond à un besoin commercial clair et est réutilisable par plusieurs consommateurs d'API.",
-  "criterion.hide-backend-discrepancies": "L'API est destinée à protéger les consommateurs de la complexité et des incohérences du backend.",
-  "criterion.value-prop-validated": "La proposition de valeur de l'API a été examinée et validée avec les parties prenantes commerciales et de consommateurs pertinentes.",
-  "criterion.consumer-segments-identified": "Les segments d'utilisateurs de l'API (internes et externes) sont identifiés.",
-  "criterion.api-roadmap-defined": "Des feuilles de route de haut niveau pour le développement de l'API sont établies.",
-  "criterion.architecture-patterns-validated": "Les modèles d'architecture et de plateforme API choisis ont été validés avec les parties prenantes d'architecture, de sécurité et de plateforme pertinentes.",
-  "criterion.design-reflects-business-value": "La conception de l'API et ses capacités exposées reflètent clairement la valeur commerciale et les besoins des utilisateurs.",
-  "criterion.api-consistency": "La conception de l'API suit nos conventions partagées pour le produit API et la conception.",
-  "criterion.api-contract-tested": "Le contrat d'API est testé et répond aux exigences fonctionnelles et non fonctionnelles.",
-  "criterion.api-description-available": "L'API et ses capacités exposées sont décrites de manière suffisante pour être examinées, auditées et intégrées.",
-  "criterion.audit-passed": "L'API passe avec succès les contrôles de conformité, de sécurité et d'audit.",
-  "criterion.audit-reports-shared": "Les résultats de l'audit et les décisions de correction sont partagés avec les parties prenantes pertinentes.",
-  "criterion.api-ready-for-publishing": "L'API est prête à être déployée et exposée via les passerelles et environnements prévus.",
-  "criterion.api-documentation-ready": "La documentation API destinée aux utilisateurs est suffisamment complète pour la publication et l'intégration.",
-  "criterion.consumer-support-ready": "Les processus d'enregistrement, de support et de communication sont prêts pour les utilisateurs de l'API.",
-  "criterion.legal-compliance-clear": "Les exigences légales, de confidentialité et de conformité pour la publication sont définies et comprises."
-}
\ No newline at end of file
+  "criterion.metrics-feedback-available": "Des signaux de marché pertinents, des retours d'expérience ou des informations opérationnelles sont disponibles pour guider cette opportunité de capacité.",
+  "criterion.business-goals-defined": "Les objectifs métier sont définis.",
+  "criterion.market-research-done": "L'étude de marché identifie des opportunités de capacité.",
+  "criterion.stakeholder-approval": "Les parties prenantes concernées conviennent que cette opportunité de capacité mérite d'être explorée et priorisée.",
+  "criterion.api-opportunity-documented": "L'opportunité de capacité est identifiée et documentée.",
+  "criterion.api-reusability": "La capacité répond à un besoin métier clair et peut être réutilisée par les utilisateurs prévus.",
+  "criterion.hide-backend-discrepancies": "L’interface choisie fournit une abstraction appropriée aux utilisateurs.",
+  "criterion.value-prop-validated": "La proposition de valeur de la capacité a été validée avec les parties prenantes métier et utilisateurs.",
+  "criterion.consumer-segments-identified": "Les segments d'utilisateurs sont identifiés.",
+  "criterion.api-roadmap-defined": "Une feuille de route de haut niveau pour la mise en œuvre est définie.",
+  "criterion.architecture-patterns-validated": "L'architecture, la plateforme et le mode de mise en œuvre choisis ont été validés avec les parties prenantes concernées en architecture, sécurité et plateforme.",
+  "criterion.design-reflects-business-value": "La conception de l'interface et les capacités exposées sont clairement reliées à la valeur métier et aux besoins des utilisateurs.",
+  "criterion.api-consistency": "La conception de l'interface respecte les standards partagés de produit, de conception et de qualité.",
+  "criterion.api-contract-tested": "Le contrat d'interface a été validé et testé par rapport aux exigences fonctionnelles et non fonctionnelles.",
+  "criterion.automation-workflow-validated": "Le workflow, les règles, les intégrations et les contrats d’interface pertinents ont été validés et testés.",
+  "criterion.api-description-available": "L’interface et ses capacités sont documentées de manière suffisamment claire pour la revue, l’audit et l’onboarding.",
+  "criterion.audit-passed": "La solution réussit les contrôles de qualité, de sécurité, de conformité et de préparation.",
+  "criterion.audit-reports-shared": "Les résultats d'audit et les décisions de correction sont partagés avec les parties prenantes concernées.",
+  "criterion.api-ready-for-publishing": "La capacité est prête à être publiée ou mise à disposition via le mécanisme de livraison choisi.",
+  "criterion.api-documentation-ready": "La documentation et les supports d'onboarding destinés aux utilisateurs sont prêts.",
+  "criterion.consumer-support-ready": "Les processus d'onboarding, de support et de communication sont prêts pour les utilisateurs.",
+  "criterion.legal-compliance-clear": "Les exigences juridiques, de confidentialité et de conformité liées à la publication ou à la mise à disposition sont définies et comprises."
+}
diff --git a/src/data/method/fr/labels.cycles.json b/src/data/method/fr/labels.cycles.json
new file mode 100644
index 0000000..80b6d17
--- /dev/null
+++ b/src/data/method/fr/labels.cycles.json
@@ -0,0 +1,107 @@
+{
+  "cycles.title": "Vues de cycle",
+  "cycles.description": "Vues adaptées aux publics sur le méthode APIOps Cycles.",
+  "cycle.capability-productization-cycle.title": "Cycle de productisation des capacités",
+  "cycle.capability-productization-cycle.description": "Cycle pour transformer des capacites metier en capacites numeriques reutilisables avant de choisir le mode de mise en oeuvre.",
+  "cycle.capability-productization-cycle.purpose": "Identifier et productiser des capacites numeriques reutilisables avant de choisir un mode de mise en oeuvre API, evenement, fichier, flux, produit de donnees, service avec IA, integration directe ou hybride.",
+  "cycle.api-productization-cycle.title": "Cycle de productisation des API",
+  "cycle.api-productization-cycle.description": "Parcours APIOps Cycles centré sur les API pour productiser, concevoir, livrer, publier et améliorer des produits API.",
+  "cycle.api-productization-cycle.purpose": "Parcours méthodologique centré sur les API pour les équipes qui savent déjà que le mode de mise en œuvre prévu est un produit API.",
+  "cycle.integration-productization-cycle.title": "Cycle de productisation des capacités d’intégration",
+  "cycle.integration-productization-cycle.description": "Cycle pour productiser des capacites d integration reutilisables avant de choisir le mode de mise en oeuvre.",
+  "cycle.integration-productization-cycle.purpose": "Guider la conception de capacites d integration reutilisables avant de choisir un mode de mise en oeuvre API, evenement, fichier, flux, produit de donnees, integration directe ou hybride.",
+  "cycle.station.capability-strategy": "Stratégie de capacité",
+  "cycle.station.consumer-requirements-onboarding": "Exigences utilisateurs & onboarding",
+  "cycle.station.architecture-platform-decisions": "Architecture & décisions de plateforme",
+  "cycle.station.solution-interface-design": "Conception de solution & d’interface",
+  "cycle.station.delivery-operations": "Mise à disposition & opérations",
+  "cycle.station.quality-readiness-assurance": "Assurance qualité & préparation",
+  "cycle.station.publishing-enablement": "Publication & enablement",
+  "cycle.station.monitoring-improvement": "Suivi & amélioration",
+  "cycle.station.api-product-strategy": "Stratégie produit API",
+  "cycle.station.api-consumer-experience": "Expérience utilisateur API",
+  "cycle.station.api-platform-architecture": "Architecture de plateforme API",
+  "cycle.station.api-design": "Conception d’API",
+  "cycle.station.api-delivery": "Livraison d’API",
+  "cycle.station.api-audit": "Audit API",
+  "cycle.station.api-publishing": "Publication d’API",
+  "cycle.station.monitoring-and-improving": "Suivi & amelioration API",
+  "cycle.station.integration-capability-strategy": "Stratégie de capacité d’intégration",
+  "cycle.station.integration-consumer-requirements-onboarding": "Exigences des utilisateurs d’intégration & onboarding",
+  "cycle.station.integration-architecture-decision": "Architecture d integration & decisions de plateforme",
+  "cycle.station.integration-solution-design": "Conception de solution d’intégration",
+  "cycle.station.integration-delivery-operations": "Livraison & opérations d’intégration",
+  "cycle.station.integration-readiness-assurance": "Assurance qualité des intégrations",
+  "cycle.station.capability-publishing": "Publication & enablement de l integration",
+  "cycle.station.integration-monitoring-improvement": "Suivi & amélioration des intégrations",
+  "cycle.capability-productization-cycle.station.api-product-strategy.description": "Cadrer le besoin metier comme une capacite reutilisable avec une valeur, des utilisateurs, une responsabilite et des objectifs metier clairs avant de choisir le mode de mise en oeuvre.",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.description": "Capturez les exigences des utilisateurs, les besoins d’onboarding, les contraintes, les attentes de service et les responsabilités des fournisseurs.",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.description": "Utiliser les exigences et contraintes pour choisir le mode de mise en oeuvre, le pattern d architecture et les capacites de plateforme necessaires.",
+  "cycle.capability-productization-cycle.station.api-design.description": "Concevoir le contrat d interface et le modele d interaction pour le mode de mise en oeuvre choisi.",
+  "cycle.capability-productization-cycle.station.api-delivery.description": "Construire, tester, deployer et exploiter la capacite avec le mode de mise en oeuvre choisi et le contrat d interface valide.",
+  "cycle.capability-productization-cycle.station.api-audit.description": "Valider le contrat d interface, les controles, la documentation, le modele de support et la preparation operationnelle avant publication.",
+  "cycle.capability-productization-cycle.station.api-publishing.description": "Publier la capacite afin que les utilisateurs puissent la decouvrir, l evaluer, demander l acces, terminer l onboarding, l utiliser et obtenir du support.",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.description": "Suivez la santé de la capacité, les résultats utilisateurs, la fiabilité, la réutilisation et les opportunités d’amélioration.",
+  "cycle.owner.business-owner": "Responsable métier",
+  "cycle.owner.domain-expert": "Expert domaine",
+  "cycle.owner.capability-owner": "Responsable de capacité",
+  "cycle.owner.consumer-representative": "Représentant des utilisateurs",
+  "cycle.owner.enterprise-architect": "Architecte d’entreprise",
+  "cycle.owner.platform-owner": "Responsable plateforme",
+  "cycle.owner.api-product-owner": "Product owner API",
+  "cycle.owner.api-platform-owner": "Responsable plateforme API",
+  "cycle.owner.integration-architect": "Architecte d’intégration",
+  "cycle.owner.solution-architect": "Architecte solution",
+  "cycle.template.intent-fit.title": "Intention & adéquation",
+  "cycle.template.intent-fit.description": "Capturez le résultat métier, les utilisateurs, les fournisseurs, le périmètre, les contraintes et le statut de décision.",
+  "cycle.template.requirements.title": "Exigences",
+  "cycle.template.requirements.description": "Collectez les contributions d’experts à l’aide des questions recommandées. Traitez les réponses comme des entrées pour les décisions de conception, et non comme des décisions finales.",
+  "cycle.template.architecture-decision.title": "Décision d’architecture",
+  "cycle.template.architecture-decision.description": "Comparez les choix d’architecture viables par rapport aux exigences, preuves, risques et questions ouvertes.",
+  "cycle.template.api-architecture-decision.title": "Décision d’architecture API",
+  "cycle.template.api-architecture-decision.description": "Documentez les décisions relatives à l’architecture API, à la plateforme, à la sécurité, au cycle de vie et à la publication.",
+  "cycle.template.integration-pattern-decision.title": "Décision de modèle d’intégration",
+  "cycle.template.integration-pattern-decision.description": "Comparez API, événements, fichiers, flux, produits de données, intégration directe et options hybrides par rapport aux exigences.",
+  "cycle.template.human-validation.title": "Validation humaine",
+  "cycle.template.human-validation.description": "Documentez qui valide les résultats assistés par l’IA et quelles décisions nécessitent une responsabilité humaine.",
+  "cycle.template.adr.title": "Architecture Decision Record",
+  "cycle.template.adr.description": "Documentez la décision choisie, la justification, les alternatives, les conséquences, les preuves et les actions de suivi.",
+  "cycle.api-productization-cycle.station.api-product-strategy.description": "Cadrez l’API comme un produit avec une proposition de valeur claire, des utilisateurs, un modèle économique, une responsabilité et une intention de cycle de vie.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.description": "Définissez les segments d’utilisateurs API, les parcours d’onboarding, les attentes et les exigences d’expérience avant de verrouiller les décisions de conception.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.description": "Choisissez et validez la plateforme API, l’architecture, la gouvernance et les contraintes opérationnelles nécessaires au produit.",
+  "cycle.api-productization-cycle.station.api-design.description": "Concevez le contrat d’interface API, le modèle d’interaction, les schémas, les politiques et les détails d’utilisabilité avant l’implémentation.",
+  "cycle.api-productization-cycle.station.api-delivery.description": "Implémentez, testez, sécurisez, automatisez et exploitez le produit API via le pipeline de livraison.",
+  "cycle.api-productization-cycle.station.api-audit.description": "Valider la qualite API, la conformite, les preuves, la preparation operationnelle et les criteres de publication.",
+  "cycle.api-productization-cycle.station.api-publishing.description": "Publier le produit API afin que les utilisateurs puissent le decouvrir, l evaluer, demander l acces, terminer l onboarding, l utiliser et obtenir du support.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.description": "Suivez la santé de l’API, l’adoption, les résultats utilisateurs, la fiabilité et les opportunités d’amélioration après publication.",
+  "cycle.integration-productization-cycle.station.api-product-strategy.description": "Cadrer la capacite d integration reutilisable, le besoin metier, la responsabilite et la reutilisation attendue avant de choisir le mode de mise en oeuvre.",
+  "cycle.integration-productization-cycle.station.api-consumer-experience.description": "Capturez les utilisateurs d’intégration, les responsabilités des fournisseurs, les besoins d’onboarding, les attentes de service et les contraintes opérationnelles.",
+  "cycle.integration-productization-cycle.station.api-platform-architecture.description": "Choisir l architecture d integration, le mode de mise en oeuvre et les capacites de plateforme en tenant compte des contraintes et du modele de gouvernance.",
+  "cycle.integration-productization-cycle.station.api-design.description": "Concevoir le contrat d interface, les schemas, les payloads et les modeles d interaction pour le style d integration choisi.",
+  "cycle.integration-productization-cycle.station.api-delivery.description": "Construire, tester, automatiser, deployer et exploiter la capacite d integration avec le mode de mise en oeuvre choisi et le contrat d interface valide.",
+  "cycle.integration-productization-cycle.station.api-audit.description": "Assurez la préparation, la gouvernance, la qualité, la sécurité, la conformité et les preuves opérationnelles de l’intégration avant publication.",
+  "cycle.integration-productization-cycle.station.api-publishing.description": "Publier la capacite d integration afin que les equipes puissent la decouvrir, l evaluer, demander l acces, terminer l onboarding, la reutiliser et obtenir du support.",
+  "cycle.integration-productization-cycle.station.monitoring-and-improving.description": "Suivez la fiabilité, la réutilisation, les incidents, la performance, les résultats utilisateurs et les besoins d’amélioration de l’intégration.",
+  "cycle.automation-cycle.title": "Cycle d’automatisation",
+  "cycle.automation-cycle.description": "Cycle pour identifier, concevoir, livrer, enable et améliorer des opportunités d’automatisation.",
+  "cycle.automation-cycle.purpose": "Productiser les opportunités d’automatisation en workflows gouvernés avec des utilisateurs, plateformes, contrôles, chemins de livraison, enablement et suivi clairement définis.",
+  "cycle.audience.automation-owners": "Responsables automatisation",
+  "cycle.audience.process-owners": "Responsables de processus",
+  "cycle.audience.automation-teams": "Équipes d’automatisation",
+  "cycle.station.automation-opportunity-strategy": "Stratégie d’opportunité d’automatisation",
+  "cycle.station.process-user-requirements": "Exigences processus & utilisateur",
+  "cycle.station.automation-platform-decision": "Décision de plateforme d’automatisation",
+  "cycle.station.automation-workflow-design": "Conception de workflow d’automatisation",
+  "cycle.station.automation-delivery": "Livraison & operations de l automatisation",
+  "cycle.station.automation-readiness-review": "Revue de préparation de l’automatisation",
+  "cycle.station.automation-enablement": "Deploiement & enablement de l automatisation",
+  "cycle.station.automation-monitoring-improvement": "Suivi & amélioration de l’automatisation",
+  "cycle.automation-cycle.station.api-product-strategy.description": "Identifiez et priorisez les opportunités d’automatisation selon la valeur, la faisabilité, le risque, la responsabilité et l’impact attendu sur le processus.",
+  "cycle.automation-cycle.station.api-consumer-experience.description": "Capturez les utilisateurs du processus, les rôles, les transferts, les exceptions, les contraintes et les attentes de service avant de concevoir l’automatisation.",
+  "cycle.automation-cycle.station.api-platform-architecture.description": "Choisir la plateforme d automatisation, le runtime, l approche d integration, les controles de gouvernance et les contraintes operationnelles.",
+  "cycle.automation-cycle.station.api-design.description": "Concevoir le workflow d automatisation, les declencheurs, les points de decision, les integrations, le traitement des donnees, les contrats d interface pertinents et les chemins d exception.",
+  "cycle.automation-cycle.station.api-delivery.description": "Construisez, testez, déployez, documentez et exploitez l’automatisation avec une responsabilité et des chemins de rollback clairs.",
+  "cycle.automation-cycle.station.api-audit.description": "Revoyez la préparation, la qualité, les risques, la conformité, la supervision humaine, les preuves et les critères de publication de l’automatisation.",
+  "cycle.automation-cycle.station.api-publishing.description": "Enablez les utilisateurs et opérateurs avec découverte, onboarding, instructions d’exploitation, chemins de support et communication de changement.",
+  "cycle.automation-cycle.station.monitoring-and-improving.description": "Suivez la performance de l’automatisation, les exceptions, la fiabilité, les résultats utilisateurs, l’impact opérationnel et les opportunités d’amélioration."
+}
diff --git a/src/data/method/fr/labels.lines.json b/src/data/method/fr/labels.lines.json
index 892acc3..03ce0e7 100644
--- a/src/data/method/fr/labels.lines.json
+++ b/src/data/method/fr/labels.lines.json
@@ -1,16 +1,16 @@
 {
   "lines.title": "Lignes de métro",
-  "lines.description": "Une collection de lignes d'API qui guident le développement et la gestion des API.",
-  "line.business-opportunities-line.title": "Ligne sur les opportunités d'affaires",
-  "line.business-opportunities-line.description": "L'accent est mis sur l'identification et l'exploitation des opportunités commerciales grâce aux API.",
+  "lines.description": "Lignes du métro APIOps Cycles qui guident la conception, la mise en œuvre et l'évolution des capacités, des API et des intégrations.",
+  "line.business-opportunities-line.title": "Ligne des opportunités métier",
+  "line.business-opportunities-line.description": "Se concentre sur l'identification, l'évaluation et la productisation des opportunités métier sous forme de capacités réutilisables.",
   "line.platform-architecture-line.title": "Ligne d'architecture de la plateforme",
-  "line.platform-architecture-line.description": "Couvre les aspects architecturaux des plateformes API.",
+  "line.platform-architecture-line.description": "Couvre les décisions d'architecture relatives aux plateformes, aux intégrations et aux interfaces.",
   "line.api-design-line.title": "Ligne de conception de l'API",
-  "line.api-design-line.description": "Se concentre sur les principes et les pratiques de conception des API.",
+  "line.api-design-line.description": "Se concentre sur les principes et les bonnes pratiques de conception des interfaces et des solutions d'intégration.",
   "line.delivery-line.title": "Ligne de livraison",
-  "line.delivery-line.description": "Couvre les processus et pratiques de livraison des API.",
-  "line.publishing-and-adoption-line.title": "Ligne d'édition et d'adoption",
-  "line.publishing-and-adoption-line.description": "Se concentre sur la publication d'API et sur leur adoption par les consommateurs.",
+  "line.delivery-line.description": "Couvre les pratiques de mise en œuvre, de test, d'automatisation et de livraison.",
+  "line.publishing-and-adoption-line.title": "Ligne Publication & Enablement",
+  "line.publishing-and-adoption-line.description": "Se concentre sur la publication des capacités, leur découvrabilité, leur onboarding et leur adoption.",
   "line.operating-model-line.title": "Ligne de modèle opérationnel",
-  "line.operating-model-line.description": "Couvre le modèle d'exploitation pour la gestion et la gouvernance des API."
-}
+  "line.operating-model-line.description": "Couvre la gouvernance, les responsabilités et le modèle opérationnel des capacités."
+}
\ No newline at end of file
diff --git a/src/data/method/fr/labels.resources.json b/src/data/method/fr/labels.resources.json
index 842b420..cb5ca85 100644
--- a/src/data/method/fr/labels.resources.json
+++ b/src/data/method/fr/labels.resources.json
@@ -1,137 +1,137 @@
 {
   "resource.api-community-engagement-strategies.title": "Stratégies d'engagement de la communauté de l'API",
   "resource.api-community-engagement-strategies.description": "Un guide pour favoriser l'adoption des API en cultivant des communautés grâce à des contenus, des canaux d'assistance, des boucles de retour d'information et des stratégies d'engagement social.",
-  "resource.api-community-engagement-strategies.outcomes": "Meilleure compréhension des principes des stratégies d'engagement communautaire de l'API",
+  "resource.api-community-engagement-strategies.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Stratégies d'engagement de la communauté de l'API »",
   "resource.api-community-engagement-strategies.steps": "Élaborer des stratégies de marketing pour promouvoir les API auprès des publics cibles, y compris les médias sociaux, les blogs et les webinaires.",
-  "resource.api-community-engagement-strategies.tips": "Personnalisez les stratégies d'engagement communautaire de l'API pour votre domaine",
+  "resource.api-community-engagement-strategies.tips": "Adaptez cette ressource à votre contexte.",
   "resource.api-compliance-best-practices.title": "Meilleures pratiques en matière de conformité de l'API",
   "resource.api-compliance-best-practices.description": "Veiller à ce que les API respectent la conformité légale, réglementaire et interne grâce à la documentation, aux contrôles et aux validations automatisées.",
-  "resource.api-compliance-best-practices.outcomes": "Meilleure compréhension des principes des meilleures pratiques en matière de conformité des API",
+  "resource.api-compliance-best-practices.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Meilleures pratiques en matière de conformité de l'API »",
   "resource.api-compliance-best-practices.steps": "Documenter les mesures de conformité et veiller à ce qu'elles soient communiquées aux parties prenantes et aux consommateurs.",
-  "resource.api-compliance-best-practices.tips": "Personnalisez les meilleures pratiques de conformité de l'API pour votre domaine",
+  "resource.api-compliance-best-practices.tips": "Adaptez cette ressource à votre contexte.",
   "resource.api-development-best-practices.title": "Meilleures pratiques en matière de développement d'API",
-  "resource.api-development-best-practices.description": "Guide de mise en œuvre visant à transformer un contrat API validé en une base de code API cohérente et facile à maintenir, à l'aide de bibliothèques standard, de modèles réutilisables et de workflows de développement harmonisés.",
-  "resource.api-development-best-practices.outcomes": "Meilleure compréhension des principes des meilleures pratiques en matière de développement d'API",
-  "resource.api-development-best-practices.steps": "Appliquez ces bonnes pratiques au contrat API validé et au plan de mise en œuvre avant de commencer le codage.",
-  "resource.api-development-best-practices.tips": "Utilisez cette ressource comme guide de mise en œuvre et outil d'évaluation plutôt que comme un artefact autonome obligatoire", 
+  "resource.api-development-best-practices.description": "Guide de mise en œuvre pour transformer un contrat d’interface API validé en une base de code API cohérente et maintenable, à l’aide de bibliothèques standard, de modèles réutilisables et de workflows de développement harmonisés.",
+  "resource.api-development-best-practices.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Meilleures pratiques en matière de développement d'API »",
+  "resource.api-development-best-practices.steps": "Appliquez ces pratiques au contrat d’interface API validé et au plan de mise en œuvre avant de commencer le développement.",
+  "resource.api-development-best-practices.tips": "Utilisez cette ressource comme guide de mise en œuvre et outil d'évaluation plutôt que comme un artefact autonome obligatoire",
   "resource.api-metrics-and-analytics.title": "Mesures et analyses de l'API",
   "resource.api-metrics-and-analytics.description": "Une ressource pour définir, collecter et analyser les performances de l'API et les données d'utilisation afin d'aligner les KPI techniques sur les résultats de l'entreprise.",
-  "resource.api-metrics-and-analytics.outcomes": "Meilleure compréhension des métriques API et des principes d'analyse",
+  "resource.api-metrics-and-analytics.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Mesures et analyses de l'API »",
   "resource.api-metrics-and-analytics.steps": "Identifier les indicateurs clés de performance (KPI) pour mesurer la réussite de l'API par rapport aux objectifs de l'entreprise.",
-  "resource.api-metrics-and-analytics.tips": "Personnalisez les mesures et les analyses de l'API pour votre domaine",
+  "resource.api-metrics-and-analytics.tips": "Adaptez cette ressource à votre contexte.",
   "resource.api-onboarding-best-practices.title": "Meilleures pratiques en matière d'intégration de l'API",
   "resource.api-onboarding-best-practices.description": "Meilleures pratiques pour rationaliser les parcours d'accueil des consommateurs d'API avec une inscription étape par étape, une découverte et des conseils pour le premier appel.",
-  "resource.api-onboarding-best-practices.outcomes": "Meilleure compréhension des principes des meilleures pratiques en matière d'intégration de l'API",
+  "resource.api-onboarding-best-practices.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Meilleures pratiques en matière d'intégration de l'API »",
   "resource.api-onboarding-best-practices.steps": "Définir le parcours du consommateur d'API, de la découverte au dépannage, en identifiant les points de contact clés et les points douloureux.",
-  "resource.api-onboarding-best-practices.tips": "Personnalisez les meilleures pratiques d'intégration de l'API pour votre domaine",
+  "resource.api-onboarding-best-practices.tips": "Adaptez cette ressource à votre contexte.",
   "resource.api-portfolio-management-guidelines.title": "Lignes directrices pour la gestion du portefeuille de l'API",
   "resource.api-portfolio-management-guidelines.description": "Un guide pour gérer stratégiquement la suite d'API d'une organisation - en donnant la priorité aux API, en allouant des ressources et en contrôlant les performances tout au long du cycle de vie.",
-  "resource.api-portfolio-management-guidelines.outcomes": "Meilleure compréhension des principes directeurs de la gestion du portefeuille de l'API",
+  "resource.api-portfolio-management-guidelines.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Lignes directrices pour la gestion du portefeuille de l'API »",
   "resource.api-portfolio-management-guidelines.steps": "Définir des pratiques de gestion de portefeuille qui décrivent les processus de gestion du portefeuille d'API, y compris l'établissement de priorités, le suivi et l'optimisation.",
-  "resource.api-portfolio-management-guidelines.tips": "Personnaliser les lignes directrices de la gestion du portefeuille d'API pour votre domaine",
+  "resource.api-portfolio-management-guidelines.tips": "Adaptez cette ressource à votre contexte.",
   "resource.api-security-best-practices.title": "Meilleures pratiques en matière de sécurité des API",
   "resource.api-security-best-practices.description": "Un ensemble de contrôles exploitables pour sécuriser les API, y compris l'authentification, l'autorisation, le cryptage, la limitation du débit et les contrôles de conformité au niveau du pipeline.",
-  "resource.api-security-best-practices.outcomes": "Meilleure compréhension des principes des meilleures pratiques en matière de sécurité des API",
+  "resource.api-security-best-practices.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Meilleures pratiques en matière de sécurité des API »",
   "resource.api-security-best-practices.steps": "S'assurer que les API répondent aux exigences de sécurité et de conformité grâce à des contrôles et des audits automatisés.",
-  "resource.api-security-best-practices.tips": "Personnalisez les meilleures pratiques de sécurité de l'API pour votre domaine",
+  "resource.api-security-best-practices.tips": "Adaptez cette ressource à votre contexte.",
   "resource.api-team-structure-guidelines.title": "Lignes directrices relatives à la structure des équipes de l'API",
   "resource.api-team-structure-guidelines.description": "Orientation organisationnelle pour définir les rôles et les responsabilités au sein des équipes API afin de garantir la clarté, la collaboration et la responsabilité.",
-  "resource.api-team-structure-guidelines.outcomes": "Meilleure compréhension des principes directeurs de la structure de l'équipe API",
+  "resource.api-team-structure-guidelines.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Lignes directrices relatives à la structure des équipes de l'API »",
   "resource.api-team-structure-guidelines.steps": "Définir les structures et les rôles des équipes API, y compris les propriétaires de produits API, les développeurs, les architectes et les opérations.",
-  "resource.api-team-structure-guidelines.tips": "Personnalisez les lignes directrices de la structure de l'équipe API pour votre domaine",
+  "resource.api-team-structure-guidelines.tips": "Adaptez cette ressource à votre contexte.",
   "resource.api-testing-best-practices.title": "Meilleures pratiques de test de l'API",
   "resource.api-testing-best-practices.description": "Lignes directrices pour la mise en œuvre de tests fonctionnels, de performance et de sécurité automatisés tout au long du cycle de vie de l'API.",
-  "resource.api-testing-best-practices.outcomes": "Meilleure compréhension des principes des meilleures pratiques en matière de tests d'API",
+  "resource.api-testing-best-practices.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Meilleures pratiques de test de l'API »",
   "resource.api-testing-best-practices.steps": "Tester les fonctionnalités, la sécurité et les performances des API à l'aide d'outils de test automatisés.",
-  "resource.api-testing-best-practices.tips": "Personnalisez les meilleures pratiques de test de l'API pour votre domaine",
+  "resource.api-testing-best-practices.tips": "Adaptez cette ressource à votre contexte.",
   "resource.api-training-programs.title": "Programmes de formation de l'API",
   "resource.api-training-programs.description": "Une feuille de route pour l'amélioration des compétences des équipes avec des parcours d'apprentissage structurés en matière de conception, de gouvernance, de performance et de sécurité des API.",
-  "resource.api-training-programs.outcomes": "Meilleure compréhension des principes des programmes de formation de l'API",
+  "resource.api-training-programs.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Programmes de formation de l'API »",
   "resource.api-training-programs.steps": "Identifier les compétences et les connaissances clés en matière d'API qui doivent être améliorées, telles que la conception, la sécurité et les performances des API.",
-  "resource.api-training-programs.tips": "Personnalisez les programmes de formation à l'API pour votre domaine",
+  "resource.api-training-programs.tips": "Adaptez cette ressource à votre contexte.",
   "resource.api-versioning-best-practices.title": "Meilleures pratiques en matière de versionnement de l'API",
   "resource.api-versioning-best-practices.description": "Stratégies d'introduction, de maintenance et de retrait des versions de l'API tout en préservant la compatibilité ascendante et la confiance des consommateurs.",
-  "resource.api-versioning-best-practices.outcomes": "Meilleure compréhension des principes des meilleures pratiques en matière de versions d'API",
+  "resource.api-versioning-best-practices.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Meilleures pratiques en matière de versionnement de l'API »",
   "resource.api-versioning-best-practices.steps": "Définir des stratégies de versionnement pour les API afin de gérer les changements et d'assurer la compatibilité ascendante.",
-  "resource.api-versioning-best-practices.tips": "Personnalisez les meilleures pratiques de versionnement de l'API pour votre domaine",
+  "resource.api-versioning-best-practices.tips": "Adaptez cette ressource à votre contexte.",
   "resource.apiops-CI-CD-for-apis.title": "APIOps CI/CD pour les API",
   "resource.apiops-CI-CD-for-apis.description": "Des conseils de déploiement qui intègrent les tâches du cycle de vie de l'API - conception, test, gouvernance - dans les pipelines d'intégration et de livraison en continu.",
-  "resource.apiops-CI-CD-for-apis.outcomes": "Meilleure compréhension des principes CI/CD pour les API",
+  "resource.apiops-CI-CD-for-apis.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « APIOps CI/CD pour les API »",
   "resource.apiops-CI-CD-for-apis.steps": "Utiliser les pipelines CI/CD pour automatiser les processus de construction, de test et de déploiement, en garantissant une qualité et une traçabilité constantes.",
-  "resource.apiops-CI-CD-for-apis.tips": "Personnalisez les API CI/CD pour votre domaine",
+  "resource.apiops-CI-CD-for-apis.tips": "Adaptez cette ressource à votre contexte.",
   "resource.competitor-analysis-template.title": "Modèle d'analyse des concurrents",
   "resource.competitor-analysis-template.description": "Une feuille de travail structurée pour comparer vos offres d'API à celles de vos concurrents en identifiant les forces, les faiblesses et les différentiateurs de valeur.",
-  "resource.competitor-analysis-template.outcomes": "Meilleure compréhension des principes du modèle d'analyse de la concurrence",
+  "resource.competitor-analysis-template.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Modèle d'analyse des concurrents »",
   "resource.competitor-analysis-template.steps": "Effectuer une analyse concurrentielle afin d'identifier les principaux concurrents et leurs offres d'API.",
-  "resource.competitor-analysis-template.tips": "Personnalisez le modèle d'analyse de la concurrence pour votre domaine",
+  "resource.competitor-analysis-template.tips": "Adaptez cette ressource à votre contexte.",
   "resource.contract-first-design.title": "Contrat de première conception",
   "resource.contract-first-design.description": "Une ligne directrice qui préconise des approches \"API-first\" utilisant des contrats formels (par exemple, OpenAPI) pour aligner les parties prenantes avant le développement.",
-  "resource.contract-first-design.outcomes": "Meilleure compréhension des principes de conception du contrat d'abord",
+  "resource.contract-first-design.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Contrat de première conception »",
   "resource.contract-first-design.steps": "Appliquer des approches de type \"contrat d'abord\" ou \"conception d'abord\" pour s'assurer que les contrats d'API sont validés avant leur mise en œuvre.",
-  "resource.contract-first-design.tips": "Personnalisez le Contract First Design pour votre domaine",
+  "resource.contract-first-design.tips": "Adaptez cette ressource à votre contexte.",
   "resource.cross-functional-collaboration-best-practices.title": "Meilleures pratiques en matière de collaboration interfonctionnelle",
   "resource.cross-functional-collaboration-best-practices.description": "Pratiques visant à faciliter la communication et l'alignement entre les équipes commerciales et techniques lors de la planification ou de la fourniture d'API.",
-  "resource.cross-functional-collaboration-best-practices.outcomes": "Meilleure compréhension des principes des meilleures pratiques en matière de collaboration interfonctionnelle",
+  "resource.cross-functional-collaboration-best-practices.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Meilleures pratiques en matière de collaboration interfonctionnelle »",
   "resource.cross-functional-collaboration-best-practices.steps": "Encourager la collaboration interfonctionnelle entre les équipes API, les unités opérationnelles et les parties prenantes afin d'aligner les initiatives API sur les objectifs de l'entreprise.",
-  "resource.cross-functional-collaboration-best-practices.tips": "Personnalisez les bonnes pratiques de collaboration interfonctionnelle pour votre domaine",
+  "resource.cross-functional-collaboration-best-practices.tips": "Adaptez cette ressource à votre contexte.",
   "resource.data-privacy-guidelines.title": "Lignes directrices sur la protection des données",
   "resource.data-privacy-guidelines.description": "Les considérations de conception pour s'assurer que les API respectent les réglementations sur la protection des données comme le GDPR grâce à l'anonymisation et aux contrôles d'accès.",
-  "resource.data-privacy-guidelines.outcomes": "Meilleure compréhension des principes des lignes directrices sur la confidentialité des données",
+  "resource.data-privacy-guidelines.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Lignes directrices sur la protection des données »",
   "resource.data-privacy-guidelines.steps": "Garantir la confidentialité des données des utilisateurs en mettant en œuvre des mesures de protection des données, telles que l'anonymisation et les contrôles d'accès.",
-  "resource.data-privacy-guidelines.tips": "Personnalisez les lignes directrices sur la confidentialité des données pour votre domaine",
+  "resource.data-privacy-guidelines.tips": "Adaptez cette ressource à votre contexte.",
   "resource.domain-canvas.title": "Domain Canvas",
   "resource.domain-canvas.description": "Un outil de modélisation pour définir et communiquer les entités et les relations clés de votre domaine, en assurant la cohérence sémantique entre les API.",
-  "resource.domain-canvas.outcomes": "Meilleure compréhension des principes du domain canvas",
+  "resource.domain-canvas.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Domain Canvas »",
   "resource.domain-canvas.steps": "Définir les entités de base, leurs attributs et leurs relations afin de créer une compréhension conceptuelle partagée entre les API.",
-  "resource.domain-canvas.tips": "Personnaliser le Domain Canvas pour votre domaine",
+  "resource.domain-canvas.tips": "Adaptez cette ressource à votre contexte.",
   "resource.ecosystem-vision-template.title": "Modèle de vision de l'écosystème",
   "resource.ecosystem-vision-template.description": "Un outil de planification stratégique pour définir l'écosystème de l'API, y compris les partenaires cibles, les chaînes de valeur et les possibilités d'intégration.",
-  "resource.ecosystem-vision-template.outcomes": "Meilleure compréhension des principes du modèle de vision de l'écosystème",
+  "resource.ecosystem-vision-template.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Modèle de vision de l'écosystème »",
   "resource.ecosystem-vision-template.steps": "Réaliser des études de marché pour identifier les tendances, les opportunités et les menaces dans le domaine des API.",
-  "resource.ecosystem-vision-template.tips": "Personnalisez le modèle de vision de l'écosystème pour votre domaine",
+  "resource.ecosystem-vision-template.tips": "Adaptez cette ressource à votre contexte.",
   "resource.industry-standards-and-best-practices.title": "Normes industrielles et meilleures pratiques",
   "resource.industry-standards-and-best-practices.description": "Une ressource de référence pour aligner la conception et le fonctionnement de l'API sur des cadres et des spécifications largement reconnus dans l'industrie.",
-  "resource.industry-standards-and-best-practices.outcomes": "Meilleure compréhension des normes du secteur et des principes des meilleures pratiques",
+  "resource.industry-standards-and-best-practices.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Normes industrielles et meilleures pratiques »",
   "resource.industry-standards-and-best-practices.steps": "Identifier les normes et les meilleures pratiques du secteur pour s'assurer que les API sont compétitives et conformes.",
-  "resource.industry-standards-and-best-practices.tips": "Personnaliser les normes et les meilleures pratiques de l'industrie pour votre domaine",
+  "resource.industry-standards-and-best-practices.tips": "Adaptez cette ressource à votre contexte.",
   "resource.partner-integration-guidelines.title": "Lignes directrices pour l'intégration des partenaires",
   "resource.partner-integration-guidelines.description": "Listes de contrôle de l'intégration et modèles de communication pour gérer les aspects techniques et juridiques des relations avec des API tierces.",
-  "resource.partner-integration-guidelines.outcomes": "Meilleure compréhension des principes directeurs de l'intégration des partenaires",
+  "resource.partner-integration-guidelines.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Lignes directrices pour l'intégration des partenaires »",
   "resource.partner-integration-guidelines.steps": "Établir des processus d'intégration et des lignes directrices pour la collaboration avec les partenaires, y compris l'intégration technique, le partage des données et le soutien.",
-  "resource.partner-integration-guidelines.tips": "Personnalisez les directives d'intégration des partenaires pour votre domaine",
+  "resource.partner-integration-guidelines.tips": "Adaptez cette ressource à votre contexte.",
   "resource.role-communication-best-practices.title": "Meilleures pratiques en matière de communication sur les rôles",
   "resource.role-communication-best-practices.description": "Outils permettant de définir et de documenter les responsabilités de chacun dans le cadre des initiatives API, afin de garantir la clarté des transferts et des responsabilités.",
-  "resource.role-communication-best-practices.outcomes": "Meilleure compréhension des principes des meilleures pratiques en matière de communication sur les rôles",
+  "resource.role-communication-best-practices.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Meilleures pratiques en matière de communication sur les rôles »",
   "resource.role-communication-best-practices.steps": "Établir des responsabilités claires pour chaque rôle, notamment en ce qui concerne la conception, le développement, les tests et les opérations de l'API.",
-  "resource.role-communication-best-practices.tips": "Personnalisez les meilleures pratiques de communication de rôle pour votre domaine",
+  "resource.role-communication-best-practices.tips": "Adaptez cette ressource à votre contexte.",
   "resource.scalable-infrastructure-best-practices.title": "Meilleures pratiques en matière d'infrastructure évolutive",
   "resource.scalable-infrastructure-best-practices.description": "Des conseils architecturaux pour s'assurer que les API sont déployées sur une infrastructure capable de gérer avec élasticité les pics d'utilisation et la croissance.",
-  "resource.scalable-infrastructure-best-practices.outcomes": "Meilleure compréhension des principes des meilleures pratiques en matière d'infrastructure évolutive",
+  "resource.scalable-infrastructure-best-practices.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Meilleures pratiques en matière d'infrastructure évolutive »",
   "resource.scalable-infrastructure-best-practices.steps": "Concevoir une infrastructure d'API évolutive et résiliente, en utilisant des modèles et des technologies \"cloud-native\".",
-  "resource.scalable-infrastructure-best-practices.tips": "Personnalisez les meilleures pratiques de l'infrastructure évolutive pour votre domaine",
+  "resource.scalable-infrastructure-best-practices.tips": "Adaptez cette ressource à votre contexte.",
   "resource.service-agreement-template.title": "Modèle de contrat de service",
   "resource.service-agreement-template.description": "Un format d'accord personnalisable qui définit les attentes, les accords de niveau de service, les responsabilités et les conditions d'accès pour la consommation d'API.",
-  "resource.service-agreement-template.outcomes": "Meilleure compréhension des principes du modèle d'accord de service",
+  "resource.service-agreement-template.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Modèle de contrat de service »",
   "resource.service-agreement-template.steps": "Définir des accords de service qui décrivent les attentes, les niveaux de service et les responsabilités pour chaque API.",
-  "resource.service-agreement-template.tips": "Personnalisez le modèle de contrat de service pour votre domaine",
+  "resource.service-agreement-template.tips": "Adaptez cette ressource à votre contexte.",
   "resource.stakeholder-engagement-best-practices.title": "Meilleures pratiques en matière d'engagement des parties prenantes",
   "resource.stakeholder-engagement-best-practices.description": "Tactiques d'engagement pour aligner les parties prenantes internes et externes sur les objectifs, la valeur et la gouvernance partagés de l'API.",
-  "resource.stakeholder-engagement-best-practices.outcomes": "Meilleure compréhension des principes des meilleures pratiques en matière d'engagement des parties prenantes",
+  "resource.stakeholder-engagement-best-practices.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Meilleures pratiques en matière d'engagement des parties prenantes »",
   "resource.stakeholder-engagement-best-practices.steps": "Engager les parties prenantes pour assurer l'alignement et le soutien des initiatives API.",
-  "resource.stakeholder-engagement-best-practices.tips": "Personnalisez les meilleures pratiques d'engagement des parties prenantes pour votre domaine",
+  "resource.stakeholder-engagement-best-practices.tips": "Adaptez cette ressource à votre contexte.",
   "resource.test-automation-frameworks.title": "Cadres d'automatisation des tests",
   "resource.test-automation-frameworks.description": "Outils et modèles recommandés pour automatiser les tests de contrat, de régression et d'intégration des API dans les différents environnements.",
-  "resource.test-automation-frameworks.outcomes": "Meilleure compréhension des principes des cadres d'automatisation des tests",
+  "resource.test-automation-frameworks.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Cadres d'automatisation des tests »",
   "resource.test-automation-frameworks.steps": "Mettre en œuvre des cadres d'automatisation des tests qui prennent en charge les tests de contrat, les tests d'intégration et les tests de bout en bout.",
-  "resource.test-automation-frameworks.tips": "Personnaliser les cadres d'automatisation des tests pour votre domaine",
+  "resource.test-automation-frameworks.tips": "Adaptez cette ressource à votre contexte.",
   "resource.vendor-management-best-practices.title": "Meilleures pratiques de gestion des fournisseurs",
   "resource.vendor-management-best-practices.description": "Cadre pour l'évaluation et la gestion des fournisseurs d'API externes et des intégrations de tiers en fonction des risques, des performances et de la conformité.",
-  "resource.vendor-management-best-practices.outcomes": "Meilleure compréhension des principes des meilleures pratiques en matière de gestion des fournisseurs",
+  "resource.vendor-management-best-practices.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Meilleures pratiques de gestion des fournisseurs »",
   "resource.vendor-management-best-practices.steps": "Mettre en place des processus de gestion des fournisseurs afin d'évaluer, d'intégrer et de contrôler les fournisseurs d'API tiers.",
-  "resource.vendor-management-best-practices.tips": "Personnalisez les bonnes pratiques de gestion des fournisseurs pour votre domaine",
+  "resource.vendor-management-best-practices.tips": "Adaptez cette ressource à votre contexte.",
   "resource.api-audit-checklist.title": "Liste de contrôle de l'audit de l'API",
   "resource.api-audit-checklist.description": "Une liste de contrôle basée sur le cycle de vie permettant de vérifier l'état de préparation de l'API à travers les phases de conception, de livraison, de publication et de conformité à l'aide de critères d'audit et de preuves définis.",
-  "resource.api-audit-checklist.outcomes": "Meilleure compréhension des principes de la liste de contrôle de l'audit de l'API",
+  "resource.api-audit-checklist.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Liste de contrôle de l'audit de l'API »",
   "resource.api-audit-checklist.steps": "Utilisez la liste de contrôle de l'audit de l'API pour vous assurer que la conception de l'API répond aux exigences fonctionnelles et non fonctionnelles, notamment en matière de sécurité, de performances et de conformité.",
   "resource.api-audit-checklist.tips": "Chaque élément d'audit relie les tâches du cycle de vie (étapes), les directives applicables et les preuves à l'appui afin de fournir une vision claire de l'état de préparation de l'API.",
   "resource.api-business-model-canvas.title": "API Business Model Canvas",
@@ -141,32 +141,32 @@
   "resource.api-business-model-canvas.tips": "Commencer par une seule API pour plus de clarté",
   "resource.api-design-principles.title": "Principes de conception de l'API",
   "resource.api-design-principles.description": "Un guide concis sur l'ergonomie, la facilité de découverte et la cohérence des API, fondé sur des règles de conception communes et les besoins réels des consommateurs.",
-  "resource.api-design-principles.outcomes": "Meilleure compréhension des principes de conception des API",
+  "resource.api-design-principles.outcomes": "Compréhension partagée de l’objectif et de l’utilisation de « Principes de conception de l'API »",
   "resource.api-design-principles.steps": "**Consumer-first design:** commencer chaque cycle APIOps en rassemblant les objectifs des utilisateurs et les termes du domaine afin que les APIs résolvent des problèmes réels.",
-  "resource.api-design-principles.tips": "Personnalisez les principes de conception de l'API pour votre domaine",
+  "resource.api-design-principles.tips": "Adaptez cette ressource à votre contexte.",
   "resource.api-value-proposition-canvas.title": "API Value Proposition Canvas",
   "resource.api-value-proposition-canvas.description": "Aligner les fonctionnalités de l'API sur les besoins des utilisateurs en établissant une correspondance entre les tâches, les douleurs et les gains et les produits de l'API.",
   "resource.api-value-proposition-canvas.outcomes": "Développement de fonctionnalités ciblées",
   "resource.api-value-proposition-canvas.steps": "Liste des tâches liées au parcours de l'utilisateur",
   "resource.api-value-proposition-canvas.tips": "Utiliser les données du Customer Journey Canvas",
   "resource.business-impact-canvas.title": "Business Impact Canvas",
-  "resource.business-impact-canvas.description": "Concevoir une architecture de plateforme API évolutive et sécurisée qui réponde aux exigences commerciales et techniques.",
-  "resource.business-impact-canvas.outcomes": "Infrastructure API évolutive",
+  "resource.business-impact-canvas.description": "Identifiez les risques métier, de disponibilité, de sécurité, de données, de conformité et d’exploitation qui doivent orienter les décisions d’architecture et de plateforme.",
+  "resource.business-impact-canvas.outcomes": "Évaluation documentée des impacts métier et opérationnels",
   "resource.business-impact-canvas.steps": "Risques liés à la disponibilité : Identifier les risques et les impacts.",
-  "resource.business-impact-canvas.tips": "Impliquer les architectes et les promoteurs dans le processus de conception",
+  "resource.business-impact-canvas.tips": "Complétez ce canvas avant de sélectionner ou de confirmer le mode de mise en œuvre.",
   "resource.capacity-canvas.title": "Capacity Canvas",
-  "resource.capacity-canvas.description": "Planifier la capacité de l'API pour répondre aux demandes actuelles et futures de l'entreprise, en garantissant l'évolutivité et les performances.",
-  "resource.capacity-canvas.outcomes": "Alignement de la capacité de l'API sur les volumes d'activité",
+  "resource.capacity-canvas.description": "Planifiez la capacité pour la demande actuelle et future, notamment les volumes, les pics, la latence, la disponibilité, la mise à l’échelle, la mise en cache et la limitation de débit pour la capacité et le mode de mise en œuvre choisis.",
+  "resource.capacity-canvas.outcomes": "Exigences de capacité alignées sur la demande métier attendue",
   "resource.capacity-canvas.steps": "Documenter les volumes d'affaires actuels",
-  "resource.capacity-canvas.tips": "Utiliser l'analyse pour prévoir les tendances de la croissance",
+  "resource.capacity-canvas.tips": "Complétez ce canvas avant de finaliser les décisions d’architecture et de plateforme.",
   "resource.customer-journey-canvas.title": "Customer Journey Canvas",
   "resource.customer-journey-canvas.description": "Cartographier les parcours des clients pour identifier les besoins et les points de douleur, afin d'améliorer la conception de l'API et l'expérience de l'utilisateur.",
-  "resource.customer-journey-canvas.outcomes": "Amélioration de la compréhension du client",
+  "resource.customer-journey-canvas.outcomes": "Compréhension partagée du parcours client, partenaire ou utilisateur",
   "resource.customer-journey-canvas.steps": "Définir le profil du client",
-  "resource.customer-journey-canvas.tips": "Répéter avec l'aide de l'équipe pour affiner les étapes",
+  "resource.customer-journey-canvas.tips": "Validez le parcours avec les personnes qui le réalisent ou le vivent.",
   "resource.event-canvas.title": "Event Canvas",
-  "resource.event-canvas.description": "Concevoir des API pilotées par les événements en définissant les événements, les déclencheurs et la logique de traitement.",
-  "resource.event-canvas.outcomes": "Architecture événementielle définie",
+  "resource.event-canvas.description": "Concevez des interfaces et intégrations événementielles en définissant les événements, déclencheurs, schémas, producteurs, utilisateurs et logiques de traitement.",
+  "resource.event-canvas.outcomes": "Modèle d’interaction événementiel défini",
   "resource.event-canvas.steps": "Identifier les événements clés du système",
   "resource.event-canvas.tips": "Utiliser des schémas d'événements pour normaliser les formats d'événements",
   "resource.graphql-canvas.title": "GraphQL Canvas",
@@ -176,12 +176,12 @@
   "resource.graphql-canvas.tips": "Utiliser l'introspection pour valider les définitions de type",
   "resource.interaction-canvas.title": "Interaction Canvas",
   "resource.interaction-canvas.description": "Définir les interactions API, les flux de travail et les réponses attendues afin de garantir une expérience cohérente pour les consommateurs d'API.",
-  "resource.interaction-canvas.outcomes": "Des flux de travail clairs pour les interactions avec l'API",
+  "resource.interaction-canvas.outcomes": "Modèle d’interaction défini pour la capacité choisie",
   "resource.interaction-canvas.steps": "Associer les interactions de l'API aux tâches de l'utilisateur",
   "resource.interaction-canvas.tips": "Commencer par les cas d'utilisation courants avant de traiter les cas marginaux",
   "resource.location-canvas.title": "Location Canvas",
   "resource.location-canvas.description": "Cartographier les emplacements des fournisseurs d'API et des consommateurs pour garantir la conformité et les performances dans toutes les régions.",
-  "resource.location-canvas.outcomes": "Respect des réglementations locales",
+  "resource.location-canvas.outcomes": "Exigences de localisation, de résidence des données, de réseau et de réglementation documentées",
   "resource.location-canvas.steps": "Carte des emplacements des fournisseurs d'API.",
   "resource.location-canvas.tips": "Collaborer avec les équipes juridiques et de conformité",
   "resource.rest-canvas.title": "REST Canvas",
@@ -189,125 +189,125 @@
   "resource.rest-canvas.outcomes": "Conception cohérente de l'API RESTful",
   "resource.rest-canvas.steps": "Identifier les ressources clés exposées par l'API",
   "resource.rest-canvas.tips": "Utiliser les méthodes HTTP standard (GET, POST, PUT, DELETE)",
-  "resource.api-community-engagement-strategies.outcomes.1": "Approche standardisée utilisant les stratégies d'engagement communautaire de l'API",
-  "resource.api-community-engagement-strategies.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.api-community-engagement-strategies.outcomes.1": "Approche cohérente pour appliquer « Stratégies d'engagement de la communauté de l'API »",
+  "resource.api-community-engagement-strategies.outcomes.2": "Meilleure application des pratiques associées",
   "resource.api-community-engagement-strategies.steps.1": "Créer du matériel promotionnel (par exemple, des études de cas, des exemples de réussite) qui met en évidence la valeur et les avantages des API.",
   "resource.api-community-engagement-strategies.steps.2": "Créer des supports pédagogiques (par exemple, des tutoriels, de la documentation) qui expliquent les caractéristiques, les avantages et les modes d'utilisation de l'API.",
   "resource.api-community-engagement-strategies.steps.3": "S'engager auprès des consommateurs d'API par le biais de boucles de retour d'information, de canaux d'assistance et de forums communautaires afin de comprendre leurs besoins et d'améliorer l'adoption de l'API.",
   "resource.api-community-engagement-strategies.steps.4": "Analyser les indicateurs d'utilisation de l'API et intégrer les commentaires des utilisateurs dans les itérations de l'API.",
-  "resource.api-community-engagement-strategies.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.api-compliance-best-practices.outcomes.1": "Approche normalisée utilisant les meilleures pratiques en matière de conformité des API",
-  "resource.api-compliance-best-practices.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.api-community-engagement-strategies.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.api-compliance-best-practices.outcomes.1": "Approche cohérente pour appliquer « Meilleures pratiques en matière de conformité de l'API »",
+  "resource.api-compliance-best-practices.outcomes.2": "Meilleure application des pratiques associées",
   "resource.api-compliance-best-practices.steps.1": "Mettre en œuvre des mesures pour s'assurer que les API sont conformes à ces exigences, y compris le cryptage des données, les contrôles d'accès et les pistes d'audit.",
   "resource.api-compliance-best-practices.steps.2": "Utiliser des listes de contrôle, des linters et des outils de test pour vérifier la cohérence et la conformité avec les normes.",
-  "resource.api-compliance-best-practices.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.api-development-best-practices.outcomes.1": "Approche standardisée utilisant les meilleures pratiques de développement d'API",
-  "resource.api-development-best-practices.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.api-compliance-best-practices.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.api-development-best-practices.outcomes.1": "Approche cohérente pour appliquer « Meilleures pratiques en matière de développement d'API »",
+  "resource.api-development-best-practices.outcomes.2": "Meilleure application des pratiques associées",
   "resource.api-development-best-practices.steps.1": "Utilisez des frameworks, des bibliothèques et des normes de codage établis pour implémenter le contrat de manière cohérente et maintenable.",
-  "resource.api-development-best-practices.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.api-metrics-and-analytics.outcomes.1": "Approche standardisée utilisant les métriques et l'analyse de l'API",
-  "resource.api-metrics-and-analytics.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.api-development-best-practices.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.api-metrics-and-analytics.outcomes.1": "Approche cohérente pour appliquer « Mesures et analyses de l'API »",
+  "resource.api-metrics-and-analytics.outcomes.2": "Meilleure application des pratiques associées",
   "resource.api-metrics-and-analytics.steps.1": "Définir et surveiller les indicateurs de performance (par exemple, les appels API, la latence, les taux d'erreur) et les indicateurs d'adoption (par exemple, NPS).",
   "resource.api-metrics-and-analytics.steps.2": "Contrôler les initiatives API afin de garantir le respect des lignes directrices opérationnelles et des pratiques de gouvernance.",
-  "resource.api-metrics-and-analytics.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.api-onboarding-best-practices.outcomes.1": "Approche standardisée utilisant les meilleures pratiques de l'API Onboarding",
-  "resource.api-onboarding-best-practices.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.api-metrics-and-analytics.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.api-onboarding-best-practices.outcomes.1": "Approche cohérente pour appliquer « Meilleures pratiques en matière d'intégration de l'API »",
+  "resource.api-onboarding-best-practices.outcomes.2": "Meilleure application des pratiques associées",
   "resource.api-onboarding-best-practices.steps.1": "Développer des processus et des ressources d'intégration pour aider les consommateurs d'API à comprendre comment utiliser efficacement les API.",
   "resource.api-onboarding-best-practices.steps.2": "Documenter la manière dont les consommateurs trouvent et utilisent l'API, y compris les processus d'accueil et d'enregistrement.",
-  "resource.api-onboarding-best-practices.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.api-portfolio-management-guidelines.outcomes.1": "Approche standardisée utilisant les lignes directrices de gestion du portefeuille de l'API",
-  "resource.api-portfolio-management-guidelines.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.api-onboarding-best-practices.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.api-portfolio-management-guidelines.outcomes.1": "Approche cohérente pour appliquer « Lignes directrices pour la gestion du portefeuille de l'API »",
+  "resource.api-portfolio-management-guidelines.outcomes.2": "Meilleure application des pratiques associées",
   "resource.api-portfolio-management-guidelines.steps.1": "Définir des pratiques de gestion du budget et des ressources qui décrivent les processus de gestion des budgets et des ressources pour les initiatives de l'API.",
   "resource.api-portfolio-management-guidelines.steps.2": "Établir des critères d'évaluation et de hiérarchisation des affectations budgétaires en fonction de la valeur commerciale, de l'impact et de l'alignement sur les initiatives stratégiques.",
   "resource.api-portfolio-management-guidelines.steps.3": "Contrôler le portefeuille d'API pour s'assurer que les API apportent de la valeur, répondent aux attentes en matière de performances et s'alignent sur les objectifs de l'entreprise.",
-  "resource.api-portfolio-management-guidelines.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.api-security-best-practices.outcomes.1": "Approche normalisée utilisant les meilleures pratiques en matière de sécurité des API",
-  "resource.api-security-best-practices.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.api-portfolio-management-guidelines.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.api-security-best-practices.outcomes.1": "Approche cohérente pour appliquer « Meilleures pratiques en matière de sécurité des API »",
+  "resource.api-security-best-practices.outcomes.2": "Meilleure application des pratiques associées",
   "resource.api-security-best-practices.steps.1": "Mettre en œuvre des mesures de sécurité telles que l'authentification, l'autorisation, le cryptage et la limitation du débit pour protéger les API contre les menaces.",
   "resource.api-security-best-practices.steps.2": "Mettre en œuvre des contrôles de sécurité automatisés et des validations de conformité dans le pipeline CI/CD pour s'assurer que les API sont sécurisées et conformes.",
-  "resource.api-security-best-practices.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.api-team-structure-guidelines.outcomes.1": "Approche normalisée à l'aide des lignes directrices sur la structure des équipes de l'API",
-  "resource.api-team-structure-guidelines.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
-  "resource.api-team-structure-guidelines.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.api-testing-best-practices.outcomes.1": "Approche standardisée utilisant les meilleures pratiques de test des API",
-  "resource.api-testing-best-practices.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.api-security-best-practices.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.api-team-structure-guidelines.outcomes.1": "Approche cohérente pour appliquer « Lignes directrices relatives à la structure des équipes de l'API »",
+  "resource.api-team-structure-guidelines.outcomes.2": "Meilleure application des pratiques associées",
+  "resource.api-team-structure-guidelines.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.api-testing-best-practices.outcomes.1": "Approche cohérente pour appliquer « Meilleures pratiques de test de l'API »",
+  "resource.api-testing-best-practices.outcomes.2": "Meilleure application des pratiques associées",
   "resource.api-testing-best-practices.steps.1": "Intégrer des tests fonctionnels et non fonctionnels dans le pipeline CI/CD pour s'assurer que les API répondent aux normes de qualité.",
   "resource.api-testing-best-practices.steps.2": "Utiliser des outils de test automatisés pour valider les fonctionnalités, la sécurité et les performances de l'API.",
-  "resource.api-testing-best-practices.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.api-training-programs.outcomes.1": "Approche normalisée à l'aide des programmes de formation de l'API",
-  "resource.api-training-programs.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.api-testing-best-practices.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.api-training-programs.outcomes.1": "Approche cohérente pour appliquer « Programmes de formation de l'API »",
+  "resource.api-training-programs.outcomes.2": "Meilleure application des pratiques associées",
   "resource.api-training-programs.steps.1": "Encourager la formation continue par des cours en ligne, des certifications et l'engagement communautaire.",
   "resource.api-training-programs.steps.2": "Fournir des formations et des ressources pour aider les équipes à adopter un état d'esprit \"API-first\" et à comprendre les avantages des API.",
   "resource.api-training-programs.steps.3": "Fournir des programmes de formation, des ateliers et des ressources pour aider les équipes à améliorer leurs compétences et leurs connaissances en matière d'API.",
-  "resource.api-training-programs.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.api-versioning-best-practices.outcomes.1": "Approche normalisée utilisant les meilleures pratiques en matière de versionnement de l'API",
-  "resource.api-versioning-best-practices.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
-  "resource.api-versioning-best-practices.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.apiops-CI-CD-for-apis.outcomes.1": "Approche standardisée utilisant CI/CD pour les API",
-  "resource.apiops-CI-CD-for-apis.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.api-training-programs.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.api-versioning-best-practices.outcomes.1": "Approche cohérente pour appliquer « Meilleures pratiques en matière de versionnement de l'API »",
+  "resource.api-versioning-best-practices.outcomes.2": "Meilleure application des pratiques associées",
+  "resource.api-versioning-best-practices.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.apiops-CI-CD-for-apis.outcomes.1": "Approche cohérente pour appliquer « APIOps CI/CD pour les API »",
+  "resource.apiops-CI-CD-for-apis.outcomes.2": "Meilleure application des pratiques associées",
   "resource.apiops-CI-CD-for-apis.steps.1": "Intégrer des tests automatisés dans le pipeline CI/CD pour assurer une validation continue de la qualité de l'API.",
   "resource.apiops-CI-CD-for-apis.steps.2": "Mettre en œuvre des stratégies de déploiement (par exemple, des déploiements \"bleu-vert\", des versions \"canari\") afin de minimiser les risques lors des mises à jour de l'API.",
   "resource.apiops-CI-CD-for-apis.steps.3": "Prendre l'habitude d'examiner les mesures et de planifier des activités d'amélioration continue.",
-  "resource.apiops-CI-CD-for-apis.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.competitor-analysis-template.outcomes.1": "Approche standardisée à l'aide du modèle d'analyse des concurrents",
-  "resource.competitor-analysis-template.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.apiops-CI-CD-for-apis.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.competitor-analysis-template.outcomes.1": "Approche cohérente pour appliquer « Modèle d'analyse des concurrents »",
+  "resource.competitor-analysis-template.outcomes.2": "Meilleure application des pratiques associées",
   "resource.competitor-analysis-template.steps.1": "Analyser les API des concurrents pour comprendre leurs forces, leurs faiblesses et leurs arguments de vente uniques.",
-  "resource.competitor-analysis-template.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.contract-first-design.outcomes.1": "Approche normalisée utilisant la méthode du contrat d'abord (Contract First Design)",
-  "resource.contract-first-design.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.competitor-analysis-template.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.contract-first-design.outcomes.1": "Approche cohérente pour appliquer « Contrat de première conception »",
+  "resource.contract-first-design.outcomes.2": "Meilleure application des pratiques associées",
   "resource.contract-first-design.steps.1": "Définir des contrats d'API qui décrivent les attentes, les responsabilités et les directives d'utilisation pour chaque API.",
   "resource.contract-first-design.steps.2": "Utiliser des formats normalisés (par exemple, OpenAPI, AsyncAPI) pour créer des contrats d'API lisibles par machine, faciles à partager et à valider.",
-  "resource.contract-first-design.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.cross-functional-collaboration-best-practices.outcomes.1": "Approche normalisée utilisant les meilleures pratiques de collaboration interfonctionnelle",
-  "resource.cross-functional-collaboration-best-practices.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
-  "resource.cross-functional-collaboration-best-practices.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.data-privacy-guidelines.outcomes.1": "Approche standardisée utilisant les lignes directrices sur la confidentialité des données",
-  "resource.data-privacy-guidelines.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
-  "resource.data-privacy-guidelines.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.domain-canvas.outcomes.1": "Approche standardisée utilisant Domain Canvas",
-  "resource.domain-canvas.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
-  "resource.domain-canvas.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.ecosystem-vision-template.outcomes.1": "Approche standardisée utilisant le modèle de vision écosystémique",
-  "resource.ecosystem-vision-template.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.contract-first-design.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.cross-functional-collaboration-best-practices.outcomes.1": "Approche cohérente pour appliquer « Meilleures pratiques en matière de collaboration interfonctionnelle »",
+  "resource.cross-functional-collaboration-best-practices.outcomes.2": "Meilleure application des pratiques associées",
+  "resource.cross-functional-collaboration-best-practices.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.data-privacy-guidelines.outcomes.1": "Approche cohérente pour appliquer « Lignes directrices sur la protection des données »",
+  "resource.data-privacy-guidelines.outcomes.2": "Meilleure application des pratiques associées",
+  "resource.data-privacy-guidelines.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.domain-canvas.outcomes.1": "Approche cohérente pour appliquer « Domain Canvas »",
+  "resource.domain-canvas.outcomes.2": "Meilleure application des pratiques associées",
+  "resource.domain-canvas.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.ecosystem-vision-template.outcomes.1": "Approche cohérente pour appliquer « Modèle de vision de l'écosystème »",
+  "resource.ecosystem-vision-template.outcomes.2": "Meilleure application des pratiques associées",
   "resource.ecosystem-vision-template.steps.1": "Identifier les principaux partenaires de l'écosystème et les parties prenantes qui bénéficieront de l'écosystème ou y contribueront.",
   "resource.ecosystem-vision-template.steps.2": "Identifier les lacunes du marché que vos API peuvent combler, en se basant sur les offres des concurrents.",
   "resource.ecosystem-vision-template.steps.3": "Identifier les partenaires potentiels dont les API peuvent améliorer vos capacités en matière d'API et votre proposition de valeur.",
   "resource.ecosystem-vision-template.steps.4": "Élaborer une stratégie de différenciation qui mette en évidence les caractéristiques et les avantages uniques de vos API.",
   "resource.ecosystem-vision-template.steps.5": "Définissez la vision de l'écosystème pour vos API, y compris la manière dont elles interagiront avec d'autres systèmes et plateformes.",
   "resource.ecosystem-vision-template.steps.6": "Concevoir des API pour permettre une intégration et une collaboration transparentes au sein de l'écosystème.",
-  "resource.ecosystem-vision-template.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.industry-standards-and-best-practices.outcomes.1": "Approche standardisée utilisant les normes et les meilleures pratiques de l'industrie",
-  "resource.industry-standards-and-best-practices.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
-  "resource.industry-standards-and-best-practices.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.partner-integration-guidelines.outcomes.1": "Approche standardisée utilisant les lignes directrices pour l'intégration des partenaires",
-  "resource.partner-integration-guidelines.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.ecosystem-vision-template.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.industry-standards-and-best-practices.outcomes.1": "Approche cohérente pour appliquer « Normes industrielles et meilleures pratiques »",
+  "resource.industry-standards-and-best-practices.outcomes.2": "Meilleure application des pratiques associées",
+  "resource.industry-standards-and-best-practices.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.partner-integration-guidelines.outcomes.1": "Approche cohérente pour appliquer « Lignes directrices pour l'intégration des partenaires »",
+  "resource.partner-integration-guidelines.outcomes.2": "Meilleure application des pratiques associées",
   "resource.partner-integration-guidelines.steps.1": "Surveillez les performances et la conformité de l'API de vos partenaires pour garantir la fiabilité et l'alignement avec votre stratégie d'API.",
-  "resource.partner-integration-guidelines.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.role-communication-best-practices.outcomes.1": "Approche standardisée utilisant les meilleures pratiques en matière de communication sur les rôles",
-  "resource.role-communication-best-practices.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.partner-integration-guidelines.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.role-communication-best-practices.outcomes.1": "Approche cohérente pour appliquer « Meilleures pratiques en matière de communication sur les rôles »",
+  "resource.role-communication-best-practices.outcomes.2": "Meilleure application des pratiques associées",
   "resource.role-communication-best-practices.steps.1": "Veiller à ce que les rôles et les responsabilités soient communiqués à tous les membres de l'équipe et aux parties prenantes afin d'assurer l'alignement.",
-  "resource.role-communication-best-practices.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.scalable-infrastructure-best-practices.outcomes.1": "Approche normalisée utilisant les meilleures pratiques en matière d'infrastructure évolutive",
-  "resource.scalable-infrastructure-best-practices.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.role-communication-best-practices.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.scalable-infrastructure-best-practices.outcomes.1": "Approche cohérente pour appliquer « Meilleures pratiques en matière d'infrastructure évolutive »",
+  "resource.scalable-infrastructure-best-practices.outcomes.2": "Meilleure application des pratiques associées",
   "resource.scalable-infrastructure-best-practices.steps.1": "Contrôler les performances et la capacité de l'infrastructure pour s'assurer qu'elle peut répondre à une demande croissante.",
-  "resource.scalable-infrastructure-best-practices.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.service-agreement-template.outcomes.1": "Approche standardisée utilisant le modèle d'accord de service",
-  "resource.service-agreement-template.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.scalable-infrastructure-best-practices.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.service-agreement-template.outcomes.1": "Approche cohérente pour appliquer « Modèle de contrat de service »",
+  "resource.service-agreement-template.outcomes.2": "Meilleure application des pratiques associées",
   "resource.service-agreement-template.steps.1": "Utiliser des formats normalisés pour créer des accords de service lisibles par machine, faciles à partager et à valider.",
   "resource.service-agreement-template.steps.2": "Veiller à ce que les accords de service soient examinés et approuvés par les parties prenantes afin de garantir l'alignement et la clarté.",
-  "resource.service-agreement-template.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.stakeholder-engagement-best-practices.outcomes.1": "Approche standardisée utilisant les meilleures pratiques en matière d'engagement des parties prenantes",
-  "resource.stakeholder-engagement-best-practices.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
-  "resource.stakeholder-engagement-best-practices.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.test-automation-frameworks.outcomes.1": "Approche standardisée utilisant des cadres d'automatisation des tests",
-  "resource.test-automation-frameworks.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
-  "resource.test-automation-frameworks.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.vendor-management-best-practices.outcomes.1": "Approche standardisée utilisant les meilleures pratiques de gestion des fournisseurs",
-  "resource.vendor-management-best-practices.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.service-agreement-template.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.stakeholder-engagement-best-practices.outcomes.1": "Approche cohérente pour appliquer « Meilleures pratiques en matière d'engagement des parties prenantes »",
+  "resource.stakeholder-engagement-best-practices.outcomes.2": "Meilleure application des pratiques associées",
+  "resource.stakeholder-engagement-best-practices.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.test-automation-frameworks.outcomes.1": "Approche cohérente pour appliquer « Cadres d'automatisation des tests »",
+  "resource.test-automation-frameworks.outcomes.2": "Meilleure application des pratiques associées",
+  "resource.test-automation-frameworks.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.vendor-management-best-practices.outcomes.1": "Approche cohérente pour appliquer « Meilleures pratiques de gestion des fournisseurs »",
+  "resource.vendor-management-best-practices.outcomes.2": "Meilleure application des pratiques associées",
   "resource.vendor-management-best-practices.steps.1": "Définir les critères d'évaluation des API des fournisseurs, y compris la fiabilité, la sécurité et la conformité.",
-  "resource.vendor-management-best-practices.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
-  "resource.api-audit-checklist.outcomes.1": "Approche normalisée à l'aide de la liste de contrôle de l'audit de l'API",
-  "resource.api-audit-checklist.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.vendor-management-best-practices.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.api-audit-checklist.outcomes.1": "Approche cohérente pour appliquer « Liste de contrôle de l'audit de l'API »",
+  "resource.api-audit-checklist.outcomes.2": "Meilleure application des pratiques associées",
   "resource.api-audit-checklist.steps.1": "Réalisez des audits pour évaluer la couverture du cycle de vie et vérifier que l'API respecte les normes métier, de conception et opérationnelles.",
   "resource.api-audit-checklist.steps.2": "S'assurer que la documentation, les modèles de sécurité, la configuration de la passerelle et les exigences légales sont clairement définis, validés et étayés par des preuves.",
   "resource.api-audit-checklist.tips.1": "Utilisez la liste de contrôle d'audit des API de manière collaborative entre les rôles métier et techniques",
@@ -316,18 +316,18 @@
   "resource.api-business-model-canvas.steps.1": "Définir les segments de consommateurs",
   "resource.api-business-model-canvas.steps.2": "Identifier les stratégies de relations avec les développeurs",
   "resource.api-business-model-canvas.steps.3": "Cartographier les canaux de distribution",
-  "resource.api-business-model-canvas.steps.4": "documenter les ressources et activités clés",
+  "resource.api-business-model-canvas.steps.4": "Documentez les ressources et activités clés.",
   "resource.api-business-model-canvas.steps.5": "Identifier les principaux partenaires et parties prenantes",
   "resource.api-business-model-canvas.steps.6": "Mettre en évidence les avantages et les coûts",
   "resource.api-business-model-canvas.tips.1": "Utiliser des mesures telles que le rapport coût/bénéfice pour hiérarchiser les opportunités",
   "resource.api-business-model-canvas.tips.2": "Valider les résultats avec les principales parties prenantes",
-  "resource.api-design-principles.outcomes.1": "Approche normalisée utilisant les principes de conception de l'API",
-  "resource.api-design-principles.outcomes.2": "Amélioration de la mise en œuvre des pratiques liées à l'API",
+  "resource.api-design-principles.outcomes.1": "Approche cohérente pour appliquer « Principes de conception de l'API »",
+  "resource.api-design-principles.outcomes.2": "Meilleure application des pratiques associées",
   "resource.api-design-principles.steps.1": "**Noms et comportements cohérents:** appliquer des conventions partagées pour les ressources, les erreurs et les formats afin de rendre les API prévisibles.",
   "resource.api-design-principles.steps.2": "**Dirigé par le contrat:** capturer l'interface avec OpenAPI ou AsyncAPI avant le codage pour aligner les équipes et permettre l'automatisation.",
   "resource.api-design-principles.steps.3": "**Utilisabilité et facilité de découverte:** fournir une documentation et des exemples clairs afin que les développeurs comprennent rapidement comment utiliser l'API.",
-  "resource.api-design-principles.steps.4": "**Les conceptions évoluent par petites étapes et par versions, de sorte que les changements ne perturbent pas les consommateurs existants.",
-  "resource.api-design-principles.tips.1": "L'utiliser en collaboration avec les entreprises et les techniciens",
+  "resource.api-design-principles.steps.4": "**Itérer en sécurité :** faites évoluer les conceptions par petits incréments versionnés afin que les changements ne perturbent pas les utilisateurs existants.",
+  "resource.api-design-principles.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
   "resource.api-value-proposition-canvas.outcomes.1": "Alignement sur les besoins des utilisateurs",
   "resource.api-value-proposition-canvas.outcomes.2": "Amélioration de la satisfaction des consommateurs d'API",
   "resource.api-value-proposition-canvas.steps.1": "Identifier les caractéristiques permettant d'obtenir les gains escomptés",
@@ -335,25 +335,25 @@
   "resource.api-value-proposition-canvas.steps.3": "Cartographier les caractéristiques des produits de l'API",
   "resource.api-value-proposition-canvas.tips.1": "Mettre en évidence les caractéristiques qui soulagent les douleurs ou améliorent les gains",
   "resource.api-value-proposition-canvas.tips.2": "Valider les caractéristiques avec les consommateurs d'API pour garantir l'alignement",
-  "resource.business-impact-canvas.outcomes.1": "Sécurité et conformité renforcées",
-  "resource.business-impact-canvas.outcomes.2": "Amélioration des performances de l'API",
+  "resource.business-impact-canvas.outcomes.1": "Risques et mesures d’atténuation priorisés",
+  "resource.business-impact-canvas.outcomes.2": "Éléments probants pour les décisions d’architecture et de plateforme",
   "resource.business-impact-canvas.steps.1": "Moyens d'atténuer les risques liés à la disponibilité : Définir les mesures d'atténuation.",
   "resource.business-impact-canvas.steps.2": "Risques liés à la sécurité : Documenter les risques liés à la sécurité.",
   "resource.business-impact-canvas.steps.3": "Moyens d'atténuer les risques de sécurité : Proposer des stratégies pour atténuer les risques de sécurité.",
   "resource.business-impact-canvas.steps.4": "Risques liés aux données : Identifier les risques pour l'exactitude ou la disponibilité des données.",
   "resource.business-impact-canvas.steps.5": "Moyens d'atténuer les risques liés aux données : Prévoir des stratégies pour faire face aux risques liés aux données.",
-  "resource.business-impact-canvas.tips.1": "Utiliser les incidents passés pour identifier les risques potentiels",
-  "resource.business-impact-canvas.tips.2": "Priorité aux API critiques ayant le plus d'impact sur l'activité de l'entreprise",
-  "resource.capacity-canvas.outcomes.1": "Préparés aux futures tendances de la consommation",
-  "resource.capacity-canvas.outcomes.2": "Stratégies définies de mise en cache et de limitation du débit",
+  "resource.business-impact-canvas.tips.1": "Examinez les risques avec les parties prenantes métier et techniques.",
+  "resource.business-impact-canvas.tips.2": "Utilisez les incidents passés et les données opérationnelles pour remettre en question les hypothèses.",
+  "resource.capacity-canvas.outcomes.1": "Hypothèses de pics de charge, de disponibilité et de croissance documentées",
+  "resource.capacity-canvas.outcomes.2": "Décisions de mise à l’échelle, de mise en cache et de limitation de débit définies",
   "resource.capacity-canvas.steps.1": "Prévoir les tendances futures de la consommation",
   "resource.capacity-canvas.steps.2": "Planifier les pics de charge et les exigences de disponibilité",
   "resource.capacity-canvas.steps.3": "Définir les stratégies de mise en cache et de limitation du débit",
   "resource.capacity-canvas.steps.4": "Proposer des stratégies de mise à l'échelle",
-  "resource.capacity-canvas.tips.1": "Définir des scénarios d'utilisation maximale",
-  "resource.capacity-canvas.tips.2": "Inclure des tests d'évolutivité dans la phase de planification",
-  "resource.customer-journey-canvas.outcomes.1": "Conception améliorée de l'API",
-  "resource.customer-journey-canvas.outcomes.2": "Une meilleure expérience pour l'utilisateur",
+  "resource.capacity-canvas.tips.1": "Utilisez des données mesurées lorsqu’elles sont disponibles et explicitez les hypothèses.",
+  "resource.capacity-canvas.tips.2": "Réexaminez le canvas après les pilotes ou tout changement significatif de la demande.",
+  "resource.customer-journey-canvas.outcomes.1": "Besoins, irritants, gains, entrées et sorties documentés",
+  "resource.customer-journey-canvas.outcomes.2": "Éléments du parcours disponibles pour les décisions de capacité, d’exigences et d’architecture",
   "resource.customer-journey-canvas.steps.1": "Identifier les éléments déclencheurs du voyage",
   "resource.customer-journey-canvas.steps.2": "Décrire la fin du voyage",
   "resource.customer-journey-canvas.steps.3": "Cartographier les étapes du voyage avec les intrants et les extrants",
@@ -361,13 +361,13 @@
   "resource.customer-journey-canvas.steps.5": "Résumer les gains pour les clients",
   "resource.customer-journey-canvas.steps.6": "Définir les intrants nécessaires et les résultats qui en découlent",
   "resource.customer-journey-canvas.steps.7": "Définir les interactions API pour chaque étape",
-  "resource.customer-journey-canvas.tips.1": "Utiliser les résultats de ce canevas pour informer d'autres canevas tels que le canevas de proposition de valeur de l'API.",
-  "resource.event-canvas.outcomes.1": "Déclencheurs d'événements et logique de traitement clairs",
-  "resource.event-canvas.outcomes.2": "Amélioration de la réactivité aux changements en temps réel",
+  "resource.customer-journey-canvas.tips.1": "Utilisez les résultats pour alimenter le travail sur la proposition de valeur, le domaine, les exigences et l’architecture.",
+  "resource.event-canvas.outcomes.1": "Événements, déclencheurs, schémas, producteurs et utilisateurs clarifiés",
+  "resource.event-canvas.outcomes.2": "Attentes de traitement, d’accusé de réception et de gestion des échecs documentées",
   "resource.event-canvas.steps.1": "Définir des déclencheurs pour chaque événement",
-  "resource.event-canvas.steps.2": "Décrire la logique de traitement des événements par le backend",
+  "resource.event-canvas.steps.2": "Décrivez le traitement des événements, les changements d’état et la gestion des échecs.",
   "resource.event-canvas.steps.3": "Préciser les résultats obtenus ou les remerciements",
-  "resource.event-canvas.tips.1": "documenter les flux d'événements et les dépendances",
+  "resource.event-canvas.tips.1": "Documentez les flux d’événements, les responsabilités, les hypothèses d’ordre et les dépendances.",
   "resource.event-canvas.tips.2": "Valider le traitement des événements à l'aide de cas de test",
   "resource.graphql-canvas.outcomes.1": "Types définis et leurs relations",
   "resource.graphql-canvas.outcomes.2": "Des requêtes, des mutations et des abonnements clairs",
@@ -378,18 +378,18 @@
   "resource.graphql-canvas.steps.5": "Abonnements aux grandes lignes pour des mises à jour en temps réel",
   "resource.graphql-canvas.steps.6": "Définir l'authentification et l'autorisation : Qui peut accéder à quels champs ou types ?",
   "resource.graphql-canvas.steps.7": "Tenez compte des contraintes de pagination, de filtrage ou de limitation du débit.",
-  "resource.graphql-canvas.tips.1": "documenter les exemples de requêtes et de mutations",
+  "resource.graphql-canvas.tips.1": "Documentez des exemples de requêtes et de mutations.",
   "resource.graphql-canvas.tips.2": "Veiller à ce que les noms des types soient descriptifs et cohérents",
-  "resource.interaction-canvas.outcomes.1": "Entrées et sorties définies pour chaque interaction",
-  "resource.interaction-canvas.outcomes.2": "Règles de validation cohérentes entre les interactions",
+  "resource.interaction-canvas.outcomes.1": "Entrées, sorties, commandes, requêtes, événements et réponses clarifiés",
+  "resource.interaction-canvas.outcomes.2": "Règles de validation et attentes d’interaction convenues",
   "resource.interaction-canvas.steps.1": "Définir des points finaux pour chaque interaction",
-  "resource.interaction-canvas.steps.2": "documenter les entrées et les sorties pour chaque interaction",
+  "resource.interaction-canvas.steps.2": "Documentez les entrées et les sorties de chaque interaction.",
   "resource.interaction-canvas.steps.3": "Spécifier les règles et contraintes de validation",
   "resource.interaction-canvas.steps.4": "Créer des modèles d'interaction pour les interactions CRUD, axées sur les requêtes, axées sur les commandes et axées sur les événements.",
   "resource.interaction-canvas.tips.1": "Simuler des interactions avec des données fictives pour valider les flux de travail",
-  "resource.interaction-canvas.tips.2": "documenter les réponses attendues en cas d'interactions réussies ou non",
-  "resource.location-canvas.outcomes.1": "Optimisation des performances de l'API dans toutes les régions",
-  "resource.location-canvas.outcomes.2": "Meilleure compréhension des besoins régionaux",
+  "resource.interaction-canvas.tips.2": "Documentez les réponses attendues pour les interactions réussies, échouées et exceptionnelles.",
+  "resource.location-canvas.outcomes.1": "Contraintes régionales de performance et d’accessibilité identifiées",
+  "resource.location-canvas.outcomes.2": "Résidence des données, limites de confiance et réglementations applicables clarifiées",
   "resource.location-canvas.steps.1": "Documenter l'emplacement des consommateurs.",
   "resource.location-canvas.steps.2": "Identifier les réglementations applicables.",
   "resource.location-canvas.steps.3": "Documenter l'endroit où les données doivent être stockées.",
@@ -403,5 +403,143 @@
   "resource.rest-canvas.steps.2": "Spécifier les verbes HTTP utilisés pour interagir avec les ressources",
   "resource.rest-canvas.steps.3": "Fournir des exemples de demandes et de réponses pour chaque verbe",
   "resource.rest-canvas.tips.1": "Veiller à ce que les URI des ressources soient intuitifs et cohérents",
-  "resource.rest-canvas.tips.2": "gestion des erreurs de documents et codes de réponse"
-}
+  "resource.rest-canvas.tips.2": "Documentez la gestion des erreurs et les codes de réponse.",
+  "resource.capability-value-proposition-canvas.title": "Capability Value Proposition Canvas",
+  "resource.capability-value-proposition-canvas.description": "Un canvas indépendant de la technologie pour cartographier les tâches, gains, irritants et capacités réutilisables candidates des utilisateurs avant de sélectionner un mode de mise en œuvre.",
+  "resource.capability-value-proposition-canvas.outcomes": "Proposition de valeur claire pour une capacité réutilisable",
+  "resource.capability-value-proposition-canvas.outcomes.1": "Tâches, gains et irritants des utilisateurs capturés sans présupposer de technologie",
+  "resource.capability-value-proposition-canvas.outcomes.2": "Capacités réutilisables candidates identifiées pour l’évaluation d’architecture",
+  "resource.capability-value-proposition-canvas.steps": "Listez les tâches et résultats utilisateurs que la capacité doit prendre en charge.",
+  "resource.capability-value-proposition-canvas.steps.1": "Identifiez les caractéristiques de capacité qui permettent les gains.",
+  "resource.capability-value-proposition-canvas.steps.2": "Identifiez les caractéristiques de capacité qui réduisent les irritants.",
+  "resource.capability-value-proposition-canvas.steps.3": "Regroupez les caractéristiques en capacités réutilisables candidates.",
+  "resource.capability-value-proposition-canvas.tips": "Restez indépendant de la technologie jusqu’à ce que les exigences indiquent un mode de mise en œuvre adapté.",
+  "resource.capability-value-proposition-canvas.tips.1": "Utilisez ce canvas à la place de l’API Value Proposition Canvas lorsqu’une API n’est pas encore le mode de mise en œuvre retenu.",
+  "resource.capability-business-model-canvas.title": "Capability Business Model Canvas",
+  "resource.capability-business-model-canvas.description": "Un business model canvas pour les capacités réutilisables, couvrant la valeur, les utilisateurs, la responsabilité, l’engagement, les coûts et les bénéfices sans présupposer de mode de mise en œuvre.",
+  "resource.capability-business-model-canvas.outcomes": "Modèle opérationnel viable pour une capacité réutilisable",
+  "resource.capability-business-model-canvas.outcomes.1": "Responsabilité, utilisateurs, canaux, partenaires et besoins de support clarifiés",
+  "resource.capability-business-model-canvas.outcomes.2": "Coûts et bénéfices visibles avant l’engagement architectural",
+  "resource.capability-business-model-canvas.steps": "Résumez la proposition de valeur de la capacité.",
+  "resource.capability-business-model-canvas.steps.1": "Identifiez les segments d’utilisateurs et les canaux d’engagement.",
+  "resource.capability-business-model-canvas.steps.2": "Définissez les activités, ressources et partenaires clés.",
+  "resource.capability-business-model-canvas.steps.3": "Documentez les coûts et les bénéfices.",
+  "resource.capability-business-model-canvas.steps.4": "Clarifiez la responsabilité, le financement, le support et les attentes de cycle de vie.",
+  "resource.capability-business-model-canvas.steps.5": "Validez le modèle avec les utilisateurs, producteurs et parties prenantes de gouvernance.",
+  "resource.capability-business-model-canvas.tips": "Utilisez ce canvas à la place de l’API Business Model Canvas tant que le mode de mise en œuvre reste ouvert.",
+  "resource.capability-business-model-canvas.tips.1": "Concentrez-vous sur la viabilité d’une capacité réutilisable, et non sur une connexion ponctuelle.",
+  "resource.consumer-experience-requirements-canvas.title": "Consumer Experience Requirements Canvas",
+  "resource.consumer-experience-requirements-canvas.description": "Un canvas d’exigences pour l’expérience utilisateur et les besoins non fonctionnels, destiné à guider les décisions ultérieures d’architecture et de mode de mise en œuvre.",
+  "resource.consumer-experience-requirements-canvas.outcomes": "Exigences utilisateurs et de service indépendantes de la technologie",
+  "resource.consumer-experience-requirements-canvas.outcomes.1": "Besoins d’expérience et exigences non fonctionnelles capturés avant le début de la conception",
+  "resource.consumer-experience-requirements-canvas.outcomes.2": "Impacts architecturaux documentés pour le choix du mode de mise en œuvre",
+  "resource.consumer-experience-requirements-canvas.steps": "Capturez les objectifs des utilisateurs et leur contexte d’usage.",
+  "resource.consumer-experience-requirements-canvas.steps.1": "Documentez les attentes de disponibilité, de fraîcheur, de volume, de performance, de qualité et de cohérence des données.",
+  "resource.consumer-experience-requirements-canvas.steps.2": "Documentez les attentes de sécurité, de confidentialité, d’onboarding, de changement, d’observabilité, de support et de reprise.",
+  "resource.consumer-experience-requirements-canvas.steps.3": "Résumez ce que les exigences impliquent pour les modes de mise en œuvre possibles.",
+  "resource.consumer-experience-requirements-canvas.tips": "Utilisez ce canvas comme lien entre la valeur de la capacité et la décision d’architecture.",
+  "resource.consumer-experience-requirements-canvas.tips.1": "Ne choisissez pas API, événement, fichier, flux, produit de données, intégration directe ou style hybride avant que les exigences n’indiquent l’option la plus adaptée.",
+  "resource.integration-style-selection-guide.title": "Guide de sélection du mode d’intégration",
+  "resource.integration-style-selection-guide.description": "Guide pour choisir entre API, événement, fichier, flux, produit de données, intégration directe ou mode hybride selon les exigences et contraintes.",
+  "resource.integration-style-selection-guide.outcomes": "Mode de mise en œuvre de l’intégration justifié",
+  "resource.integration-style-selection-guide.outcomes.1": "Compromis documentés entre les différentes options",
+  "resource.integration-style-selection-guide.outcomes.2": "Choix traçable aux exigences utilisateurs, plateforme, données et opérations",
+  "resource.integration-style-selection-guide.steps": "Comparez les modes viables selon la latence, le volume, le couplage, la responsabilité des données, la fraîcheur, la gouvernance et l’exploitabilité.",
+  "resource.integration-style-selection-guide.steps.1": "Identifiez les options adaptées au cas d’usage.",
+  "resource.integration-style-selection-guide.steps.2": "Documentez contraintes, risques et dépendances de plateforme.",
+  "resource.integration-style-selection-guide.steps.3": "Consignez les raisons du rejet des alternatives.",
+  "resource.process-workflow-design-guide.title": "Guide de conception des processus et workflows",
+  "resource.process-workflow-design-guide.description": "Guide pour modéliser étapes, rôles, transferts, décisions, états, entrées, sorties et exceptions d’un workflow automatisé.",
+  "resource.process-workflow-design-guide.outcomes": "Conception claire du workflow automatisé",
+  "resource.process-workflow-design-guide.outcomes.1": "Étapes et transferts documentés avant mise en œuvre",
+  "resource.process-workflow-design-guide.outcomes.2": "États, entrées, sorties et exceptions compris",
+  "resource.process-workflow-design-guide.steps": "Cartographiez le processus actuel et cible, avec les responsabilités humaines et système.",
+  "resource.process-workflow-design-guide.steps.1": "Identifiez déclencheurs, états, décisions, données, sorties et critères de fin.",
+  "resource.process-workflow-design-guide.steps.2": "Documentez les transferts entre utilisateurs, systèmes, opérations et support.",
+  "resource.process-workflow-design-guide.steps.3": "Confirmez les étapes automatisées et celles nécessitant un jugement humain.",
+  "resource.decision-business-rules-guide.title": "Guide des décisions et règles métier",
+  "resource.decision-business-rules-guide.description": "Guide pour capturer règles, seuils, décisions, validations, critères d’éligibilité et responsabilités.",
+  "resource.decision-business-rules-guide.outcomes": "Décisions et règles métier explicites",
+  "resource.decision-business-rules-guide.outcomes.1": "Règles et seuils documentés avec leurs responsables",
+  "resource.decision-business-rules-guide.outcomes.2": "Décisions traçables aux politiques, processus ou objectifs métier",
+  "resource.decision-business-rules-guide.steps": "Listez les décisions que l’automatisation doit prendre ou soutenir.",
+  "resource.decision-business-rules-guide.steps.1": "Documentez conditions, seuils, exceptions, validations et escalades.",
+  "resource.decision-business-rules-guide.steps.2": "Identifiez les responsables et la gouvernance des changements.",
+  "resource.automation-trigger-handoff-exception-guide.title": "Guide des déclencheurs, transferts et exceptions",
+  "resource.automation-trigger-handoff-exception-guide.description": "Guide pour définir déclencheurs, transferts humains, exceptions, reprises, actions compensatoires et escalades.",
+  "resource.automation-trigger-handoff-exception-guide.outcomes": "Déclencheurs et chemins d’exception définis",
+  "resource.automation-trigger-handoff-exception-guide.outcomes.1": "Transferts humains et escalades explicites",
+  "resource.automation-trigger-handoff-exception-guide.outcomes.2": "Exceptions, reprises et compensations conçues avant livraison",
+  "resource.automation-trigger-handoff-exception-guide.steps": "Définissez événements, horaires, actions utilisateur ou états système déclencheurs.",
+  "resource.automation-trigger-handoff-exception-guide.steps.1": "Cartographiez les transferts vers utilisateurs, opérateurs ou support.",
+  "resource.automation-trigger-handoff-exception-guide.steps.2": "Documentez exceptions, reprises, délais et solutions de repli.",
+  "resource.automation-trigger-handoff-exception-guide.steps.3": "Définissez alertes et seuils d’escalade.",
+  "resource.automation-testing-guide.title": "Guide de test des automatisations",
+  "resource.automation-testing-guide.description": "Guide pour tester workflows, décisions, intégrations, exceptions, rollback, supervision et impact utilisateur.",
+  "resource.automation-testing-guide.outcomes": "Comportement de l’automatisation validé",
+  "resource.automation-testing-guide.outcomes.1": "Tests des workflows, règles, exceptions et intégrations définis",
+  "resource.automation-testing-guide.outcomes.2": "Confiance avant publication pour les parcours automatisés et assistés",
+  "resource.automation-testing-guide.steps": "Créez des tests pour parcours nominaux, cas limites, exceptions, reprises et transferts.",
+  "resource.automation-testing-guide.steps.1": "Validez règles métier et décisions avec des données représentatives.",
+  "resource.automation-testing-guide.steps.2": "Testez rollback, reprise, observabilité et intervention manuelle.",
+  "resource.automation-testing-guide.steps.3": "Impliquez utilisateurs et opérateurs dans les tests d’acceptation.",
+  "resource.automation-operational-ownership-guide.title": "Guide de responsabilité opérationnelle",
+  "resource.automation-operational-ownership-guide.description": "Guide pour définir responsabilité, runbooks, supervision, support, suivi, contrôle des changements et amélioration continue.",
+  "resource.automation-operational-ownership-guide.outcomes": "Modèle opérationnel clair",
+  "resource.automation-operational-ownership-guide.outcomes.1": "Responsabilités de propriété, support et escalade attribuées",
+  "resource.automation-operational-ownership-guide.outcomes.2": "Pratiques de suivi et changement prêtes pour exploitation",
+  "resource.automation-operational-ownership-guide.steps": "Définissez les responsables métier, techniques et opérationnels.",
+  "resource.automation-operational-ownership-guide.steps.1": "Documentez runbooks, support, signaux de suivi, attentes de service et escalades.",
+  "resource.automation-operational-ownership-guide.steps.2": "Définissez le contrôle des changements pour workflows, plateforme et règles.",
+  "resource.automation-rollback-supervision-guide.title": "Guide de rollback et supervision",
+  "resource.automation-rollback-supervision-guide.description": "Guide pour concevoir rollback, pause, dérogation manuelle, suivi, supervision et reprise.",
+  "resource.automation-rollback-supervision-guide.outcomes": "Chemins de reprise contrôlés",
+  "resource.automation-rollback-supervision-guide.outcomes.1": "Rollback, pause et dérogation documentés",
+  "resource.automation-rollback-supervision-guide.outcomes.2": "Besoins de supervision et responsabilités de reprise définis",
+  "resource.automation-rollback-supervision-guide.steps": "Identifiez les actions réversibles, suspendables ou remplaçables manuellement.",
+  "resource.automation-rollback-supervision-guide.steps.1": "Définissez rollback, compensation et reprise.",
+  "resource.automation-rollback-supervision-guide.steps.2": "Documentez seuils de supervision, alertes et décisions manuelles.",
+  "resource.automation-rollback-supervision-guide.steps.3": "Validez les procédures de reprise avant publication.",
+  "resource.automation-readiness-checklist.title": "Checklist de préparation des automatisations",
+  "resource.automation-readiness-checklist.description": "Checklist pour valider workflow, contrôles, risques, conformité, supervision humaine, preuves de test, rollback, opérations et préparation.",
+  "resource.automation-readiness-checklist.outcomes": "Préparation de l’automatisation documentée",
+  "resource.automation-readiness-checklist.outcomes.1": "Écarts et mesures d’atténuation connus avant publication",
+  "resource.automation-readiness-checklist.outcomes.2": "Preuves pour qualité, risques, conformité, supervision et approbation",
+  "resource.automation-readiness-checklist.steps": "Examinez workflow, règles métier, contrôles, accès, données et exceptions.",
+  "resource.automation-readiness-checklist.steps.1": "Vérifiez preuves de test, rollback, supervision et support.",
+  "resource.automation-readiness-checklist.steps.2": "Confirmez responsabilités, runbooks, suivi et contrôle des changements.",
+  "resource.automation-readiness-checklist.steps.3": "Consignez les écarts, décisions et risques acceptés.",
+  "resource.automation-rollout-enablement-guide.title": "Guide de déploiement et d’enablement",
+  "resource.automation-rollout-enablement-guide.description": "Guide pour déployer les automatisations avec communication, onboarding, instructions d’exploitation, support, conduite du changement et feedback.",
+  "resource.automation-rollout-enablement-guide.outcomes": "Utilisateurs et opérateurs préparés",
+  "resource.automation-rollout-enablement-guide.outcomes.1": "Communication, onboarding et support préparés",
+  "resource.automation-rollout-enablement-guide.outcomes.2": "Compréhension des changements de travail après publication",
+  "resource.automation-rollout-enablement-guide.steps": "Définissez publics, calendrier, canaux et besoins de formation.",
+  "resource.automation-rollout-enablement-guide.steps.1": "Publiez instructions, support, gestion des exceptions et contacts.",
+  "resource.automation-rollout-enablement-guide.steps.2": "Planifiez l’accompagnement de transition.",
+  "resource.automation-rollout-enablement-guide.steps.3": "Collectez les retours et alimentez le backlog.",
+  "resource.integration-style-selection-guide.tips": "Adaptez cette ressource à votre contexte.",
+  "resource.integration-style-selection-guide.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.process-workflow-design-guide.tips": "Adaptez cette ressource à votre contexte.",
+  "resource.process-workflow-design-guide.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.decision-business-rules-guide.tips": "Adaptez cette ressource à votre contexte.",
+  "resource.decision-business-rules-guide.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.automation-trigger-handoff-exception-guide.tips": "Adaptez cette ressource à votre contexte.",
+  "resource.automation-trigger-handoff-exception-guide.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.automation-testing-guide.tips": "Adaptez cette ressource à votre contexte.",
+  "resource.automation-testing-guide.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.automation-operational-ownership-guide.tips": "Adaptez cette ressource à votre contexte.",
+  "resource.automation-operational-ownership-guide.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.automation-rollback-supervision-guide.tips": "Adaptez cette ressource à votre contexte.",
+  "resource.automation-rollback-supervision-guide.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.automation-readiness-checklist.tips": "Adaptez cette ressource à votre contexte.",
+  "resource.automation-readiness-checklist.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.automation-rollout-enablement-guide.tips": "Adaptez cette ressource à votre contexte.",
+  "resource.automation-rollout-enablement-guide.tips.1": "Utilisez cette ressource avec les rôles métier et techniques concernés.",
+  "resource.api-community-engagement-strategies.tips.2": "Utilisez cette ressource lorsque l’API est le mode de mise en œuvre retenu.",
+  "resource.api-development-best-practices.tips.2": "Utilisez cette ressource lorsque l’API est le mode de mise en œuvre retenu.",
+  "resource.api-metrics-and-analytics.tips.2": "Utilisez cette ressource lorsque l’API est le mode de mise en œuvre retenu.",
+  "resource.api-testing-best-practices.tips.2": "Utilisez cette ressource lorsque l’API est le mode de mise en œuvre retenu.",
+  "resource.apiops-CI-CD-for-apis.tips.2": "Utilisez cette ressource lorsque l’API est le mode de mise en œuvre retenu.",
+  "resource.api-audit-checklist.tips.2": "Utilisez cette ressource lorsque l’API est le mode de mise en œuvre retenu."
+}
\ No newline at end of file
diff --git a/src/data/method/fr/labels.stakeholders.json b/src/data/method/fr/labels.stakeholders.json
index ff8eb0d..003943a 100644
--- a/src/data/method/fr/labels.stakeholders.json
+++ b/src/data/method/fr/labels.stakeholders.json
@@ -1,35 +1,49 @@
 {
-  "stakeholder.involvement.lead": "Chef",
+  "stakeholder.involvement.lead": "Responsable",
   "stakeholder.involvement.core": "Principal",
   "stakeholder.involvement.consulted": "Consulté",
   "stakeholder.business-owner.title": "Responsable métier",
-  "stakeholder.business-owner.description": "Représente les objectifs commerciaux, le financement et les résultats attendus pour l'initiative API.",
+  "stakeholder.business-owner.description": "Représente les objectifs métier, le financement et les résultats attendus de l’initiative de capacité, d’API ou d’automatisation.",
   "stakeholder.api-program-owner.title": "Responsable du programme API",
   "stakeholder.api-program-owner.description": "Coordonne les pratiques du portefeuille API, l'alignement organisationnel et le développement à long terme des capacités API.",
   "stakeholder.api-product-owner.title": "Propriétaire du produit API",
-  "stakeholder.api-product-owner.description": "Piloter l'opportunité API, la priorisation et les décisions au niveau du produit tout au long du cycle de vie.",
-  "stakeholder.domain-expert.title": "Expert du domaine",
-  "stakeholder.domain-expert.description": "Apporte une connaissance approfondie du domaine métier, des concepts, des règles et des contraintes que l'API doit refléter.",
-  "stakeholder.customer-or-partner-representative.title": "Représentant client ou partenaire",
-  "stakeholder.customer-or-partner-representative.description": "Contribue à la perspective du client ou partenaire commercial pour le parcours, la valeur et le modèle de collaboration.",
-  "stakeholder.api-consumer-representative.title": "Représentant utilisateur API",
-  "stakeholder.api-consumer-representative.description": "Représente les besoins des développeurs, intégrateurs ou autres utilisateurs d'API qui utilisent l'API directement.",
+  "stakeholder.api-product-owner.description": "Pilote l’opportunité API, la priorisation et les décisions au niveau produit tout au long du cycle de vie.",
+  "stakeholder.capability-owner.title": "Responsable de capacité",
+  "stakeholder.capability-owner.description": "Responsable de la vision, de la valeur, des priorités, du cycle de vie et de la réutilisation de la capacité auprès des utilisateurs.",
+  "stakeholder.domain-specialist.title": "Expert du domaine",
+  "stakeholder.domain-specialist.description": "Apporte une connaissance approfondie du domaine métier, des concepts, des règles et des contraintes que la capacité ou l’interface doit refléter.",
+  "stakeholder.customer-specialist.title": "Représentant client ou partenaire",
+  "stakeholder.customer-specialist.description": "Contribue à la perspective du client ou partenaire pour le parcours, la valeur et le modèle de collaboration.",
+  "stakeholder.api-consumer-specialist.title": "Représentant utilisateur API",
+  "stakeholder.api-consumer-specialist.description": "Représente les besoins des développeurs, intégrateurs ou autres utilisateurs d'API qui utilisent l'API directement.",
   "stakeholder.platform-architect.title": "Architecte de la plateforme",
-  "stakeholder.platform-architect.description": "Orienté les décisions sur la plateforme, l'intégration, l'évolutivité et l'architecture qui façonnent la construction et l'exploitation de l'API.",
+  "stakeholder.platform-architect.description": "Oriente les décisions relatives à la plateforme, à l’intégration, à l’évolutivité et à l’architecture qui déterminent comment la capacité ou l’API est construite et exploitée.",
+  "stakeholder.api-architect.title": "Architecte API",
+  "stakeholder.api-architect.description": "Responsable de l'architecture API, des principes de conception et de la qualité des contrats d'interface.",
+  "stakeholder.integration-architect.title": "Architecte d'intégration",
+  "stakeholder.integration-architect.description": "Conçoit les approches d’intégration et les modes de mise en œuvre qui relient la capacité ou l’API aux autres systèmes.",
+  "stakeholder.platform-owner.title": "Responsable de plateforme",
+  "stakeholder.platform-owner.description": "Responsable des capacités de la plateforme, de la feuille de route, du modèle opérationnel et des attentes de service.",
   "stakeholder.api-designer.title": "Designer API",
-  "stakeholder.api-designer.description": "Conçoit le contrat API, le modèle d'interaction, la cohérence et l'utilisabilité des capacités exposées.",
-  "stakeholder.delivery-engineer.title": "Ingénieur de livraison",
-  "stakeholder.delivery-engineer.description": "Assume la responsabilité de l'implémentation, de l'automatisation, des tests et du flux de publication nécessaires pour livrer l'API de manière fiable.",
+  "stakeholder.api-designer.description": "Conçoit le contrat d’interface, le modèle d’interaction, la cohérence et l’utilisabilité des capacités exposées.",
+  "stakeholder.api-engineer.title": "Ingénieur de livraison",
+  "stakeholder.api-engineer.description": "Assume la responsabilité de la mise en œuvre, de l’automatisation, des tests et du flux de publication nécessaires pour livrer la capacité, l’API ou l’automatisation de manière fiable.",
+  "stakeholder.automation-owner.title": "Responsable de l'automatisation",
+  "stakeholder.automation-owner.description": "Responsable des objectifs, de la valeur métier, des priorités, des contrôles et des résultats du cycle de vie de l’automatisation.",
+  "stakeholder.process-owner.title": "Responsable de processus",
+  "stakeholder.process-owner.description": "Responsable du processus métier à automatiser, y compris les objectifs, les règles, les résultats et les priorités d’amélioration.",
+  "stakeholder.automation-engineer.title": "Ingénieur automatisation",
+  "stakeholder.automation-engineer.description": "Met en œuvre, teste, intègre et exploite les solutions d’automatisation et les workflows associés.",
   "stakeholder.security-specialist.title": "Spécialiste en sécurité",
-  "stakeholder.security-specialist.description": "Assure que les risques de sécurité, les contrôles et les limites de confiance sont pris en compte tout au long du cycle de vie de l'API.",
-  "stakeholder.compliance-legal-specialist.title": "Spécialiste en conformité et juridique",
-  "stakeholder.compliance-legal-specialist.description": "Clarifie les exigences légales, de confidentialité, réglementaires et contractuelles qui affectent l'API.",
-  "stakeholder.governance-owner.title": "Propriétaire de la gouvernance",
-  "stakeholder.governance-owner.description": "Représente les pratiques de revue, d'audit et de gouvernance à l'échelle de l'organisation pour la qualité et la conformité des API.",
-  "stakeholder.documentation-devrel-owner.title": "Propriétaire de la documentation et du développement communautaire",
-  "stakeholder.documentation-devrel-owner.description": "Possède le contenu d'intégration, la communication avec les développeurs et la qualité de la documentation pour les utilisateurs d'API.",
-  "stakeholder.support-operations-owner.title": "Propriétaire du support et des opérations",
-  "stakeholder.support-operations-owner.description": "Représente le support en production, la gestion des incidents, l'observabilité et la préparation opérationnelle.",
-  "stakeholder.partner-vendor-manager.title": "Gestionnaire de partenaires ou de fournisseurs",
-  "stakeholder.partner-vendor-manager.description": "Coordonne les relations avec les partenaires externes, les fournisseurs ou les vendeurs qui influencent la stratégie et la livraison de l'API."
+  "stakeholder.security-specialist.description": "Assure que les risques de sécurité, les contrôles et les limites de confiance sont pris en compte tout au long du cycle de vie.",
+  "stakeholder.compliance-specialist.title": "Spécialiste en conformité et juridique",
+  "stakeholder.compliance-specialist.description": "Clarifie les exigences juridiques, de confidentialité, réglementaires et contractuelles qui affectent la capacité, l’API, l’interface ou l’automatisation.",
+  "stakeholder.governance-specialist.title": "Responsable gouvernance",
+  "stakeholder.governance-specialist.description": "Représente les pratiques de revue, d'audit et de gouvernance à l'échelle de l'organisation pour la qualité et la conformité des API.",
+  "stakeholder.api-devrel-specialist.title": "Responsable Documentation & DevRel",
+  "stakeholder.api-devrel-specialist.description": "Responsable des contenus d'onboarding, de la communication avec les développeurs et de la qualité de la documentation API.",
+  "stakeholder.operations-specialist.title": "Responsable support et opérations",
+  "stakeholder.operations-specialist.description": "Représente le support en production, la gestion des incidents, l’observabilité et la préparation opérationnelle pour la capacité, l’API ou l’automatisation.",
+  "stakeholder.partner-specialist.title": "Gestionnaire de partenaires ou de fournisseurs",
+  "stakeholder.partner-specialist.description": "Coordonne les relations avec les partenaires, fournisseurs ou prestataires externes qui influencent la stratégie et la mise en œuvre de la capacité ou de l’API."
 }
diff --git a/src/data/method/fr/labels.stations.json b/src/data/method/fr/labels.stations.json
index f254579..c8ea246 100644
--- a/src/data/method/fr/labels.stations.json
+++ b/src/data/method/fr/labels.stations.json
@@ -1,61 +1,61 @@
 {
-  "group.core-stations.title": "Stations centrales du cycle de vie de l'API",
-  "group.core-stations.description": "Les stations centrales de l'API Metro, où les équipes peuvent apprendre à créer et à gérer des API de manière efficace.",
-  "group.sub-stations.title": "Sous-stations du cycle de vie de l'API",
-  "group.sub-stations.description": "Sous-stations qui fournissent des ressources supplémentaires, des outils et des meilleures pratiques pour les équipes API.",
-  "station.api-product-strategy.title": "Stratégie produit API - Transformer les API en produits stratégiques",
-  "station.api-product-strategy.description": "Avant de construire quoi que ce soit, définissez dès le départ la valeur de votre API, ses utilisateurs et ses objectifs commerciaux.",
-  "station.api-product-strategy.why_it_matters": "De nombreuses organisations considèrent les API comme des projets technologiques et non comme des produits. Le résultat ? Des consommateurs désorientés, une adoption médiocre et un gaspillage d'efforts.\n\nCette station vous aide à définir l'objectif, le public cible et les critères de réussite de votre API, afin que les équipes puissent fournir des API qui résolvent des problèmes réels.",
-  "station.api-product-strategy.apply_in_work": "Fournir des lignes directrices et des modèles pour la création de modèles commerciaux, de propositions de valeur et de feuilles de route pour les API.",
-  "station.api-product-strategy.outcomes": "Une proposition de valeur et un public simples pour l'API",
-  "station.api-product-strategy.how_it_works": "Explorez le problème du client ou du partenaire que vous comptez résoudre avec les API. Dressez la carte des parties prenantes, de leurs parcours et de leurs résultats à l'aide du Customer Journey canvas.",
-  "station.api-consumer-experience.title": "API Consumer Experience - Concevoir pour les vrais utilisateurs de votre API",
-  "station.api-consumer-experience.description": "Veillez à ce que votre API soit découvrable, compréhensible et utilisable - avant et après le lancement.",
-  "station.api-consumer-experience.why_it_matters": "Les meilleures API ne se contentent pas de fonctionner, elles sont intuitives. Que votre consommateur soit un développeur interne, un partenaire externe ou un agent d'intelligence artificielle, c'est son expérience qui détermine l'adoption.\n\nSans un plan d'expérience clair :\n- Les meilleures API restent inutilisées\n- Les équipes perdent du temps à deviner comment utiliser votre API.\n- Les boucles de rétroaction sont brisées ou manquantes.\n\nCette station vous aide à voir votre API à travers les yeux de ses consommateurs.",
-  "station.api-consumer-experience.how_it_works": "Examinez l'API Value Proposition Canvas du point de vue de l'utilisateur. Veillez à la stabilité des tâches métier prises en charge et enrichissez les fonctionnalités qui simplifient et optimisent l'expérience utilisateur en intégrant les préoccupations des utilisateurs afin d'orienter les décisions de conception ultérieures.",
-  "station.api-consumer-experience.how_it_works.1":"Utilisez le canevas du parcours client pour le parcours de l'utilisateur de l'API, de la découverte et de l'évaluation à l'intégration, au dépannage et à l'utilisation continue.",
-  "station.api-consumer-experience.how_it_works.2": "Utilisez le parcours ainsi obtenu pour améliorer l'intégration, la documentation, l'assistance et les boucles de rétroaction pour l'utilisateur de l'API.",
-  "station.api-consumer-experience.apply_in_work": "Fournir des lignes directrices, des outils et des mécanismes de retour d'information pour comprendre, analyser et améliorer l'expérience interne et externe des développeurs et des partenaires.",
-  "station.api-consumer-experience.outcomes": "Identifier et hiérarchiser les consommateurs d'API",
-  "station.api-platform-architecture.title": "Architecture de la plateforme API - Architecturer les API pour l'évolutivité et la réutilisation",
-  "station.api-platform-architecture.description": "Assurez l'évolutivité, la réutilisation et la gouvernance de vos composants d'API et de plateforme.",
-  "station.api-platform-architecture.why_it_matters": "Lorsque les API s'étendent à plusieurs équipes, votre plateforme doit permettre la gouvernance et la réutilisation sans bloquer la vitesse. Cette station montre comment architecturer les API pour assurer leur longévité, leur sécurité et leur efficacité.",
-  "station.api-platform-architecture.apply_in_work": "Mettre en place une infrastructure évolutive, sécurisée et conforme pour les opérations API. Fournir des lignes directrices sur les meilleures pratiques en matière d'architecture.",
-  "station.api-platform-architecture.outcomes": "Supprimer les API redondantes et réduire les coûts de la plateforme en nuage",
-  "station.api-platform-architecture.how_it_works": "Le Business Impact Canvas permet d'identifier et d'atténuer les risques liés à la disponibilité, à la sécurité et à la fonctionnalité de l'API afin de prendre des décisions éclairées en matière d'architecture.",
-  "station.api-design.title": "Conception d'API - Concevoir des API qui apportent de la valeur",
-  "station.api-design.description": "Créer des architectures d'API cohérentes, réutilisables et fondées sur les objectifs métier et des normes communes.",
-  "station.api-design.why_it_matters": "La conception d'API ne se limite pas à nommer des points de terminaison. Une bonne conception garantit que les API sont utilisables, cohérentes et alignées sur les objectifs métier et techniques. Une mauvaise conception entraîne un couplage étroit, une faible réutilisation et des retouches coûteuses entre les équipes.",
-  "station.api-design.apply_in_work": "Fournir des modèles de conception réutilisables, des normes communes et des outils de validation pour les spécifications d'API. S'assurer que les décisions de conception sont cohérentes, examinées dès le début et alignées sur les objectifs métier.",
-  "station.api-design.outcomes": "Des conceptions d'API bien documentées et cohérentes",
-  "station.api-design.how_it_works": "Définir les entités de base, leurs attributs et leurs relations afin de créer une compréhension conceptuelle partagée entre les API.",
-  "station.api-delivery.title": "Livraison d'API - Fournir des API sécurisées et fiables",
-  "station.api-delivery.description": "Construire, tester et publier des API en utilisant des pipelines de livraison modernes et les meilleures pratiques d'ingénierie.",
-  "station.api-delivery.why_it_matters": "Même les meilleures conceptions d'API échouent si la livraison est incohérente. Cette station garantit que vos API sont construites avec qualité, testées de manière approfondie et déployées de manière fiable, ce qui permet des itérations plus rapides et une plus grande confiance.",
-  "station.api-delivery.apply_in_work": "Fournir des cadres de codage, des bibliothèques et des normes pour la mise en œuvre des API. Mettre en œuvre des pipelines CI/CD, des cadres d'assurance qualité et des outils d'automatisation du déploiement.",
-  "station.api-delivery.outcomes": "API mises en œuvre à l'aide de cadres et de modèles testés",
-"station.api-delivery.how_it_works": "Utilisez les meilleures pratiques de développement d'API comme guide pour mettre en œuvre le contrat validé à l'aide de frameworks et de bibliothèques établis, en veillant à ce que le résultat soit réutilisable et maintenable.",
-  "station.api-audit.title": "Audit API - Audit de conformité et de qualité des API",
-  "station.api-audit.description": "Vérifiez que les API répondent aux normes métier, de conception et opérationnelles avant leur publication et leur mise à disposition.",
-  "station.api-audit.why_it_matters": "Les API sont des produits à longue durée de vie et doivent répondre aux attentes en matière de qualité, de cohérence et de conformité. L'audit relie les décisions de conception, la mise en œuvre et l'état de préparation opérationnelle à des normes définies, réduisant ainsi les risques avant la mise à disposition.",
-  "station.api-audit.apply_in_work": "Mettez en place un processus d'audit cohérent qui évalue l'état de préparation des API à toutes les étapes du cycle de vie à l'aide de critères, de preuves et de normes définis. Assurez-vous que les lacunes sont identifiées tôt et résolues avant la publication.",
-  "station.api-audit.outcomes": "Les API sont conformes aux normes internes et externes",
-  "station.api-audit.how_it_works": "Mener des audits pour s'assurer que les API respectent les normes organisationnelles, techniques et juridiques avant d'être publiées.",
-  "station.api-publishing.title": "Publication d'API - Publier des API en toute confiance",
-  "station.api-publishing.description": "Exposer les API de manière sûre et claire au bon public avec la bonne documentation et les bons processus.",
-  "station.api-publishing.why_it_matters": "La publication va plus loin que le déploiement - il s'agit de la découvrabilité, de l'accès et de l'assistance. Si les API ne sont pas publiées correctement, elles ne seront pas utilisées, réutilisées ou sécurisées efficacement.",
-  "station.api-publishing.apply_in_work": "Permettre aux API d'être publiées dans l'environnement approprié et disposer de mécanismes d'enregistrement et d'accès clairs (par exemple, clés API, OAuth, plans d'abonnement) en fonction des segments de consommateurs d'API et des exigences en matière de sécurité et de conformité.",
-  "station.api-publishing.outcomes": "API publiées dans le bon environnement (privé, partenaire, public)",
-  "station.api-publishing.how_it_works": "Publier les API dans les passerelles et les environnements appropriés afin de favoriser la réutilisation pour de multiples consommateurs d'API.",
-  "station.monitoring-and-improving.title": "Suivi et amélioration - pour la valeur de l'API",
-  "station.monitoring-and-improving.description": "Utiliser les mesures et le retour d'information pour suivre les performances de l'API et favoriser l'amélioration continue.",
-  "station.monitoring-and-improving.why_it_matters": "La livraison d'API ne s'arrête pas au lancement. Sans surveillance, les équipes ne peuvent pas améliorer l'adoption, les performances ou le retour sur investissement. Cette station garantit que les API restent utiles, sécurisées et qu'elles évoluent avec les besoins de l'entreprise.",
-  "station.monitoring-and-improving.apply_in_work": "Mettre en place des cadres d'analyse pour suivre les performances et l'engagement. Développer des boucles de rétroaction, des outils d'analyse et des stratégies d'engagement pour les API.",
-  "station.monitoring-and-improving.outcomes": "Définition et suivi des indicateurs de performance et d'utilisation",
-  "station.monitoring-and-improving.how_it_works": "Contrôler les indicateurs de performance (par exemple, les appels à l'API, la latence, les taux d'erreur) et les indicateurs d'adoption (par exemple, NPS).",
+  "group.core-stations.title": "Stations centrales du cycle de vie des capacités",
+  "group.core-stations.description": "Les stations centrales du graphe de méthode APIOps Cycles, où les équipes apprennent à concevoir, fournir, gouverner et améliorer des capacités réutilisables via des API, événements, fichiers, flux, produits de données et autres modes d'intégration.",
+  "group.sub-stations.title": "Stations de soutien",
+  "group.sub-stations.description": "Stations de soutien qui fournissent des pratiques, points de décision et ressources réutilisables dans différents parcours APIOps Cycles.",
+  "station.api-product-strategy.title": "Stratégie de capacité",
+  "station.api-product-strategy.description": "Décrivez le besoin métier comme une capacité réutilisable avant de choisir le mode de mise en œuvre.",
+  "station.api-product-strategy.why_it_matters": "Les initiatives d'intégration et d'API passent souvent trop vite à un choix technique. Cette station maintient l'équipe concentrée sur le parcours métier, le domaine, la valeur, le potentiel de réutilisation, la responsabilité et la faisabilité avant de choisir API, événements, fichiers, flux, produits de données ou intégration directe.",
+  "station.api-product-strategy.apply_in_work": "Utilisez des canvases de parcours, de domaine, de proposition de valeur et de modèle métier pour capturer les exigences indépendamment de la technologie et décider si la capacité doit être réutilisable.",
+  "station.api-product-strategy.outcomes": "Une opportunité de capacité indépendante de la technologie",
+  "station.api-product-strategy.how_it_works": "Analysez le parcours client ou partenaire d'où émerge le besoin de capacité, puis identifiez les tâches, irritants, gains, entrées, sorties et points de décision.",
+  "station.api-consumer-experience.title": "Exigences utilisateurs & onboarding",
+  "station.api-consumer-experience.description": "Capturez les exigences des utilisateurs, l'onboarding, les standards, les exigences non fonctionnelles, les attentes de service, les contraintes, la sécurité, les protocoles, la fraîcheur des données, les SLA, l'observabilité, la reprise, l'adoption et les responsabilités des fournisseurs.",
+  "station.api-consumer-experience.why_it_matters": "La bonne architecture dépend des objectifs des utilisateurs, des attentes d'onboarding, des niveaux de service, de la qualité des données, de la tolérance au changement, de l'observabilité, du support et des contraintes du fournisseur.",
+  "station.api-consumer-experience.how_it_works": "Utilisez le Consumer Experience Requirements Canvas pour documenter objectifs utilisateurs, disponibilité, fraîcheur, volumes, performance, qualité des données, sécurité, onboarding, changements, observabilité et attentes de reprise.",
+  "station.api-consumer-experience.how_it_works.1": "Utilisez le canevas du parcours client pour le parcours de l'utilisateur, de la découverte et de l'évaluation à l'intégration, au dépannage et à l'utilisation continue.",
+  "station.api-consumer-experience.how_it_works.2": "Utilisez le parcours ainsi obtenu pour améliorer l'intégration, la documentation, l'assistance et les boucles de rétroaction pour l'utilisateur.",
+  "station.api-consumer-experience.apply_in_work": "Utilisez les ressources d'expérience utilisateur et d'onboarding pour rendre explicites les attentes des utilisateurs et des fournisseurs.",
+  "station.api-consumer-experience.outcomes": "Exigences utilisateurs et attentes d'onboarding explicites",
+  "station.api-platform-architecture.title": "Architecture & décisions de plateforme",
+  "station.api-platform-architecture.description": "Utilisez les exigences et contraintes pour choisir l'architecture, les capacités de plateforme, la gouvernance et le modèle opérationnel.",
+  "station.api-platform-architecture.why_it_matters": "Une capacité réutilisable nécessite des décisions d'architecture alignées sur les exigences utilisateurs, la sécurité, les flux de données, le modèle opérationnel et la réalité des plateformes existantes.",
+  "station.api-platform-architecture.apply_in_work": "Utilisez les ressources d'architecture et de plateforme pour comparer les options de mise en œuvre viables et prendre une décision traçable.",
+  "station.api-platform-architecture.outcomes": "Décision d'architecture et de plateforme validée",
+  "station.api-platform-architecture.how_it_works": "Utilisez les ressources Business Impact, Capacity, Security et Architecture Decision pour évaluer systématiquement les risques, contraintes et alternatives.",
+  "station.api-design.title": "Conception de solution & d'interface",
+  "station.api-design.description": "Concevez le mode de mise en œuvre choisi, le contrat d'interface, les modèles d'interaction, les structures de données et les détails d'utilisation avant l'implémentation.",
+  "station.api-design.why_it_matters": "Une bonne conception va au-delà du nommage des endpoints. Elle garantit que l'interface est utilisable, cohérente, vérifiable et traçable aux besoins métier et utilisateurs.",
+  "station.api-design.apply_in_work": "Utilisez les ressources de conception adaptées au mode de mise en œuvre choisi, par exemple REST, GraphQL, événements, fichiers, produits de données ou intégration directe.",
+  "station.api-design.outcomes": "Un contrat d'interface validé pour le mode de mise en œuvre choisi",
+  "station.api-design.how_it_works": "Clarifiez les objets métier, les termes, les règles et les responsabilités avant de concevoir le contrat d'interface.",
+  "station.api-delivery.title": "Mise à disposition & opérations",
+  "station.api-delivery.description": "Mettez en œuvre le mode choisi avec des pratiques adaptées d'ingénierie, de test, de sécurité, d'automatisation et d'exploitation.",
+  "station.api-delivery.why_it_matters": "Une capacité réutilisable a besoin d'une mise à disposition et d'un fonctionnement fiables, qu'elle soit réalisée sous forme d'API, de flux d'événements, d'échange de fichiers, de produit de données ou d'intégration directe.",
+  "station.api-delivery.apply_in_work": "Appliquez les pratiques de mise en œuvre, de test, de CI/CD, d'exploitation et de sécurité au mode de mise en œuvre choisi.",
+  "station.api-delivery.outcomes": "Une capacité livrée conformément au contrat d'interface validé",
+  "station.api-delivery.how_it_works": "Utilisez les pratiques de développement pour implémenter le contrat d'interface validé avec les frameworks, bibliothèques et standards d'équipe établis.",
+  "station.api-audit.title": "Assurance qualité & préparation",
+  "station.api-audit.description": "Vérifiez le contrat d'interface, les contrôles, le modèle de support, l'observabilité, la documentation et la préparation du cycle de vie avant publication.",
+  "station.api-audit.why_it_matters": "Les capacités réutilisables créent des risques opérationnels, liés aux données, à la sécurité, à la confidentialité, à la conformité et à l'expérience utilisateur. Les revues de préparation réduisent les surprises avant la publication ou l'utilisation en production.",
+  "station.api-audit.apply_in_work": "Utilisez les ressources d'audit et de conformité pour vérifier que la capacité peut être publiée et réutilisée de manière contrôlée.",
+  "station.api-audit.outcomes": "Préparation documentée pour la publication et la réutilisation",
+  "station.api-audit.how_it_works": "Utilisez des checklists, linters, tests et revues pour vérifier cohérence, standards, sécurité, performance et conformité.",
+  "station.api-publishing.title": "Publication & enablement",
+  "station.api-publishing.description": "Publiez les informations de capacité afin que les utilisateurs puissent la trouver, l'évaluer, demander l'accès, s'onboarder, l'utiliser et obtenir du support.",
+  "station.api-publishing.why_it_matters": "Une capacité réutilisable ne crée de la valeur que si les utilisateurs peuvent la trouver, comprendre le contrat d'interface et les attentes de service, demander l'accès et connaître le support ainsi que la responsabilité du cycle de vie.",
+  "station.api-publishing.apply_in_work": "Publiez la responsabilité, la documentation, l'onboarding, les contacts support, les attentes de service, le statut de cycle de vie et les chemins d'accès.",
+  "station.api-publishing.outcomes": "Une capacité découvrable et utilisable",
+  "station.api-publishing.how_it_works": "Publiez les informations de capacité dans les catalogues, portails, passerelles ou environnements appropriés afin que plusieurs utilisateurs puissent la réutiliser.",
+  "station.monitoring-and-improving.title": "Suivi & amélioration",
+  "station.monitoring-and-improving.description": "Suivez l'utilisation, la fiabilité, la qualité des données, les résultats utilisateurs, les coûts opérationnels et les opportunités de réutilisation après publication.",
+  "station.monitoring-and-improving.why_it_matters": "Les capacités ont besoin de retours continus pour rester fiables, utiles, économiquement pertinentes et réutilisables lorsque les utilisateurs, systèmes, données et plateformes évoluent.",
+  "station.monitoring-and-improving.apply_in_work": "Utilisez des métriques, analyses et pratiques de feedback pour améliorer continuellement la capacité.",
+  "station.monitoring-and-improving.outcomes": "Santé et contribution de valeur de la capacité mesurées",
+  "station.monitoring-and-improving.how_it_works": "Définissez des métriques d'utilisation, fiabilité, qualité des données, coût, adoption et valeur utilisateur.",
   "station.user-experience.title": "Expérience utilisateur - Concevoir des API en pensant à l'utilisateur",
   "station.user-experience.description": "Veiller à ce que les API soient conçues en pensant à l'utilisateur final, en lui offrant une expérience transparente et intuitive.",
-  "station.user-experience.why_it_matters": "Les API ne sont pas seulement des produits techniques, ce sont des produits orientés vers l'utilisateur. Une mauvaise expérience utilisateur peut entraîner une faible adoption et de la frustration. Cette station aide les équipes à concevoir des API conviviales et répondant aux besoins des consommateurs.",
+  "station.user-experience.why_it_matters": "Les API ne sont pas seulement des produits techniques, ce sont des produits orientés vers l'utilisateur. Une mauvaise expérience utilisateur peut entraîner une faible adoption et de la frustration. Cette station aide les équipes à concevoir des API conviviales et répondant aux besoins des utilisateurs.",
   "station.user-experience.apply_in_work": "Fournir des lignes directrices, des modèles et des outils en matière d'expérience utilisateur pour la conception d'API. Veiller à ce que les équipes suivent des pratiques de conception centrées sur l'utilisateur et intègrent les commentaires des utilisateurs dans les itérations de l'API.",
   "station.user-experience.outcomes": "Des API conçues en fonction des besoins des utilisateurs",
   "station.user-experience.how_it_works": "Utiliser des profils d'utilisateurs pour comprendre les besoins et les attentes des utilisateurs finaux.",
@@ -68,7 +68,7 @@
   "station.business-goals.title": "Objectifs de l'entreprise - Aligner les API sur les objectifs de l'entreprise",
   "station.business-goals.description": "Veiller à ce que les API soient alignées sur les objectifs de l'entreprise et contribuent aux objectifs généraux de l'organisation.",
   "station.business-goals.why_it_matters": "Les API ne doivent pas être conçues de manière isolée ; elles doivent soutenir et stimuler les objectifs de l'entreprise. Cette station aide les équipes à aligner leurs API sur les objectifs stratégiques, en veillant à ce qu'elles apportent une réelle valeur ajoutée à l'entreprise.",
-  "station.business-goals.apply_in_work": "Fournir des cadres, des modèles et des outils d'alignement commercial pour définir la valeur commerciale des API. Veiller à ce que les équipes examinent et alignent régulièrement les API sur l'évolution des objectifs de l'entreprise.",
+  "station.business-goals.apply_in_work": "Fournir des cadres, des modèles et des outils d'alignement commercial pour définir la valeur métier des API. Veiller à ce que les équipes examinent et alignent régulièrement les API sur l'évolution des objectifs de l'entreprise.",
   "station.business-goals.outcomes": "Des API alignées sur les objectifs de l'entreprise",
   "station.business-goals.how_it_works": "Définissez les objectifs de l'entreprise et la manière dont les API peuvent les soutenir en utilisant **le Business Model Canvas**. Si votre activité consiste à fournir des API, passez par *la station API Product Strategy* et remplissez **l'API Business Model Canvas**.",
   "station.competitive-analysis.title": "Analyse concurrentielle - Garder une longueur d'avance sur le marché des API",
@@ -109,20 +109,20 @@
   "station.design-standards.how_it_works": "Définir des normes et des lignes directrices pour la conception des API, y compris les conventions de dénomination, les formats de réponse et la gestion des erreurs.",
   "station.vendor-management.title": "Gestion des fournisseurs - Gestion des intégrations d'API de tiers",
   "station.vendor-management.description": "Gérer efficacement les fournisseurs d'API tiers et les intégrations pour garantir la fiabilité et la conformité.",
-  "station.vendor-management.why_it_matters": "Les API tierces peuvent présenter des risques et des dépendances qui ont un impact sur votre écosystème d'API. Ce poste fournit des lignes directrices pour gérer les relations avec les fournisseurs, garantir la fiabilité, la conformité et l'alignement sur votre stratégie d'API.",
+  "station.vendor-management.why_it_matters": "Les API tierces peuvent présenter des risques et des dépendances qui ont un impact sur votre écosystème d'API. Ce station fournit des lignes directrices pour gérer les relations avec les fournisseurs, garantir la fiabilité, la conformité et l'alignement sur votre stratégie d'API.",
   "station.vendor-management.apply_in_work": "Fournir des cadres de gestion des fournisseurs, des critères d'évaluation et des outils de suivi. Veiller à ce que les équipes gèrent efficacement les fournisseurs d'API tiers, en garantissant la fiabilité, la conformité et l'alignement sur les normes de l'organisation.",
   "station.vendor-management.outcomes": "Mise en place de processus efficaces de gestion des fournisseurs",
   "station.vendor-management.how_it_works": "Mettre en place des processus de gestion des fournisseurs afin d'évaluer, d'intégrer et de contrôler les fournisseurs d'API tiers.",
   "station.contract-design.title": "Conception des contrats - Définir des contrats API clairs",
-  "station.contract-design.description": "Créer des contrats d'API clairs et bien définis qui décrivent les attentes, les responsabilités et les directives d'utilisation.",
-  "station.contract-design.why_it_matters": "Les contrats d'API sont essentiels pour garantir la clarté et l'alignement entre les fournisseurs d'API et les consommateurs. Cette station fournit des lignes directrices pour la conception de contrats d'API clairs, complets et faciles à comprendre.",
-  "station.contract-design.apply_in_work": "Fournir des modèles de conception de contrats, des formats normalisés et des processus d'examen. Veiller à ce que les équipes créent des contrats d'API clairs et bien définis qui décrivent les attentes, les responsabilités et les directives d'utilisation.",
-  "station.contract-design.outcomes": "Contrats d'API clairs définis pour chaque API",
-  "station.contract-design.how_it_works": "Définir des contrats d'API qui décrivent les attentes, les responsabilités et les directives d'utilisation pour chaque API.",
+  "station.contract-design.description": "Créer des contrats d'interface clairs et bien définis qui décrivent les attentes, les responsabilités et les directives d'utilisation.",
+  "station.contract-design.why_it_matters": "Les contrats d'interface sont essentiels pour garantir la clarté et l'alignement entre les fournisseurs d'API et les utilisateurs. Cette station fournit des lignes directrices pour la conception de contrats d'interface clairs, complets et faciles à comprendre.",
+  "station.contract-design.apply_in_work": "Fournir des modèles de conception de contrats, des formats normalisés et des processus d'examen. Veiller à ce que les équipes créent des contrats d'interface clairs et bien définis qui décrivent les attentes, les responsabilités et les directives d'utilisation.",
+  "station.contract-design.outcomes": "Contrats d'interface clairs définis pour chaque API",
+  "station.contract-design.how_it_works": "Définir des contrats d'interface qui décrivent les attentes, les responsabilités et les directives d'utilisation pour chaque API.",
   "station.development.title": "Développement - Construire des API avec les meilleures pratiques",
   "station.development.description": "Mettre en œuvre des API en utilisant les meilleures pratiques et les meilleurs cadres afin de garantir la qualité, la maintenabilité et l'évolutivité.",
   "station.development.why_it_matters": "Le développement de l'API est une phase critique qui détermine la qualité et la fiabilité de l'API. Cette station fournit les meilleures pratiques et les cadres pour le développement d'API, garantissant que les API sont construites selon des normes élevées et qu'elles peuvent être maintenues et mises à l'échelle efficacement.",
-  "station.development.apply_in_work": "Fournir des cadres de développement, des bibliothèques et des normes de codage pour la mise en œuvre de l'API. Veiller à ce que les équipes suivent les meilleures pratiques et effectuent des révisions de code afin de maintenir un développement d'API de haute qualité.",
+  "station.development.apply_in_work": "Fournir des frameworks de développement, des bibliothèques et des normes de codage pour la mise en œuvre de l'API. Veiller à ce que les équipes suivent les meilleures pratiques et effectuent des révisions de code afin de maintenir un développement d'API de haute qualité.",
   "station.development.outcomes": "API développées à l'aide des meilleures pratiques et des meilleurs cadres",
   "station.development.how_it_works": "Utiliser des cadres et des bibliothèques établis pour mettre en œuvre les API, en veillant à ce qu'elles soient réutilisables et faciles à entretenir.",
   "station.ci-cd.title": "CI/CD - Automatiser la livraison des API",
@@ -144,17 +144,17 @@
   "station.release-management.outcomes": "Des versions contrôlées et fluides de l'API",
   "station.release-management.how_it_works": "Définir des stratégies de versionnement pour les API afin de gérer les changements et d'assurer la compatibilité ascendante.",
   "station.service-agreements.title": "Accords de service - Définir les niveaux de service de l'API",
-  "station.service-agreements.description": "Établir des accords de service qui définissent les attentes, les niveaux de service et les responsabilités des fournisseurs et des consommateurs d'API.",
-  "station.service-agreements.why_it_matters": "Les accords de service sont essentiels pour garantir la clarté et l'alignement entre les fournisseurs d'API et les consommateurs. Cette station fournit des lignes directrices pour la création d'accords de service qui décrivent les attentes, les niveaux de service et les responsabilités, réduisant ainsi les malentendus et les litiges.",
-  "station.service-agreements.apply_in_work": "Fournir des modèles d'accords de service, des formats normalisés et des processus d'examen. Veiller à ce que les équipes créent des accords de service clairs et bien définis qui décrivent les attentes, les niveaux de service et les responsabilités des fournisseurs d'API et des consommateurs.",
+  "station.service-agreements.description": "Établir des accords de service qui définissent les attentes, les niveaux de service et les responsabilités des fournisseurs et des utilisateurs.",
+  "station.service-agreements.why_it_matters": "Les accords de service sont essentiels pour garantir la clarté et l'alignement entre les fournisseurs d'API et les utilisateurs. Cette station fournit des lignes directrices pour la création d'accords de service qui décrivent les attentes, les niveaux de service et les responsabilités, réduisant ainsi les malentendus et les litiges.",
+  "station.service-agreements.apply_in_work": "Fournir des modèles d'accords de service, des formats normalisés et des processus d'examen. Veiller à ce que les équipes créent des accords de service clairs et bien définis qui décrivent les attentes, les niveaux de service et les responsabilités des fournisseurs d'API et des utilisateurs.",
   "station.service-agreements.outcomes": "Des accords de service clairs définis pour chaque API",
   "station.service-agreements.how_it_works": "Définir des accords de service qui décrivent les attentes, les niveaux de service et les responsabilités pour chaque API.",
-  "station.api-consumer-adoption.title": "Adoption de l'API par les consommateurs - Favoriser l'utilisation de l'API",
+  "station.api-consumer-adoption.title": "Adoption de l'API par les utilisateurs - Favoriser l'utilisation de l'API",
   "station.api-consumer-adoption.description": "Mettre en œuvre des stratégies visant à favoriser l'adoption et l'engagement des utilisateurs d'API, en veillant à ce que les API soient utilisées efficacement.",
-  "station.api-consumer-adoption.why_it_matters": "Il est essentiel de favoriser l'adoption par les consommateurs d'API pour réaliser la valeur des API. Cette station fournit des stratégies et des meilleures pratiques pour engager les consommateurs d'API, en s'assurant qu'ils comprennent comment utiliser efficacement les API et en tirer de la valeur.",
-  "station.api-consumer-adoption.apply_in_work": "Fournir des ressources d'accueil, du matériel pédagogique et des stratégies d'engagement pour les consommateurs d'API. Veiller à ce que les équipes mettent en œuvre des stratégies qui favorisent l'adoption, l'engagement et la satisfaction des consommateurs d'API.",
-  "station.api-consumer-adoption.outcomes": "Mise en œuvre de stratégies d'adoption de l'API par les consommateurs",
-  "station.api-consumer-adoption.how_it_works": "Développer des processus et des ressources d'intégration pour aider les consommateurs d'API à comprendre comment utiliser efficacement les API.",
+  "station.api-consumer-adoption.why_it_matters": "Il est essentiel de favoriser l'adoption par les utilisateurs pour réaliser la valeur des API. Cette station fournit des stratégies et des meilleures pratiques pour engager les utilisateurs, en s'assurant qu'ils comprennent comment utiliser efficacement les API et en tirer de la valeur.",
+  "station.api-consumer-adoption.apply_in_work": "Fournir des ressources d'accueil, du matériel pédagogique et des stratégies d'engagement pour les utilisateurs. Veiller à ce que les équipes mettent en œuvre des stratégies qui favorisent l'adoption, l'engagement et la satisfaction des utilisateurs.",
+  "station.api-consumer-adoption.outcomes": "Mise en œuvre de stratégies d'adoption de l'API par les utilisateurs",
+  "station.api-consumer-adoption.how_it_works": "Développer des processus et des ressources d'intégration pour aider les utilisateurs à comprendre comment utiliser efficacement les API.",
   "station.api-promotion.title": "Promotion de l'API - Augmenter la visibilité et l'utilisation de l'API",
   "station.api-promotion.description": "Promouvoir les API afin d'accroître la visibilité, l'utilisation et l'adoption parmi les publics cibles.",
   "station.api-promotion.why_it_matters": "La promotion des API est essentielle pour accroître leur visibilité et favoriser leur utilisation. Cette station propose des stratégies et des bonnes pratiques pour promouvoir efficacement les API auprès des publics cibles, en veillant à ce qu'ils connaissent les API et comprennent leur valeur.",
@@ -172,11 +172,11 @@
   "station.api-mindset.why_it_matters": "Un état d'esprit axé sur les API est essentiel pour favoriser l'innovation et la collaboration au sein de l'entreprise. Cette station fournit des stratégies pour cultiver une culture API-first, en veillant à ce que les API soient considérées comme des actifs stratégiques qui génèrent de la valeur pour l'entreprise.",
   "station.api-mindset.apply_in_work": "Fournir des programmes de formation, des ressources et des stratégies de communication pour favoriser une culture de l'API. S'assurer que les équipes comprennent la valeur des API et sont habilitées à conduire la stratégie et les initiatives en matière d'API.",
   "station.api-mindset.outcomes": "Culture de la priorité aux API établie dans l'ensemble de l'organisation",
-  "station.api-mindset.how_it_works": "Promouvoir la valeur des API en tant qu'actifs stratégiques qui génèrent de la valeur commerciale et de l'innovation.",
+  "station.api-mindset.how_it_works": "Promouvoir la valeur des API en tant qu'actifs stratégiques qui génèrent de la valeur métier et de l'innovation.",
   "station.roles-and-responsibilities.title": "Rôles et responsabilités - Définir les structures de l'équipe API",
   "station.roles-and-responsibilities.description": "Définir clairement les rôles et les responsabilités des équipes chargées de l'API afin de garantir une collaboration et une responsabilisation efficaces.",
   "station.roles-and-responsibilities.why_it_matters": "Des rôles et des responsabilités clairs sont essentiels pour une collaboration et une responsabilisation efficaces au sein des équipes de l'API. Cette station fournit des lignes directrices pour définir les structures, les rôles et les responsabilités des équipes, en veillant à ce que chacun comprenne sa contribution aux initiatives de l'API.",
-  "station.roles-and-responsibilities.apply_in_work": "Fournir des lignes directrices sur la structure des équipes, des définitions des rôles et des stratégies de communication. Veiller à ce que les équipes aient des rôles et des responsabilités clairs qui favorisent une collaboration et une responsabilisation efficaces dans le cadre des initiatives de l'IPA.",
+  "station.roles-and-responsibilities.apply_in_work": "Fournir des lignes directrices sur la structure des équipes, des définitions des rôles et des stratégies de communication. Veiller à ce que les équipes aient des rôles et des responsabilités clairs qui favorisent une collaboration et une responsabilisation efficaces dans le cadre des initiatives de l'API.",
   "station.roles-and-responsibilities.outcomes": "Rôles et responsabilités clairement définis pour les équipes API",
   "station.roles-and-responsibilities.how_it_works": "Définir les structures et les rôles des équipes API, y compris les propriétaires de produits API, les développeurs, les architectes et les opérations.",
   "station.upskilling.title": "Upkilling - Améliorer les compétences et les connaissances en matière d'API",
@@ -193,38 +193,38 @@
   "station.operating-guidelines.how_it_works": "Définir des lignes directrices opérationnelles basées sur les cycles APIOps qui décrivent les processus, les normes et les meilleures pratiques pour la gestion de l'API.",
   "station.portfolio-management.title": "Gestion de portefeuille - Gérer efficacement le portefeuille d'API",
   "station.portfolio-management.description": "Gérer efficacement le portefeuille d'API afin de garantir l'alignement sur les objectifs de l'entreprise et les initiatives stratégiques.",
-  "station.portfolio-management.why_it_matters": "Une gestion efficace du portefeuille d'API est essentielle pour garantir que les API s'alignent sur les objectifs de l'entreprise et les initiatives stratégiques. Ce poste fournit des lignes directrices pour la gestion du portefeuille d'API, en veillant à ce que les API soient classées par ordre de priorité, contrôlées et optimisées pour offrir une valeur maximale.",
+  "station.portfolio-management.why_it_matters": "Une gestion efficace du portefeuille d'API est essentielle pour garantir que les API s'alignent sur les objectifs de l'entreprise et les initiatives stratégiques. Ce station fournit des lignes directrices pour la gestion du portefeuille d'API, en veillant à ce que les API soient classées par ordre de priorité, contrôlées et optimisées pour offrir une valeur maximale.",
   "station.portfolio-management.apply_in_work": "Fournir des cadres de gestion de portefeuille, des critères de priorisation et des outils de suivi pour la gestion des API. Veiller à ce que les équipes gèrent efficacement le portefeuille d'API, en assurant l'alignement sur les objectifs de l'entreprise, les initiatives stratégiques et la fourniture d'une valeur maximale.",
   "station.portfolio-management.outcomes": "Mise en place de pratiques de gestion du portefeuille API",
   "station.portfolio-management.how_it_works": "Définir des pratiques de gestion de portefeuille qui décrivent les processus de gestion du portefeuille d'API, y compris l'établissement de priorités, le suivi et l'optimisation.",
   "station.budget-and-resource-management.title": "Gestion du budget et des ressources - Optimiser les investissements dans l'API",
   "station.budget-and-resource-management.description": "Optimiser la gestion du budget et des ressources pour les initiatives API afin de garantir l'efficacité des investissements et de l'affectation des ressources.",
-  "station.budget-and-resource-management.why_it_matters": "Une gestion efficace du budget et des ressources est essentielle pour garantir que les initiatives en matière d'API sont bien financées et disposent des ressources nécessaires. Ce poste fournit des lignes directrices pour optimiser la gestion du budget et des ressources, en veillant à ce que les initiatives en matière d'API soient alignées sur les objectifs de l'entreprise et apportent une valeur maximale.",
+  "station.budget-and-resource-management.why_it_matters": "Une gestion efficace du budget et des ressources est essentielle pour garantir que les initiatives en matière d'API sont bien financées et disposent des ressources nécessaires. Ce station fournit des lignes directrices pour optimiser la gestion du budget et des ressources, en veillant à ce que les initiatives en matière d'API soient alignées sur les objectifs de l'entreprise et apportent une valeur maximale.",
   "station.budget-and-resource-management.apply_in_work": "Fournir des cadres de gestion budgétaire, des critères de priorisation et des outils de suivi pour les initiatives API. Veiller à ce que les équipes gèrent efficacement les budgets et les ressources, en optimisant les investissements dans le développement et la gestion des API afin d'obtenir une valeur maximale.",
   "station.budget-and-resource-management.outcomes": "Pratiques de gestion du budget et des ressources établies pour les initiatives de l'API",
   "station.budget-and-resource-management.how_it_works": "Définir des pratiques de gestion du budget et des ressources qui décrivent les processus de gestion des budgets et des ressources pour les initiatives de l'API.",
   "station.api-product-strategy.outcomes.1": "Un langage commun entre le produit, le design et la technologie",
   "station.api-product-strategy.outcomes.2": "Un argumentaire ou un dossier solide pour le financement/l'approbation",
   "station.api-product-strategy.how_it_works.1": "Définir les entités de base, leurs attributs et leurs relations pour créer une compréhension conceptuelle partagée à travers les parcours et éventuellement les API.",
-  "station.api-product-strategy.how_it_works.2":"Utilisez le canevas de proposition de valeur de l'API pour recenser les tâches métier prises en charge ainsi que les difficultés, les avantages et les fonctionnalités pour l'utilisateur de l'API qui façonnent les API nouvelles ou réutilisables.",
-  "station.api-product-strategy.how_it_works.3": "Définissez la valeur - pour les utilisateurs et l'entreprise - à l'aide du modèle commercial de l'API, afin de rendre votre stratégie API visuelle, partageable et facile à valider avec vos consommateurs d'API à la prochaine station.",
+  "station.api-product-strategy.how_it_works.2": "Utilisez le canevas de proposition de valeur de l'API pour recenser les tâches métier prises en charge ainsi que les difficultés, les avantages et les fonctionnalités pour l'utilisateur qui façonnent les API nouvelles ou réutilisables.",
+  "station.api-product-strategy.how_it_works.3": "Définissez la valeur - pour les utilisateurs et l'entreprise - à l'aide du modèle commercial de l'API, afin de rendre votre stratégie API visuelle, partageable et facile à valider avec vos utilisateurs à la prochaine station.",
   "station.api-consumer-experience.outcomes.1": "Définir le parcours de l'expérience API",
   "station.api-consumer-experience.outcomes.2": "Planifier l'intégration, la documentation et le retour d'information",
   "station.api-consumer-experience.outcomes.3": "Améliorer l'adoption grâce à une véritable empathie + l'expérience du développeur (DX)",
   "station.api-platform-architecture.outcomes.1": "Mettre en œuvre une gouvernance cohérente sans contrôle descendant lourd",
   "station.api-platform-architecture.outcomes.2": "Conception en vue d'une réutilisation interne et d'une évolutivité externe",
-  "station.api-platform-architecture.how_it_works.1": "Cartographier les emplacements réglementaires, de conformité et de réseau des fournisseurs d'API et des consommateurs afin de garantir l'accessibilité et la conformité.",
+  "station.api-platform-architecture.how_it_works.1": "Cartographier les emplacements réglementaires, de conformité et de réseau des fournisseurs d'API et des utilisateurs afin de garantir l'accessibilité et la conformité.",
   "station.api-platform-architecture.how_it_works.2": "Le Capacity Canvas aligne les modèles de transactions commerciales, les tendances de consommation futures et les solutions techniques pour garantir l'évolutivité et les performances de l'API, et fournit des informations essentielles pour les décisions d'évolution et la planification de l'infrastructure.",
   "station.api-platform-architecture.how_it_works.3": "Définir et surveiller les indicateurs de performance (par exemple, les appels API, la latence, les taux d'erreur) et les indicateurs d'adoption (par exemple, NPS).",
-  "station.api-design.outcomes.1": "Contrats d'API réutilisables et validés",
+  "station.api-design.outcomes.1": "Contrats d'interface réutilisables et validés",
   "station.api-design.outcomes.2": "Conceptions alignées sur les modèles de domaine et les modèles d'interaction",
-  "station.api-design.outcomes.3": "Traçabilité de la conception à la valeur commerciale",
-  "station.api-design.how_it_works.1": "Utilisez le canevas d'interaction pour définir la manière dont les consommateurs interagiront avec l'API, en veillant à ce qu'elle réponde à leurs besoins et à leurs attentes.",
-  "station.api-design.how_it_works.2": "Appliquer les modèles de conception REST pour créer des contrats d'API cohérents et réutilisables qui sont validés avec les parties prenantes.",
-  "station.api-design.how_it_works.3": "Appliquer des modèles de conception orientés événements pour créer des contrats d'API cohérents et réutilisables qui sont validés avec les parties prenantes.",
-  "station.api-design.how_it_works.4": "Appliquer les modèles de conception GraphQL pour créer des contrats d'API cohérents et réutilisables qui sont validés avec les parties prenantes.",
-   "station.api-design.how_it_works.5": "Utiliser les principes de conception et le guide de style des API pour aligner vos décisions de conception sur des règles communes et permettre une validation d'audit cohérente.",
-  "station.api-design.how_it_works.6": "Appliquez des approches « contract-first » ou  « design-first » pour définir et valider le contrat de l'API avant sa mise en œuvre.",
+  "station.api-design.outcomes.3": "Traçabilité de la conception à la valeur métier",
+  "station.api-design.how_it_works.1": "Utilisez le canevas d'interaction pour définir la manière dont les utilisateurs interagiront avec l'API, en veillant à ce qu'elle réponde à leurs besoins et à leurs attentes.",
+  "station.api-design.how_it_works.2": "Appliquer les modèles de conception REST pour créer des contrats d'interface cohérents et réutilisables qui sont validés avec les parties prenantes.",
+  "station.api-design.how_it_works.3": "Appliquer des modèles de conception orientés événements pour créer des contrats d'interface cohérents et réutilisables qui sont validés avec les parties prenantes.",
+  "station.api-design.how_it_works.4": "Appliquer les modèles de conception GraphQL pour créer des contrats d'interface cohérents et réutilisables qui sont validés avec les parties prenantes.",
+  "station.api-design.how_it_works.5": "Utiliser les principes de conception et le guide de style des API pour aligner vos décisions de conception sur des règles communes et permettre une validation d'audit cohérente.",
+  "station.api-design.how_it_works.6": "Appliquez des approches « contract-first » ou « design-first » pour définir et valider le contrat de l'API avant sa mise en œuvre.",
   "station.api-design.how_it_works.7": "Utilisez la liste de contrôle d'audit des API pour vous assurer que la conception de l'API répond aux exigences fonctionnelles et non fonctionnelles, notamment en matière de sécurité, de performances et de conformité.",
   "station.api-delivery.outcomes.1": "Pipelines CI/CD fiables et automatisés",
   "station.api-delivery.outcomes.2": "Tests fonctionnels et non fonctionnels intégrés",
@@ -242,8 +242,8 @@
   "station.api-publishing.outcomes.1": "Des processus clairs d'intégration et d'enregistrement de l'API",
   "station.api-publishing.outcomes.2": "Documentation, modèles de sécurité et politiques disponibles",
   "station.api-publishing.outcomes.3": "Des API prêtes pour l'échelle et la gouvernance",
-  "station.api-publishing.how_it_works.1": "Documenter la manière dont les consommateurs trouvent et utilisent l'API, y compris les processus d'accueil et d'enregistrement.",
-  "station.api-publishing.how_it_works.2": "Veiller à ce que les modèles de sécurité, la configuration de la passerelle et les termes juridiques soient clairs et accessibles aux consommateurs.",
+  "station.api-publishing.how_it_works.1": "Documenter la manière dont les utilisateurs trouvent et utilisent l'API, y compris les processus d'accueil et d'enregistrement.",
+  "station.api-publishing.how_it_works.2": "Veiller à ce que les modèles de sécurité, la configuration de la passerelle et les termes juridiques soient clairs et accessibles aux utilisateurs.",
   "station.monitoring-and-improving.outcomes.1": "Boucles de rétroaction des développeurs en place",
   "station.monitoring-and-improving.outcomes.2": "Questions identifiées et traitées en permanence",
   "station.monitoring-and-improving.outcomes.3": "Itération de l'API alignée sur les besoins des utilisateurs",
@@ -252,14 +252,14 @@
   "station.user-experience.outcomes.1": "Interfaces utilisateur intuitives et cohérentes",
   "station.user-experience.outcomes.2": "Le retour d'information des utilisateurs est intégré dans la conception de l'API",
   "station.user-experience.outcomes.3": "Amélioration de la satisfaction et de l'adoption des utilisateurs",
-  "station.user-experience.how_it_works.1": "Mener des études sur les utilisateurs pour comprendre comment les consommateurs interagissent avec les services de l'écosystème ou avec vos applications consommatrices d'API.",
+  "station.user-experience.how_it_works.1": "Mener des études sur les utilisateurs pour comprendre comment les utilisateurs interagissent avec les services de l'écosystème ou avec vos applications consommatrices d'API.",
   "station.user-experience.how_it_works.2": "Documenter les exigences en matière d'expérience utilisateur afin qu'elles puissent être utilisées dans la conception de l'API, en veillant à ce qu'elles soient intuitives et faciles à utiliser.",
   "station.market-insights.outcomes.1": "Identification des normes industrielles et des meilleures pratiques",
   "station.market-insights.outcomes.2": "Stratégie API alignée sur les besoins du marché",
   "station.market-insights.outcomes.3": "Une prise de décision éclairée basée sur la connaissance du marché",
   "station.market-insights.how_it_works.1": "Analyser les API des concurrents pour comprendre leurs forces, leurs faiblesses et leurs arguments de vente uniques.",
   "station.market-insights.how_it_works.2": "Identifier les normes et les meilleures pratiques du secteur pour garantir la compétitivité et la conformité des API.",
-  "station.business-goals.outcomes.1": "Valeur commerciale clairement définie pour chaque API",
+  "station.business-goals.outcomes.1": "Valeur métier clairement définie pour chaque API",
   "station.business-goals.outcomes.2": "Adhésion et soutien des parties prenantes aux initiatives API",
   "station.business-goals.outcomes.3": "Les API contribuent au succès de l'organisation",
   "station.business-goals.how_it_works.1": "Identifier les indicateurs clés de performance (KPI) pour mesurer la réussite de l'API par rapport aux objectifs de l'entreprise.",
@@ -283,7 +283,7 @@
   "station.legal-and-compliance.outcomes.2": "Risques juridiques identifiés et atténués",
   "station.legal-and-compliance.outcomes.3": "Documentation claire des mesures de conformité",
   "station.legal-and-compliance.how_it_works.1": "Mettre en œuvre des mesures pour s'assurer que les API sont conformes à ces exigences, y compris le cryptage des données, les contrôles d'accès et les pistes d'audit.",
-  "station.legal-and-compliance.how_it_works.2": "Documenter les mesures de conformité et veiller à ce qu'elles soient communiquées aux parties prenantes et aux consommateurs.",
+  "station.legal-and-compliance.how_it_works.2": "Documenter les mesures de conformité et veiller à ce qu'elles soient communiquées aux parties prenantes et aux utilisateurs.",
   "station.security-and-privacy.outcomes.1": "Les données des utilisateurs sont protégées par des mesures de protection de la vie privée",
   "station.security-and-privacy.outcomes.2": "Mise en œuvre des meilleures pratiques de sécurité dans la conception et le développement des API",
   "station.security-and-privacy.outcomes.3": "Respect des normes et réglementations en matière de sécurité",
@@ -299,15 +299,15 @@
   "station.vendor-management.outcomes.3": "Réduction des risques liés aux dépendances avec des tiers",
   "station.vendor-management.how_it_works.1": "Définir les critères d'évaluation des API des fournisseurs, y compris la fiabilité, la sécurité et la conformité.",
   "station.vendor-management.how_it_works.2": "Contrôler les performances des fournisseurs et le respect des accords de niveau de service (SLA) et des normes de l'organisation.",
-  "station.contract-design.outcomes.1": "Attentes et responsabilités des fournisseurs d'API et des consommateurs",
+  "station.contract-design.outcomes.1": "Attentes et responsabilités des fournisseurs d'API et des utilisateurs",
   "station.contract-design.outcomes.2": "Directives d'utilisation et bonnes pratiques documentées",
   "station.contract-design.outcomes.3": "Réduction des malentendus et des litiges concernant l'utilisation de l'API",
-  "station.contract-design.how_it_works.1": "Utiliser des formats normalisés (par exemple, OpenAPI, AsyncAPI) pour créer des contrats d'API lisibles par machine, faciles à partager et à valider.",
+  "station.contract-design.how_it_works.1": "Utiliser des formats normalisés (par exemple, OpenAPI, AsyncAPI) pour créer des contrats d'interface lisibles par machine, faciles à partager et à valider.",
   "station.contract-design.how_it_works.2": "Veiller à ce que les contrats API soient examinés et approuvés par les parties prenantes afin de garantir l'alignement et la clarté.",
   "station.development.outcomes.1": "Des API de haute qualité, faciles à entretenir et évolutives",
   "station.development.outcomes.2": "Respect des normes et pratiques de codage cohérentes",
   "station.development.outcomes.3": "Réduction du temps de développement et de la dette technique",
-  "station.development.how_it_works.1": "Appliquer des approches de type \"contrat d'abord\" ou \"conception d'abord\" pour s'assurer que les contrats d'API sont validés avant leur mise en œuvre.",
+  "station.development.how_it_works.1": "Appliquer des approches de type \"contrat d'abord\" ou \"conception d'abord\" pour s'assurer que les contrats d'interface sont validés avant leur mise en œuvre.",
   "station.development.how_it_works.2": "Respecter les normes de codage et les meilleures pratiques afin d'assurer un développement cohérent et de haute qualité de l'API.",
   "station.ci-cd.outcomes.1": "Qualité et traçabilité constantes dans la livraison des API",
   "station.ci-cd.outcomes.2": "Des itérations plus rapides et une réduction du temps de mise sur le marché",
@@ -324,19 +324,19 @@
   "station.release-management.outcomes.3": "Réduction des risques liés aux changements d'API",
   "station.release-management.how_it_works.1": "Mettre en œuvre des stratégies de déploiement (par exemple, des déploiements \"bleu-vert\", des versions \"canari\") afin de minimiser les risques lors des mises à jour de l'API.",
   "station.release-management.how_it_works.2": "Mettre en place des procédures de retour en arrière pour revenir rapidement sur les modifications en cas de problèmes lors des mises à jour de l'API.",
-  "station.service-agreements.outcomes.1": "Attentes et niveaux de service définis pour les fournisseurs d'API et les consommateurs",
+  "station.service-agreements.outcomes.1": "Attentes et niveaux de service définis pour les fournisseurs d'API et les utilisateurs",
   "station.service-agreements.outcomes.2": "Responsabilités et processus de soutien documentés",
   "station.service-agreements.outcomes.3": "Amélioration de la communication et de la collaboration entre les équipes API",
   "station.service-agreements.how_it_works.1": "Utiliser des formats normalisés pour créer des accords de service lisibles par machine, faciles à partager et à valider.",
   "station.service-agreements.how_it_works.2": "Veiller à ce que les accords de service soient examinés et approuvés par les parties prenantes afin de garantir l'alignement et la clarté.",
   "station.api-consumer-adoption.outcomes.1": "Augmentation de l'utilisation de l'API et de l'engagement",
-  "station.api-consumer-adoption.outcomes.2": "Les consommateurs d'API sont informés des caractéristiques et des avantages de l'API",
-  "station.api-consumer-adoption.outcomes.3": "Amélioration de la satisfaction et de la fidélité des consommateurs d'API",
+  "station.api-consumer-adoption.outcomes.2": "Les utilisateurs sont informés des caractéristiques et des avantages de l'API",
+  "station.api-consumer-adoption.outcomes.3": "Amélioration de la satisfaction et de la fidélité des utilisateurs",
   "station.api-consumer-adoption.how_it_works.1": "Créer des supports pédagogiques (par exemple, des tutoriels, de la documentation) qui expliquent les caractéristiques, les avantages et les modes d'utilisation de l'API.",
-  "station.api-consumer-adoption.how_it_works.2": "S'engager auprès des consommateurs d'API par le biais de boucles de retour d'information, de canaux d'assistance et de forums communautaires afin de comprendre leurs besoins et d'améliorer l'adoption de l'API.",
+  "station.api-consumer-adoption.how_it_works.2": "S'engager auprès des utilisateurs par le biais de boucles de retour d'information, de canaux d'assistance et de forums communautaires afin de comprendre leurs besoins et d'améliorer l'adoption de l'API.",
   "station.api-promotion.outcomes.1": "Augmentation de la visibilité et de la notoriété de l'API",
   "station.api-promotion.outcomes.2": "Taux d'utilisation et d'adoption de l'API plus élevés",
-  "station.api-promotion.outcomes.3": "Amélioration de l'engagement et de la satisfaction des consommateurs d'API",
+  "station.api-promotion.outcomes.3": "Amélioration de l'engagement et de la satisfaction des utilisateurs",
   "station.api-promotion.how_it_works.1": "Créer du matériel promotionnel (par exemple, des études de cas, des exemples de réussite) qui met en évidence la valeur et les avantages des API.",
   "station.api-promotion.how_it_works.2": "S'impliquer dans les communautés et les forums API pour partager les mises à jour de l'API, recueillir des commentaires et promouvoir l'utilisation de l'API.",
   "station.partner-integration.outcomes.1": "Capacités API améliorées grâce aux API des partenaires",
@@ -357,8 +357,6 @@
   "station.upskilling.outcomes.1": "Compétences accrues en matière de conception, de développement et de gestion des API",
   "station.upskilling.outcomes.2": "Amélioration de la capacité à adopter de nouvelles technologies et pratiques",
   "station.upskilling.outcomes.3": "Des équipes responsabilisées pour favoriser l'innovation et la qualité de l'API",
-  "station.upskilling.how_it_works.1": "Fournir des programmes de formation, des ateliers et des ressources pour aider les équipes à améliorer leurs compétences et leurs connaissances en matière d'API.",
-  "station.upskilling.how_it_works.2": "Encourager la formation continue par des cours en ligne, des certifications et l'engagement communautaire.",
   "station.operating-guidelines.outcomes.1": "Gestion et qualité cohérentes de l'API dans l'ensemble de l'organisation",
   "station.operating-guidelines.outcomes.2": "Respect des normes et des meilleures pratiques de l'organisation",
   "station.operating-guidelines.outcomes.3": "Amélioration de la visibilité et du contrôle des initiatives en matière d'API",
@@ -367,11 +365,103 @@
   "station.portfolio-management.outcomes.1": "Des API alignées sur les objectifs de l'entreprise et les initiatives stratégiques",
   "station.portfolio-management.outcomes.2": "Hiérarchisation et optimisation des API en fonction de leur valeur et de leur impact",
   "station.portfolio-management.outcomes.3": "Amélioration de la visibilité et du contrôle du portefeuille d'API",
-  "station.portfolio-management.how_it_works.1": "Établir des critères d'évaluation et de hiérarchisation des API en fonction de la valeur commerciale, de l'impact et de l'alignement sur les initiatives stratégiques.",
-  "station.portfolio-management.how_it_works.2": "Contrôler le portefeuille d'API pour s'assurer que les API apportent de la valeur, répondent aux attentes en matière de performances et s'alignent sur les objectifs de l'entreprise.",
   "station.budget-and-resource-management.outcomes.1": "Affectation efficace des ressources aux initiatives de l'API",
   "station.budget-and-resource-management.outcomes.2": "Optimisation des investissements dans le développement et la gestion des API",
   "station.budget-and-resource-management.outcomes.3": "Amélioration de la visibilité financière et du contrôle des initiatives API",
-  "station.budget-and-resource-management.how_it_works.1": "Établir des critères d'évaluation et de hiérarchisation des affectations budgétaires en fonction de la valeur commerciale, de l'impact et de l'alignement sur les initiatives stratégiques.",
-  "station.budget-and-resource-management.how_it_works.2": "Contrôler le budget et l'utilisation des ressources afin de garantir l'efficacité des investissements et de l'affectation des ressources pour les initiatives de l'API."
+  "cycle.api-productization-cycle.station.api-product-strategy.title": "Stratégie produit API - Transformer les API en produits stratégiques",
+  "cycle.api-productization-cycle.station.api-product-strategy.description": "Avant de construire quoi que ce soit, définissez dès le départ la valeur de votre API, ses utilisateurs et ses objectifs métier.",
+  "cycle.api-productization-cycle.station.api-product-strategy.why_it_matters": "De nombreuses organisations considèrent les API comme des projets technologiques et non comme des produits. Le résultat ? Des utilisateurs désorientés, une adoption médiocre et un gaspillage d'efforts.\n\nCette station vous aide à définir l'objectif, le public cible et les critères de réussite de votre API, afin que les équipes puissent fournir des API qui résolvent des problèmes réels.",
+  "cycle.api-productization-cycle.station.api-product-strategy.apply_in_work": "Fournir des lignes directrices et des modèles pour la création de modèles commerciaux, de propositions de valeur et de feuilles de route pour les API.",
+  "cycle.api-productization-cycle.station.api-product-strategy.outcomes": "Une proposition de valeur et un public simples pour l'API",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works": "Explorez le problème du client ou du partenaire que vous comptez résoudre avec les API. Dressez la carte des parties prenantes, de leurs parcours et de leurs résultats à l'aide du Customer Journey canvas.",
+  "cycle.api-productization-cycle.station.api-product-strategy.outcomes.1": "Un langage commun entre le produit, le design et la technologie",
+  "cycle.api-productization-cycle.station.api-product-strategy.outcomes.2": "Un argumentaire ou un dossier solide pour le financement/l'approbation",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works.1": "Définir les entités de base, leurs attributs et leurs relations pour créer une compréhension conceptuelle partagée à travers les parcours et éventuellement les API.",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works.2": "Utilisez le canevas de proposition de valeur de l'API pour recenser les tâches métier prises en charge ainsi que les difficultés, les avantages et les fonctionnalités pour l'utilisateur qui façonnent les API nouvelles ou réutilisables.",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works.3": "Définissez la valeur - pour les utilisateurs et l'entreprise - à l'aide du modèle commercial de l'API, afin de rendre votre stratégie API visuelle, partageable et facile à valider avec vos utilisateurs à la prochaine station.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.title": "API Consumer Experience - Concevoir pour les vrais utilisateurs de votre API",
+  "cycle.api-productization-cycle.station.api-consumer-experience.description": "Veillez à ce que votre API soit découvrable, compréhensible et utilisable - avant et après le lancement.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.why_it_matters": "Les meilleures API ne se contentent pas de fonctionner, elles sont intuitives. Que votre utilisateur soit un développeur interne, un partenaire externe ou un agent d'intelligence artificielle, c'est son expérience qui détermine l'adoption.\n\nSans un plan d'expérience clair :\n- Les meilleures API restent inutilisées\n- Les équipes perdent du temps à deviner comment utiliser votre API.\n- Les boucles de rétroaction sont brisées ou manquantes.\n\nCette station vous aide à voir votre API à travers les yeux de ses utilisateurs.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.how_it_works": "Examinez l'API Value Proposition Canvas du point de vue de l'utilisateur. Veillez à la stabilité des tâches métier prises en charge et enrichissez les fonctionnalités qui simplifient et optimisent l'expérience utilisateur en intégrant les préoccupations des utilisateurs afin d'orienter les décisions de conception ultérieures.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.how_it_works.1": "Utilisez le canevas du parcours client pour le parcours de l'utilisateur, de la découverte et de l'évaluation à l'intégration, au dépannage et à l'utilisation continue.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.how_it_works.2": "Utilisez le parcours ainsi obtenu pour améliorer l'intégration, la documentation, l'assistance et les boucles de rétroaction pour l'utilisateur.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.apply_in_work": "Fournir des lignes directrices, des outils et des mécanismes de retour d'information pour comprendre, analyser et améliorer l'expérience interne et externe des développeurs et des partenaires.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes": "Identifier et hiérarchiser les utilisateurs",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes.1": "Définir le parcours de l'expérience API",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes.2": "Planifier l'intégration, la documentation et le retour d'information",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes.3": "Améliorer l'adoption grâce à une véritable empathie + l'expérience du développeur (DX)",
+  "cycle.api-productization-cycle.station.api-platform-architecture.title": "Architecture de la plateforme API - Architecturer les API pour l'évolutivité et la réutilisation",
+  "cycle.api-productization-cycle.station.api-platform-architecture.description": "Assurez l'évolutivité, la réutilisation et la gouvernance de vos composants d'API et de plateforme.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.why_it_matters": "Lorsque les API s'étendent à plusieurs équipes, votre plateforme doit permettre la gouvernance et la réutilisation sans bloquer la vitesse. Cette station montre comment architecturer les API pour assurer leur longévité, leur sécurité et leur efficacité.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.apply_in_work": "Mettre en place une infrastructure évolutive, sécurisée et conforme pour les opérations API. Fournir des lignes directrices sur les meilleures pratiques en matière d'architecture.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.outcomes": "Supprimer les API redondantes et réduire les coûts de la plateforme en nuage",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works": "Le Business Impact Canvas permet d'identifier et d'atténuer les risques liés à la disponibilité, à la sécurité et à la fonctionnalité de l'API afin de prendre des décisions éclairées en matière d'architecture.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.outcomes.1": "Mettre en œuvre une gouvernance cohérente sans contrôle descendant lourd",
+  "cycle.api-productization-cycle.station.api-platform-architecture.outcomes.2": "Conception en vue d'une réutilisation interne et d'une évolutivité externe",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works.1": "Cartographier les emplacements réglementaires, de conformité et de réseau des fournisseurs d'API et des utilisateurs afin de garantir l'accessibilité et la conformité.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works.2": "Le Capacity Canvas aligne les modèles de transactions commerciales, les tendances de consommation futures et les solutions techniques pour garantir l'évolutivité et les performances de l'API, et fournit des informations essentielles pour les décisions d'évolution et la planification de l'infrastructure.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works.3": "Définir et surveiller les indicateurs de performance (par exemple, les appels API, la latence, les taux d'erreur) et les indicateurs d'adoption (par exemple, NPS).",
+  "cycle.api-productization-cycle.station.api-design.title": "Conception d'API - Concevoir des API qui apportent de la valeur",
+  "cycle.api-productization-cycle.station.api-design.description": "Créer des architectures d'API cohérentes, réutilisables et fondées sur les objectifs métier et des normes communes.",
+  "cycle.api-productization-cycle.station.api-design.why_it_matters": "La conception d'API ne se limite pas à nommer des points de terminaison. Une bonne conception garantit que les API sont utilisables, cohérentes et alignées sur les objectifs métier et techniques. Une mauvaise conception entraîne un couplage étroit, une faible réutilisation et des retouches coûteuses entre les équipes.",
+  "cycle.api-productization-cycle.station.api-design.apply_in_work": "Fournir des modèles de conception réutilisables, des normes communes et des outils de validation pour les spécifications d'API. S'assurer que les décisions de conception sont cohérentes, examinées dès le début et alignées sur les objectifs métier.",
+  "cycle.api-productization-cycle.station.api-design.outcomes": "Des conceptions d'API bien documentées et cohérentes",
+  "cycle.api-productization-cycle.station.api-design.how_it_works": "Définir les entités de base, leurs attributs et leurs relations afin de créer une compréhension conceptuelle partagée entre les API.",
+  "cycle.api-productization-cycle.station.api-design.outcomes.1": "Contrats d'interface API réutilisables et validés",
+  "cycle.api-productization-cycle.station.api-design.outcomes.2": "Conceptions alignées sur les modèles de domaine et les modèles d'interaction",
+  "cycle.api-productization-cycle.station.api-design.outcomes.3": "Traçabilité de la conception à la valeur métier",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.1": "Utilisez le canevas d'interaction pour définir la manière dont les utilisateurs interagiront avec l'API, en veillant à ce qu'elle réponde à leurs besoins et à leurs attentes.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.2": "Appliquer les modèles de conception REST pour créer des contrats d'interface cohérents et réutilisables qui sont validés avec les parties prenantes.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.3": "Appliquer des modèles de conception orientés événements pour créer des contrats d'interface cohérents et réutilisables qui sont validés avec les parties prenantes.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.4": "Appliquer les modèles de conception GraphQL pour créer des contrats d'interface cohérents et réutilisables qui sont validés avec les parties prenantes.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.5": "Utiliser les principes de conception et le guide de style des API pour aligner vos décisions de conception sur des règles communes et permettre une validation d'audit cohérente.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.6": "Appliquez des approches « contract-first » ou « design-first » pour définir et valider le contrat d'interface API avant sa mise en œuvre.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.7": "Utilisez la liste de contrôle d'audit des API pour vous assurer que la conception de l'API répond aux exigences fonctionnelles et non fonctionnelles, notamment en matière de sécurité, de performances et de conformité.",
+  "cycle.api-productization-cycle.station.api-delivery.title": "Livraison d'API - Fournir des API sécurisées et fiables",
+  "cycle.api-productization-cycle.station.api-delivery.description": "Construire, tester et publier des API en utilisant des pipelines de livraison modernes et les meilleures pratiques d'ingénierie.",
+  "cycle.api-productization-cycle.station.api-delivery.why_it_matters": "Même les meilleures conceptions d'API échouent si la livraison est incohérente. Cette station garantit que vos API sont construites avec qualité, testées de manière approfondie et déployées de manière fiable, ce qui permet des itérations plus rapides et une plus grande confiance.",
+  "cycle.api-productization-cycle.station.api-delivery.apply_in_work": "Fournir des frameworks de développement, des bibliothèques et des normes pour la mise en œuvre des API. Mettre en œuvre des pipelines CI/CD, des cadres d'assurance qualité et des outils d'automatisation du déploiement.",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes": "API mises en œuvre à l'aide de cadres et de modèles testés",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works": "Utilisez les meilleures pratiques de développement d'API comme guide pour mettre en œuvre le contrat d'interface validé à l'aide de frameworks et de bibliothèques établis, en veillant à ce que le résultat soit réutilisable et maintenable.",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes.1": "Pipelines CI/CD fiables et automatisés",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes.2": "Tests fonctionnels et non fonctionnels intégrés",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes.3": "Pipelines de livraison sécurisés et conformes",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.1": "Construisez l'implémentation de l'API à partir du contrat d'interface validé en utilisant des frameworks, des bibliothèques et des standards d'équipe établis.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.2": "Tester les fonctionnalités, la sécurité et les performances des API à l'aide d'outils de test automatisés.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.3": "Utiliser les pipelines CI/CD pour automatiser les processus de construction, de test et de déploiement, en garantissant une qualité et une traçabilité constantes.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.4": "S'assurer que les API répondent aux exigences de sécurité et de conformité grâce à des contrôles et des audits automatisés.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.5": "Utilisez la liste de contrôle de l'audit de l'API pour vous assurer que l'API répond aux exigences fonctionnelles et non fonctionnelles, notamment en matière de sécurité, de performances et de conformité.",
+  "cycle.api-productization-cycle.station.api-audit.title": "Audit API - Audit de conformité et de qualité des API",
+  "cycle.api-productization-cycle.station.api-audit.description": "Vérifiez que les API répondent aux normes métier, de conception et opérationnelles avant leur publication et leur mise à disposition.",
+  "cycle.api-productization-cycle.station.api-audit.why_it_matters": "Les API sont des produits à longue durée de vie et doivent répondre aux attentes en matière de qualité, de cohérence et de conformité. L'audit relie les décisions de conception, la mise en œuvre et l'état de préparation opérationnelle à des normes définies, réduisant ainsi les risques avant la mise à disposition.",
+  "cycle.api-productization-cycle.station.api-audit.apply_in_work": "Mettez en place un processus d'audit cohérent qui évalue l'état de préparation des API à toutes les étapes du cycle de vie à l'aide de critères, de preuves et de normes définis. Assurez-vous que les lacunes sont identifiées tôt et résolues avant la publication.",
+  "cycle.api-productization-cycle.station.api-audit.outcomes": "Les API sont conformes aux normes internes et externes",
+  "cycle.api-productization-cycle.station.api-audit.how_it_works": "Mener des audits pour s'assurer que les API respectent les normes organisationnelles, techniques et juridiques avant d'être publiées.",
+  "cycle.api-productization-cycle.station.api-audit.outcomes.1": "Documentation claire des décisions relatives à la conception et à la mise en œuvre de l'API",
+  "cycle.api-productization-cycle.station.api-audit.outcomes.2": "Sécurité, performance et conformité validées",
+  "cycle.api-productization-cycle.station.api-audit.outcomes.3": "Réduction du risque de problèmes en production",
+  "cycle.api-productization-cycle.station.api-audit.how_it_works.1": "Utiliser des listes de contrôle, des linters et des outils de test pour vérifier la cohérence et la conformité avec les normes.",
+  "cycle.api-productization-cycle.station.api-audit.how_it_works.2": "Collaborer avec les équipes de gouvernance et les experts du domaine pour s'assurer que les API sont prêtes pour la production.",
+  "cycle.api-productization-cycle.station.api-publishing.title": "Publication d'API - Publier des API en toute confiance",
+  "cycle.api-productization-cycle.station.api-publishing.description": "Exposer les API de manière sûre et claire au bon public avec la bonne documentation et les bons processus.",
+  "cycle.api-productization-cycle.station.api-publishing.why_it_matters": "La publication va plus loin que le déploiement - il s'agit de la découvrabilité, de l'accès et de l'assistance. Si les API ne sont pas publiées correctement, elles ne seront pas utilisées, réutilisées ou sécurisées efficacement.",
+  "cycle.api-productization-cycle.station.api-publishing.apply_in_work": "Permettre aux API d'être publiées dans l'environnement approprié et disposer de mécanismes d'enregistrement et d'accès clairs (par exemple, clés API, OAuth, plans d'abonnement) en fonction des segments de utilisateurs et des exigences en matière de sécurité et de conformité.",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes": "API publiées dans le bon environnement (privé, partenaire, public)",
+  "cycle.api-productization-cycle.station.api-publishing.how_it_works": "Publier les API dans les passerelles et les environnements appropriés afin de favoriser la réutilisation pour de multiples utilisateurs.",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes.1": "Des processus clairs d'intégration et d'enregistrement de l'API",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes.2": "Documentation, modèles de sécurité et politiques disponibles",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes.3": "Des API prêtes pour l'échelle et la gouvernance",
+  "cycle.api-productization-cycle.station.api-publishing.how_it_works.1": "Documenter la manière dont les utilisateurs trouvent et utilisent l'API, y compris les processus d'accueil et d'enregistrement.",
+  "cycle.api-productization-cycle.station.api-publishing.how_it_works.2": "Veiller à ce que les modèles de sécurité, la configuration de la passerelle et les termes juridiques soient clairs et accessibles aux utilisateurs.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.title": "Suivi et amélioration - pour la valeur de l'API",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.description": "Utiliser les mesures et le retour d'information pour suivre les performances de l'API et favoriser l'amélioration continue.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.why_it_matters": "La livraison d'API ne s'arrête pas au lancement. Sans surveillance, les équipes ne peuvent pas améliorer l'adoption, les performances ou le retour sur investissement. Cette station garantit que les API restent utiles, sécurisées et qu'elles évoluent avec les besoins de l'entreprise.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.apply_in_work": "Mettre en place des cadres d'analyse pour suivre les performances et l'engagement. Développer des boucles de rétroaction, des outils d'analyse et des stratégies d'engagement pour les API.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes": "Définition et suivi des indicateurs de performance et d'utilisation",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.how_it_works": "Contrôler les indicateurs de performance (par exemple, les appels à l'API, la latence, les taux d'erreur) et les indicateurs d'adoption (par exemple, NPS).",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes.1": "Boucles de rétroaction des développeurs en place",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes.2": "Questions identifiées et traitées en permanence",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes.3": "Itération de l'API alignée sur les besoins des utilisateurs",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.how_it_works.1": "Analyser les indicateurs d'utilisation de l'API et intégrer les commentaires des utilisateurs dans les itérations de l'API.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.how_it_works.2": "Prendre l'habitude d'examiner les mesures et de planifier des activités d'amélioration continue."
 }
diff --git a/src/data/method/lines.json b/src/data/method/lines.json
index e6b0c43..3e7df9e 100644
--- a/src/data/method/lines.json
+++ b/src/data/method/lines.json
@@ -107,4 +107,4 @@
       }
     ]
   }
-}
\ No newline at end of file
+}
diff --git a/src/data/method/pt/labels.criteria.json b/src/data/method/pt/labels.criteria.json
index 9fbf93c..2e21d47 100644
--- a/src/data/method/pt/labels.criteria.json
+++ b/src/data/method/pt/labels.criteria.json
@@ -1,25 +1,26 @@
 {
   "exit_criteria": "Critérios de saída",
   "entry_criteria": "Critérios de entrada",
-  "criterion.metrics-feedback-available": "Sinais de mercado relevantes, feedback ou insights operacionais estão disponíveis para orientar esta oportunidade de API.",
-  "criterion.business-goals-defined": "As metas de negócios estão definidas",
-  "criterion.market-research-done": "A pesquisa de mercado identifica oportunidades de API",
-  "criterion.stakeholder-approval": "As partes interessadas relevantes concordam que esta oportunidade de API vale a pena ser explorada e priorizada.",
-  "criterion.api-opportunity-documented": "As oportunidades individuais de API são identificadas e documentadas",
-  "criterion.api-reusability": "A API atende a uma necessidade clara de negócios e é reutilizável para vários consumidores de API",
-  "criterion.hide-backend-discrepancies": "A API é destinada a proteger os consumidores da complexidade e das inconsistências do backend.",
-  "criterion.value-prop-validated": "A proposta de valor da API foi revisada e validada com as partes interessadas relevantes do negócio e dos consumidores.",
-  "criterion.consumer-segments-identified": "Os segmentos de consumidores de API (internos e externos) são identificados.",
-  "criterion.api-roadmap-defined": "Roteiros de alto nível para o desenvolvimento de API são estabelecidos.",
-  "criterion.architecture-patterns-validated": "Os padrões de arquitetura e plataforma da API escolhidos foram validados com as partes interessadas relevantes de arquitetura, segurança e plataforma.",
-  "criterion.design-reflects-business-value": "A design da API e suas capacidades expostas refletem claramente o valor comercial e as necessidades dos usuários.",
-  "criterion.api-consistency": "O design da API segue nossas convenções compartilhadas para o produto API e o design.",
-  "criterion.api-contract-tested": "O contrato da API é testado e atende aos requisitos funcionais e não funcionais.",
-  "criterion.api-description-available": "A API e suas capacidades expostas são descritas de forma suficiente para revisão, auditoria e integração.",
-  "criterion.audit-passed": "A API é aprovada nas verificações de conformidade, segurança e auditoria.",
-  "criterion.audit-reports-shared": "Os resultados da auditoria e as decisões de correção são compartilhados com as partes interessadas relevantes.",
-  "criterion.api-ready-for-publishing": "A API está pronta para ser implantada e exposta através das portarias e ambientes intencionados.",
-  "criterion.api-documentation-ready": "A documentação da API voltada para os consumidores está completa o suficiente para publicação e integração.",
-  "criterion.consumer-support-ready": "Os processos de registro, suporte e comunicação estão prontos para os consumidores da API.",
-  "criterion.legal-compliance-clear": "Os requisitos legais, de privacidade e de conformidade para publicação são definidos e compreendidos."
-}
\ No newline at end of file
+  "criterion.metrics-feedback-available": "Sinais de mercado relevantes, feedback ou conhecimento operacional estão disponíveis para orientar esta oportunidade de capacidade.",
+  "criterion.business-goals-defined": "Os objetivos de negócio estão definidos.",
+  "criterion.market-research-done": "A investigação de mercado identifica oportunidades de capacidade.",
+  "criterion.stakeholder-approval": "As partes interessadas relevantes concordam que vale a pena explorar e priorizar esta oportunidade de capacidade.",
+  "criterion.api-opportunity-documented": "A oportunidade de capacidade está identificada e documentada.",
+  "criterion.api-reusability": "A capacidade responde a uma necessidade clara de negócio e é reutilizável pelos utilizadores previstos.",
+  "criterion.hide-backend-discrepancies": "A interface selecionada fornece uma abstração adequada aos utilizadores.",
+  "criterion.value-prop-validated": "A proposta de valor da capacidade foi validada com partes interessadas de negócio e utilizadores.",
+  "criterion.consumer-segments-identified": "Os segmentos de utilizadores estão identificados.",
+  "criterion.api-roadmap-defined": "Está definido um roadmap de implementação de alto nível.",
+  "criterion.architecture-patterns-validated": "A arquitetura, plataforma e estilo de implementação escolhidos foram validados com as partes interessadas relevantes de arquitetura, segurança e plataforma.",
+  "criterion.design-reflects-business-value": "O desenho da interface e as capacidades expostas são rastreáveis ao valor de negócio e às necessidades dos utilizadores.",
+  "criterion.api-consistency": "O desenho da interface segue os standards e convenções de desenho acordados.",
+  "criterion.api-contract-tested": "O contrato de interface foi validado e testado face aos requisitos funcionais e não funcionais.",
+  "criterion.automation-workflow-validated": "O workflow, as regras, as integrações e os contratos de interface relevantes foram validados e testados.",
+  "criterion.api-description-available": "A interface e as suas capacidades estão documentadas de forma suficientemente clara para revisão, auditoria e onboarding.",
+  "criterion.audit-passed": "A solução passa as verificações de qualidade, segurança, conformidade e prontidão.",
+  "criterion.audit-reports-shared": "As conclusões da auditoria e as decisões de correção são partilhadas com as partes interessadas relevantes.",
+  "criterion.api-ready-for-publishing": "A capacidade está pronta para ser publicada ou disponibilizada através do mecanismo de entrega selecionado.",
+  "criterion.api-documentation-ready": "A documentação orientada para os utilizadores e os materiais de onboarding estão prontos.",
+  "criterion.consumer-support-ready": "Os processos de onboarding, suporte e comunicação para utilizadores estão prontos.",
+  "criterion.legal-compliance-clear": "Os requisitos legais, de privacidade e de conformidade para publicação ou disponibilização estão definidos e compreendidos."
+}
diff --git a/src/data/method/pt/labels.cycles.json b/src/data/method/pt/labels.cycles.json
new file mode 100644
index 0000000..fa21ade
--- /dev/null
+++ b/src/data/method/pt/labels.cycles.json
@@ -0,0 +1,93 @@
+{
+  "cycles.title": "Vistas de ciclo",
+  "cycles.description": "Vistas específicas por público sobre o método APIOps Cycles",
+  "cycle.capability-productization-cycle.title": "Ciclo de Produto de Capacidades",
+  "cycle.capability-productization-cycle.description": "Um ciclo para transformar capacidades de negócio em capacidades digitais reutilizáveis antes de selecionar o estilo de implementação.",
+  "cycle.capability-productization-cycle.purpose": "Identificar e transformar capacidades digitais reutilizaveis em produto antes de escolher um estilo de implementacao API, evento, ficheiro, stream, produto de dados, servico com IA, integracao direta ou hibrido.",
+  "cycle.api-productization-cycle.title": "Ciclo de Produto de API",
+  "cycle.api-productization-cycle.description": "A jornada APIOps Cycles focada em API para transformar APIs em produto, concebê-las, entregá-las, publicá-las e melhorá-las.",
+  "cycle.api-productization-cycle.purpose": "Jornada do metodo focada em API para equipas que ja sabem que o estilo de implementacao pretendido e um produto API.",
+  "cycle.integration-productization-cycle.title": "Ciclo de Produto de Integração",
+  "cycle.integration-productization-cycle.description": "Um ciclo para transformar capacidades de integracao reutilizaveis em produto antes de selecionar o estilo de implementacao.",
+  "cycle.integration-productization-cycle.purpose": "Orientar a concecao de capacidades de integracao reutilizaveis antes de escolher um estilo de implementacao API, evento, ficheiro, stream, produto de dados, integracao direta ou hibrido.",
+  "cycle.station.capability-strategy": "Estrategia da capacidade",
+  "cycle.station.consumer-requirements-onboarding": "Requisitos e onboarding de utilizadores",
+  "cycle.station.architecture-platform-decisions": "Decisões de arquitetura e plataforma",
+  "cycle.station.solution-interface-design": "Conceção da solução e da interface",
+  "cycle.station.delivery-operations": "Entrega e operações",
+  "cycle.station.quality-readiness-assurance": "Garantia de qualidade e prontidão",
+  "cycle.station.publishing-enablement": "Publicacao e enablement",
+  "cycle.station.monitoring-improvement": "Monitorização e melhoria",
+  "cycle.station.api-product-strategy": "Estratégia de produto API",
+  "cycle.station.api-consumer-experience": "Experiência do consumidor da API",
+  "cycle.station.api-platform-architecture": "Arquitetura da plataforma API",
+  "cycle.station.api-design": "Conceção da API",
+  "cycle.station.api-delivery": "Entrega da API",
+  "cycle.station.api-audit": "Auditoria da API",
+  "cycle.station.api-publishing": "Publicação da API",
+  "cycle.station.monitoring-and-improving": "Monitorizacao e melhoria da API",
+  "cycle.station.integration-capability-strategy": "Estratégia da capacidade de integração",
+  "cycle.station.integration-consumer-requirements-onboarding": "Requisitos e integração de consumidores da integração",
+  "cycle.station.integration-architecture-decision": "Arquitetura de integracao e decisoes de plataforma",
+  "cycle.station.integration-solution-design": "Conceção da solução de integração",
+  "cycle.station.integration-delivery-operations": "Entrega e operações da integração",
+  "cycle.station.integration-readiness-assurance": "Garantia de prontidão da integração",
+  "cycle.station.capability-publishing": "Publicacao e enablement da integracao",
+  "cycle.station.integration-monitoring-improvement": "Monitorização e melhoria da integração",
+  "cycle.capability-productization-cycle.station.api-product-strategy.description": "Enquadrar a necessidade de negocio como uma capacidade reutilizavel com valor, utilizadores, ownership e objectivos de negocio claros antes de selecionar o estilo de implementacao.",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.description": "Recolha requisitos dos consumidores, necessidades de integração, restrições, expectativas de serviço e responsabilidades dos produtores.",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.description": "Utilizar requisitos e restricoes para selecionar o estilo de implementacao, o padrao de arquitetura e as capacidades de plataforma necessarias.",
+  "cycle.capability-productization-cycle.station.api-design.description": "Conceber o contrato de interface e o modelo de interacao para o estilo de implementacao selecionado.",
+  "cycle.capability-productization-cycle.station.api-delivery.description": "Construir, testar, disponibilizar e operar a capacidade usando o estilo de implementacao selecionado e o contrato de interface validado.",
+  "cycle.capability-productization-cycle.station.api-audit.description": "Validar o contrato de interface, os controlos, a documentacao, o modelo de suporte e a prontidao operacional antes da publicacao.",
+  "cycle.capability-productization-cycle.station.api-publishing.description": "Publicar a capacidade para que os utilizadores a possam descobrir, avaliar, solicitar acesso, concluir o onboarding, utiliza-la e obter suporte.",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.description": "Monitorize a saúde da capacidade, os resultados dos consumidores, a fiabilidade, a reutilização e as oportunidades de melhoria.",
+  "cycle.owner.business-owner": "Responsável de negócio",
+  "cycle.owner.domain-expert": "Especialista de domínio",
+  "cycle.owner.capability-owner": "Responsável pela capacidade",
+  "cycle.owner.consumer-representative": "Representante dos consumidores",
+  "cycle.owner.enterprise-architect": "Arquiteto empresarial",
+  "cycle.owner.platform-owner": "Responsável pela plataforma",
+  "cycle.owner.api-product-owner": "Responsável pelo produto API",
+  "cycle.owner.api-platform-owner": "Responsável pela plataforma API",
+  "cycle.owner.integration-architect": "Arquiteto de integração",
+  "cycle.owner.solution-architect": "Arquiteto de solução",
+  "cycle.api-productization-cycle.station.api-product-strategy.description": "Enquadre a API como um produto com proposta de valor, consumidores, modelo de negócio, propriedade e intenção de ciclo de vida claros.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.description": "Defina segmentos de consumidores da API, percursos de integração, expectativas e requisitos de experiência antes de bloquear decisões de conceção.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.description": "Escolha e valide a plataforma API, a arquitetura, a governação e as restrições operacionais necessárias para o produto.",
+  "cycle.api-productization-cycle.station.api-design.description": "Conceba o contrato de interface da API, o modelo de interação, os esquemas, as políticas e os detalhes de usabilidade antes da implementação.",
+  "cycle.api-productization-cycle.station.api-delivery.description": "Implemente, teste, proteja, automatize e opere o produto API através do pipeline de entrega.",
+  "cycle.api-productization-cycle.station.api-audit.description": "Validar a qualidade da API, a conformidade, as evidencias, a prontidao operacional e os criterios de publicacao.",
+  "cycle.api-productization-cycle.station.api-publishing.description": "Publicar o produto API para que os utilizadores o possam descobrir, avaliar, solicitar acesso, concluir o onboarding, utiliza-lo e obter suporte.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.description": "Monitorize a saúde da API, a adoção, os resultados dos consumidores, a fiabilidade e as oportunidades de melhoria após a disponibilização.",
+  "cycle.integration-productization-cycle.station.api-product-strategy.description": "Enquadrar a capacidade de integracao reutilizavel, a necessidade de negocio, o ownership e a reutilizacao esperada antes de selecionar o estilo de implementacao.",
+  "cycle.integration-productization-cycle.station.api-consumer-experience.description": "Recolha consumidores da integração, responsabilidades dos fornecedores, necessidades de integração, expectativas de serviço e restrições operacionais.",
+  "cycle.integration-productization-cycle.station.api-platform-architecture.description": "Selecionar a arquitetura de integracao, o estilo de implementacao e as capacidades de plataforma, tendo em conta as restricoes e o modelo de governacao.",
+  "cycle.integration-productization-cycle.station.api-design.description": "Conceber o contrato de interface, os esquemas, os payloads e os padroes de interacao para o estilo de integracao selecionado.",
+  "cycle.integration-productization-cycle.station.api-delivery.description": "Construir, testar, automatizar, disponibilizar e operar a capacidade de integracao usando o estilo de implementacao selecionado e o contrato de interface validado.",
+  "cycle.integration-productization-cycle.station.api-audit.description": "Assegure a prontidão, a governação, a qualidade, a segurança, a conformidade e as evidências operacionais da integração antes da disponibilização.",
+  "cycle.integration-productization-cycle.station.api-publishing.description": "Publicar a capacidade de integracao para que as equipas a possam descobrir, avaliar, solicitar acesso, concluir o onboarding, reutiliza-la e obter suporte.",
+  "cycle.integration-productization-cycle.station.monitoring-and-improving.description": "Monitorize a fiabilidade da integração, a reutilização, os incidentes, o desempenho, os resultados dos consumidores e as necessidades de melhoria.",
+  "cycle.automation-cycle.title": "Ciclo de Automação",
+  "cycle.automation-cycle.description": "Um ciclo para identificar, conceber, entregar, capacitar e melhorar oportunidades de automação.",
+  "cycle.automation-cycle.purpose": "Transformar oportunidades de automação em fluxos de trabalho governados com utilizadores, plataformas, controlos, percursos de entrega, capacitação e monitorização claros.",
+  "cycle.audience.automation-owners": "Responsáveis pela automação",
+  "cycle.audience.process-owners": "Responsáveis pelo processo",
+  "cycle.audience.automation-teams": "Equipas de automação",
+  "cycle.station.automation-opportunity-strategy": "Estratégia da oportunidade de automação",
+  "cycle.station.process-user-requirements": "Requisitos do processo e dos utilizadores",
+  "cycle.station.automation-platform-decision": "Decisão de plataforma de automação",
+  "cycle.station.automation-workflow-design": "Conceção do fluxo de trabalho de automação",
+  "cycle.station.automation-delivery": "Entrega e operacao da automacao",
+  "cycle.station.automation-readiness-review": "Revisão de prontidão da automação",
+  "cycle.station.automation-enablement": "Rollout e enablement da automacao",
+  "cycle.station.automation-monitoring-improvement": "Monitorização e melhoria da automação",
+  "cycle.automation-cycle.station.api-product-strategy.description": "Identifique e priorize oportunidades de automação por valor, viabilidade, risco, propriedade e impacto esperado no processo.",
+  "cycle.automation-cycle.station.api-consumer-experience.description": "Recolha utilizadores do processo, funções, transferências, exceções, restrições e expectativas de serviço antes de conceber a automação.",
+  "cycle.automation-cycle.station.api-platform-architecture.description": "Escolher a plataforma de automacao, o runtime, a abordagem de integracao, os controlos de governacao e as restricoes operacionais.",
+  "cycle.automation-cycle.station.api-design.description": "Conceber o fluxo de trabalho de automacao, os gatilhos, os pontos de decisao, as integracoes, o tratamento de dados, os contratos de interface relevantes e os caminhos de excecao.",
+  "cycle.automation-cycle.station.api-delivery.description": "Construa, teste, disponibilize, documente e opere a automação com propriedade, controlos e caminhos de reversão claros.",
+  "cycle.automation-cycle.station.api-audit.description": "Reveja a prontidão, a qualidade, o risco, a conformidade, a supervisão humana, as evidências e os critérios de disponibilização da automação.",
+  "cycle.automation-cycle.station.api-publishing.description": "Capacite utilizadores e operadores com descoberta, integração, instruções operacionais, caminhos de suporte e comunicação de alterações.",
+  "cycle.automation-cycle.station.monitoring-and-improving.description": "Monitorize o desempenho da automação, exceções, fiabilidade, resultados dos utilizadores, impacto operacional e oportunidades de melhoria."
+}
diff --git a/src/data/method/pt/labels.json b/src/data/method/pt/labels.json
index 6efbd2b..c8ee178 100644
--- a/src/data/method/pt/labels.json
+++ b/src/data/method/pt/labels.json
@@ -1,11 +1,11 @@
 {
   "stations": "Estações",
-  "why_it_matters": "Por que esta estação existe?",
+  "why_it_matters": "Porque existe esta estação?",
   "outcomes": "Resultados",
   "how_it_works": "Como funciona",
   "steps": "Passos",
-  "apply_in_work": "Isto é o que significa sucesso",
-  "related_metrolines": "Incluído nestas linhas de metrô",
+  "apply_in_work": "Como é o sucesso na prática",
+  "related_metrolines": "Incluído nestas linhas",
   "entry_criteria_title": "Sinais de partida",
-  "exit_criteria_title": "Feito bem quando"
-}
\ No newline at end of file
+  "exit_criteria_title": "Concluído com qualidade quando"
+}
diff --git a/src/data/method/pt/labels.lines.json b/src/data/method/pt/labels.lines.json
index d16251b..092746e 100644
--- a/src/data/method/pt/labels.lines.json
+++ b/src/data/method/pt/labels.lines.json
@@ -1,11 +1,11 @@
 {
-  "lines.title": "Linhas de metro",
-  "lines.description": "Uma coleção de linhas API que orientam o desenvolvimento e a gestão de APIs.",
+  "lines.title": "Linhas",
+  "lines.description": "Uma coleção de linhas de API que orientam o desenvolvimento e a gestão de APIs.",
   "line.business-opportunities-line.title": "Linha oportunidades de negócio",
   "line.business-opportunities-line.description": "Centra-se na identificação e aproveitamento de oportunidades de negócio através de APIs.",
   "line.platform-architecture-line.title": "Linha de arquitetura da plataforma",
-  "line.platform-architecture-line.description": "Abrange os aspectos arquitecturais das plataformas API.",
-  "line.api-design-line.title": "Linha de conceção API",
+  "line.platform-architecture-line.description": "Abrange os aspetos arquiteturais das plataformas API.",
+  "line.api-design-line.title": "Linha de conceção de API",
   "line.api-design-line.description": "Centra-se nos princípios e práticas de conceção de APIs.",
   "line.delivery-line.title": "Linha de entrega",
   "line.delivery-line.description": "Abrange os processos e práticas de entrega de APIs.",
diff --git a/src/data/method/pt/labels.resources.json b/src/data/method/pt/labels.resources.json
index ef876d4..5b646a1 100644
--- a/src/data/method/pt/labels.resources.json
+++ b/src/data/method/pt/labels.resources.json
@@ -2,188 +2,188 @@
   "resource.api-community-engagement-strategies.title": "Estratégias de envolvimento da comunidade API",
   "resource.api-community-engagement-strategies.description": "Um manual para promover a adoção de APIs, cultivando comunidades através de conteúdos, canais de apoio, ciclos de feedback e estratégias de envolvimento social.",
   "resource.api-community-engagement-strategies.outcomes": "Melhor compreensão dos princípios das estratégias de envolvimento da comunidade da API",
-  "resource.api-community-engagement-strategies.outcomes.1": "Abordagem padronizada usando as estratégias de envolvimento da comunidade da API",
+  "resource.api-community-engagement-strategies.outcomes.1": "Abordagem normalizada utilizando as estratégias de envolvimento da comunidade da API",
   "resource.api-community-engagement-strategies.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
-  "resource.api-community-engagement-strategies.steps": "Desenvolver estratégias de marketing para promover as API junto de públicos-alvo, incluindo redes sociais, blogues e webinars.",
-  "resource.api-community-engagement-strategies.steps.1": "Criar materiais promocionais (por exemplo, estudos de casos, histórias de sucesso) que realcem o valor e as vantagens das API.",
-  "resource.api-community-engagement-strategies.steps.2": "Criar materiais educativos (por exemplo, tutoriais, documentação) que expliquem as caraterísticas, as vantagens e os padrões de utilização da API.",
-  "resource.api-community-engagement-strategies.steps.3": "Interagir com os consumidores da API através de ciclos de feedback, canais de apoio e fóruns da comunidade para compreender as suas necessidades e melhorar a adoção da API.",
+  "resource.api-community-engagement-strategies.steps": "Desenvolver estratégias de marketing para promover as APIs junto de públicos-alvo, incluindo redes sociais, blogues e webinars.",
+  "resource.api-community-engagement-strategies.steps.1": "Criar materiais promocionais (por exemplo, estudos de casos, histórias de sucesso) que realcem o valor e as vantagens das APIs.",
+  "resource.api-community-engagement-strategies.steps.2": "Criar materiais educativos (por exemplo, tutoriais, documentação) que expliquem as características, as vantagens e os padrões de utilização da API.",
+  "resource.api-community-engagement-strategies.steps.3": "Interagir com os utilizadores da API através de ciclos de feedback, canais de apoio e fóruns da comunidade para compreender as suas necessidades e melhorar a adoção da API.",
   "resource.api-community-engagement-strategies.steps.4": "Analisar as métricas de utilização da API e incorporar o feedback dos utilizadores nas iterações da API.",
-  "resource.api-community-engagement-strategies.tips": "Personalize as estratégias de envolvimento da comunidade da API para o seu domínio",
-  "resource.api-community-engagement-strategies.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
-  "resource.api-compliance-best-practices.title": "Melhores práticas de conformidade da API",
-  "resource.api-compliance-best-practices.description": "Garantir que as APIs cumprem a conformidade legal, regulamentar e interna através de documentação, controlos e validações automatizadas.",
-  "resource.api-compliance-best-practices.outcomes": "Melhor compreensão dos princípios das melhores práticas de conformidade da API",
+  "resource.api-community-engagement-strategies.tips": "Personalize as estratégias de envolvimento da comunidade de API ao seu domínio",
+  "resource.api-community-engagement-strategies.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
+  "resource.api-compliance-best-practices.title": "Boas práticas de conformidade da API",
+  "resource.api-compliance-best-practices.description": "Garantir que as APIs cumprem conformidade legal, regulamentar e interna através de documentação, controlos e validações automatizadas.",
+  "resource.api-compliance-best-practices.outcomes": "Melhor compreensão dos princípios das boas práticas de conformidade da API",
   "resource.api-compliance-best-practices.outcomes.1": "Abordagem normalizada utilizando as Melhores Práticas de Conformidade da API",
   "resource.api-compliance-best-practices.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
-  "resource.api-compliance-best-practices.steps": "Documentar as medidas de conformidade e garantir que são comunicadas às partes interessadas e aos consumidores.",
+  "resource.api-compliance-best-practices.steps": "Documentar as medidas de conformidade e garantir que são comunicadas às partes interessadas e aos utilizadores.",
   "resource.api-compliance-best-practices.steps.1": "Implementar medidas para garantir que as APIs cumprem estes requisitos, incluindo encriptação de dados, controlos de acesso e pistas de auditoria.",
   "resource.api-compliance-best-practices.steps.2": "Utilizar listas de controlo, linters e ferramentas de teste para verificar a consistência e a conformidade com as normas.",
-  "resource.api-compliance-best-practices.tips": "Personalizar as Melhores Práticas de Conformidade da API para o seu domínio",
-  "resource.api-compliance-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
-  "resource.api-development-best-practices.title": "Melhores práticas de desenvolvimento de API",
-  "resource.api-development-best-practices.description": "Orientações de implementação para transformar um contrato de API validado em uma base de código de API consistente e sustentável, utilizando bibliotecas padrão, padrões reutilizáveis e fluxos de trabalho de desenvolvimento alinhados.",
-  "resource.api-development-best-practices.outcomes": "Melhor compreensão dos princípios das melhores práticas de desenvolvimento de API",
-  "resource.api-development-best-practices.outcomes.1": "Abordagem normalizada utilizando as melhores práticas de desenvolvimento de API",
+  "resource.api-compliance-best-practices.tips": "Personalizar as Melhores Práticas de Conformidade de API ao seu domínio",
+  "resource.api-compliance-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
+  "resource.api-development-best-practices.title": "Boas práticas de desenvolvimento de API",
+  "resource.api-development-best-practices.description": "Orientações de implementação para transformar um contrato de interface da API validado numa base de código de API consistente e sustentável, utilizando bibliotecas padrão, padrões reutilizáveis e fluxos de trabalho de desenvolvimento alinhados.",
+  "resource.api-development-best-practices.outcomes": "Melhor compreensão dos princípios das boas práticas de desenvolvimento de API",
+  "resource.api-development-best-practices.outcomes.1": "Abordagem normalizada utilizando as boas práticas de desenvolvimento de API",
   "resource.api-development-best-practices.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
-  "resource.api-development-best-practices.steps": "Aplique essas práticas ao contrato de API validado e ao plano de implementação antes do início da codificação.",
-  "resource.api-development-best-practices.steps.1": "Use frameworks, bibliotecas e padrões de codificação estabelecidos para implementar o contrato de forma consistente e sustentável.",
-  "resource.api-development-best-practices.tips": "Use este recurso como orientação de implementação e lente de revisão, em vez de como um artefato independente obrigatório", 
-  "resource.api-development-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
-  "resource.api-metrics-and-analytics.title": "Métricas e análises de API",
-  "resource.api-metrics-and-analytics.description": "Um recurso para definir, recolher e analisar o desempenho da API e os dados de utilização para alinhar os KPIs técnicos com os resultados comerciais.",
+  "resource.api-development-best-practices.steps": "Aplique essas práticas ao contrato de interface da API validado e ao plano de implementação antes do início da codificação.",
+  "resource.api-development-best-practices.steps.1": "Utilize frameworks, bibliotecas e padrões de codificação estabelecidos para implementar o contrato de forma consistente e sustentável.",
+  "resource.api-development-best-practices.tips": "Utilize este recurso como orientação de implementação e lente de revisão, em vez de como um artefato independente obrigatório",
+  "resource.api-development-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
+  "resource.api-metrics-and-analytics.title": "Métricas e análise de API",
+  "resource.api-metrics-and-analytics.description": "Um recurso para definir, recolher e analisar o desempenho da API e os dados de utilização para alinhar os KPIs técnicos com os resultados de negócio.",
   "resource.api-metrics-and-analytics.outcomes": "Melhor compreensão dos princípios de métrica e análise de API",
-  "resource.api-metrics-and-analytics.outcomes.1": "Abordagem padronizada usando métricas e análises de API",
+  "resource.api-metrics-and-analytics.outcomes.1": "Abordagem normalizada utilizando métricas e análise de API",
   "resource.api-metrics-and-analytics.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
-  "resource.api-metrics-and-analytics.steps": "Identificar indicadores-chave de desempenho (KPIs) para medir o sucesso da API em relação aos objectivos comerciais.",
-  "resource.api-metrics-and-analytics.steps.1": "Definir e monitorizar as métricas de desempenho (por exemplo, chamadas API, latência, taxas de erro) e as métricas de adoção (por exemplo, NPS).",
-  "resource.api-metrics-and-analytics.steps.2": "Monitorizar as iniciativas API para garantir o cumprimento das orientações operacionais e das práticas de governação",
-  "resource.api-metrics-and-analytics.tips": "Personalizar as métricas e análises da API para o seu domínio",
-  "resource.api-metrics-and-analytics.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
-  "resource.api-onboarding-best-practices.title": "Melhores práticas de integração de API",
-  "resource.api-onboarding-best-practices.description": "Práticas recomendadas para simplificar as jornadas de integração do consumidor da API com registo passo a passo, descoberta e orientação na primeira chamada.",
-  "resource.api-onboarding-best-practices.outcomes": "Melhor compreensão dos princípios das melhores práticas de integração de API",
-  "resource.api-onboarding-best-practices.outcomes.1": "Abordagem padronizada usando as práticas recomendadas de integração de API",
+  "resource.api-metrics-and-analytics.steps": "Identificar indicadores-chave de desempenho (KPIs) para medir o sucesso da API em relação aos objetivos de negócio.",
+  "resource.api-metrics-and-analytics.steps.1": "Definir e monitorizar as métricas de desempenho (por exemplo, chamadas APIs, latência, taxas de erro) e as métricas de adoção (por exemplo, NPS).",
+  "resource.api-metrics-and-analytics.steps.2": "Monitorizar as iniciativas APIs para garantir o cumprimento das orientações operacionais e das práticas de governação",
+  "resource.api-metrics-and-analytics.tips": "Personalizar as métricas e análise de API ao seu domínio",
+  "resource.api-metrics-and-analytics.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
+  "resource.api-onboarding-best-practices.title": "Boas práticas de integração de API",
+  "resource.api-onboarding-best-practices.description": "Boas práticas para simplificar as jornadas de integração do utilizador da API com registo passo a passo, descoberta e orientação na primeira chamada.",
+  "resource.api-onboarding-best-practices.outcomes": "Melhor compreensão dos princípios das boas práticas de integração de API",
+  "resource.api-onboarding-best-practices.outcomes.1": "Abordagem normalizada utilizando as boas práticas de integração de API",
   "resource.api-onboarding-best-practices.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
-  "resource.api-onboarding-best-practices.steps": "Definir o percurso do consumidor da API desde a descoberta até à resolução de problemas, identificando os principais pontos de contacto e os pontos problemáticos.",
-  "resource.api-onboarding-best-practices.steps.1": "Desenvolver processos de integração e recursos para ajudar os consumidores de API a compreender como utilizar as API de forma eficaz.",
-  "resource.api-onboarding-best-practices.steps.2": "Documentar a forma como os consumidores encontram e utilizam a API, incluindo processos de integração e registo.",
-  "resource.api-onboarding-best-practices.tips": "Personalizar as práticas recomendadas de integração da API para o seu domínio",
-  "resource.api-onboarding-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
+  "resource.api-onboarding-best-practices.steps": "Definir o percurso do utilizador da API desde a descoberta até à resolução de problemas, identificando os principais pontos de contacto e os pontos problemáticos.",
+  "resource.api-onboarding-best-practices.steps.1": "Desenvolver processos de integração e recursos para ajudar os utilizadores de API a compreender como utilizar as APIs de forma eficaz.",
+  "resource.api-onboarding-best-practices.steps.2": "Documentar a forma como os utilizadores encontram e utilizam a API, incluindo processos de integração e registo.",
+  "resource.api-onboarding-best-practices.tips": "Personalizar as boas práticas de integração de API ao seu domínio",
+  "resource.api-onboarding-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
   "resource.api-portfolio-management-guidelines.title": "Diretrizes de gestão da carteira API",
-  "resource.api-portfolio-management-guidelines.description": "Um guia para gerenciar estrategicamente o conjunto de APIs de uma organização - priorizando APIs, alocando recursos e monitorando o desempenho em todos os ciclos de vida.",
+  "resource.api-portfolio-management-guidelines.description": "Um guia para gerir estrategicamente o conjunto de APIs de uma organização - priorizando APIs, alocando recursos e monitorando o desempenho ao longo de todo o ciclo de vida.",
   "resource.api-portfolio-management-guidelines.outcomes": "Melhor compreensão dos princípios orientadores da gestão de carteiras API",
-  "resource.api-portfolio-management-guidelines.outcomes.1": "Abordagem padronizada usando as diretrizes de gerenciamento de portfólio da API",
+  "resource.api-portfolio-management-guidelines.outcomes.1": "Abordagem normalizada utilizando as diretrizes de gestão de portfólio da API",
   "resource.api-portfolio-management-guidelines.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
   "resource.api-portfolio-management-guidelines.steps": "Definir práticas de gestão da carteira que descrevam os processos de gestão da carteira de API, incluindo a definição de prioridades, a monitorização e a otimização.",
   "resource.api-portfolio-management-guidelines.steps.1": "Definir práticas de gestão orçamental e de recursos que descrevam os processos de gestão de orçamentos e recursos para iniciativas de API.",
-  "resource.api-portfolio-management-guidelines.steps.2": "Estabelecer critérios para avaliar e dar prioridade às dotações orçamentais com base no valor comercial, no impacto e no alinhamento com as iniciativas estratégicas.",
-  "resource.api-portfolio-management-guidelines.steps.3": "Monitorizar a carteira de APIs para garantir que as APIs estão a fornecer valor, a cumprir as expectativas de desempenho e a alinhar-se com os objectivos comerciais.",
-  "resource.api-portfolio-management-guidelines.tips": "Personalizar as Diretrizes de Gestão de Portfólio API para o seu domínio",
-  "resource.api-portfolio-management-guidelines.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
-  "resource.api-security-best-practices.title": "Melhores práticas de segurança da API",
+  "resource.api-portfolio-management-guidelines.steps.2": "Estabelecer critérios para avaliar e dar prioridade às dotações orçamentais com base no valor de negócio, no impacto e no alinhamento com as iniciativas estratégicas.",
+  "resource.api-portfolio-management-guidelines.steps.3": "Monitorizar a carteira de APIs para garantir que as APIs estão a fornecer valor, a cumprir as expectativas de desempenho e a alinhar-se com os objetivos de negócio.",
+  "resource.api-portfolio-management-guidelines.tips": "Personalizar as Diretrizes de Gestão de Portfólio API ao seu domínio",
+  "resource.api-portfolio-management-guidelines.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
+  "resource.api-security-best-practices.title": "Boas práticas de segurança da API",
   "resource.api-security-best-practices.description": "Um conjunto de controlos acionáveis para proteger APIs, incluindo autenticação, autorização, encriptação, limitação de taxas e verificações de conformidade ao nível do pipeline.",
-  "resource.api-security-best-practices.outcomes": "Melhor compreensão dos princípios das melhores práticas de segurança da API",
-  "resource.api-security-best-practices.outcomes.1": "Abordagem normalizada utilizando as melhores práticas de segurança da API",
+  "resource.api-security-best-practices.outcomes": "Melhor compreensão dos princípios das boas práticas de segurança da API",
+  "resource.api-security-best-practices.outcomes.1": "Abordagem normalizada utilizando as boas práticas de segurança da API",
   "resource.api-security-best-practices.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
   "resource.api-security-best-practices.steps": "Garantir que as APIs cumprem os requisitos de segurança e conformidade através de verificações e auditorias automatizadas.",
   "resource.api-security-best-practices.steps.1": "Implemente medidas de segurança como autenticação, autorização, encriptação e limitação de taxas para proteger as APIs de ameaças.",
   "resource.api-security-best-practices.steps.2": "Implementar verificações de segurança automatizadas e validações de conformidade no pipeline CI/CD para garantir que as APIs são seguras e compatíveis.",
-  "resource.api-security-best-practices.tips": "Personalize as práticas recomendadas de segurança da API para o seu domínio",
-  "resource.api-security-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
+  "resource.api-security-best-practices.tips": "Personalize as boas práticas de segurança de API ao seu domínio",
+  "resource.api-security-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
   "resource.api-team-structure-guidelines.title": "Diretrizes da estrutura da equipa API",
   "resource.api-team-structure-guidelines.description": "Orientação organizacional para a definição de funções e responsabilidades nas equipas de API para garantir clareza, colaboração e responsabilidade.",
   "resource.api-team-structure-guidelines.outcomes": "Melhor compreensão dos princípios orientadores da estrutura da equipa API",
   "resource.api-team-structure-guidelines.outcomes.1": "Abordagem normalizada utilizando as Diretrizes da Estrutura da Equipa API",
   "resource.api-team-structure-guidelines.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
   "resource.api-team-structure-guidelines.steps": "Definir estruturas de equipa e funções para equipas de API, incluindo proprietários de produtos de API, programadores, arquitectos e operações.",
-  "resource.api-team-structure-guidelines.tips": "Personalizar as Diretrizes da estrutura da equipa API para o seu domínio",
-  "resource.api-team-structure-guidelines.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
-  "resource.api-testing-best-practices.title": "Melhores práticas de teste de API",
+  "resource.api-team-structure-guidelines.tips": "Personalizar as Diretrizes da estrutura da equipa API ao seu domínio",
+  "resource.api-team-structure-guidelines.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
+  "resource.api-testing-best-practices.title": "Boas práticas de teste de API",
   "resource.api-testing-best-practices.description": "Diretrizes para a implementação de testes automatizados funcionais, de desempenho e de segurança ao longo do ciclo de vida da API.",
-  "resource.api-testing-best-practices.outcomes": "Melhor compreensão dos princípios das melhores práticas de teste de API",
-  "resource.api-testing-best-practices.outcomes.1": "Abordagem normalizada utilizando as melhores práticas de teste de API",
+  "resource.api-testing-best-practices.outcomes": "Melhor compreensão dos princípios das boas práticas de teste de API",
+  "resource.api-testing-best-practices.outcomes.1": "Abordagem normalizada utilizando as boas práticas de teste de API",
   "resource.api-testing-best-practices.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
-  "resource.api-testing-best-practices.steps": "Testar a funcionalidade, a segurança e o desempenho das API, utilizando ferramentas de teste automatizadas.",
-  "resource.api-testing-best-practices.steps.1": "Integrar testes funcionais e não funcionais no pipeline CI/CD para garantir que as APIs cumprem as normas de qualidade.",
+  "resource.api-testing-best-practices.steps": "Testar a funcionalidade, a segurança e o desempenho das APIs, utilizando ferramentas de teste automatizadas.",
+  "resource.api-testing-best-practices.steps.1": "Integrar testes funcionais e não funcionais no pipeline CI/CD para garantir que as APIs cumprems normas de qualidade.",
   "resource.api-testing-best-practices.steps.2": "Utilizar ferramentas de teste automatizadas para validar a funcionalidade, a segurança e o desempenho da API.",
-  "resource.api-testing-best-practices.tips": "Personalize as práticas recomendadas de teste de API para o seu domínio",
-  "resource.api-testing-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
+  "resource.api-testing-best-practices.tips": "Personalize as boas práticas de teste de API ao seu domínio",
+  "resource.api-testing-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
   "resource.api-training-programs.title": "Programas de formação API",
   "resource.api-training-programs.description": "Um roteiro para melhorar as competências das equipas com percursos de aprendizagem estruturados em design, governação, desempenho e segurança de API.",
   "resource.api-training-programs.outcomes": "Melhor compreensão dos princípios dos programas de formação API",
-  "resource.api-training-programs.outcomes.1": "Abordagem padronizada utilizando Programas de Formação API",
+  "resource.api-training-programs.outcomes.1": "Abordagem normalizada utilizando Programas de Formação API",
   "resource.api-training-programs.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
   "resource.api-training-programs.steps": "Identificar as principais competências e áreas de conhecimento da API que precisam de ser melhoradas, como a conceção, a segurança e o desempenho da API.",
   "resource.api-training-programs.steps.1": "Incentivar a aprendizagem contínua através de cursos em linha, certificações e envolvimento da comunidade.",
-  "resource.api-training-programs.steps.2": "Fornecer formação e recursos para ajudar as equipas a adotar uma mentalidade de prioridade à API e a compreender as vantagens das API.",
+  "resource.api-training-programs.steps.2": "Fornecer formação e recursos para ajudar as equipas a adotar uma mentalidade de prioridade à API e a compreender as vantagens das APIs.",
   "resource.api-training-programs.steps.3": "Fornecer programas de formação, workshops e recursos para ajudar as equipas a melhorar as suas competências e conhecimentos em matéria de API.",
-  "resource.api-training-programs.tips": "Personalizar os programas de formação API para o seu domínio",
-  "resource.api-training-programs.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
-  "resource.api-versioning-best-practices.title": "Práticas recomendadas de controle de versão da API",
-  "resource.api-versioning-best-practices.description": "Estratégias para introduzir, manter e retirar versões de API, preservando a compatibilidade com versões anteriores e a confiança dos consumidores.",
-  "resource.api-versioning-best-practices.outcomes": "Melhor compreensão dos princípios das melhores práticas de controlo de versões da API",
-  "resource.api-versioning-best-practices.outcomes.1": "Abordagem padronizada usando as práticas recomendadas de controle de versão da API",
+  "resource.api-training-programs.tips": "Personalizar os programas de formação API ao seu domínio",
+  "resource.api-training-programs.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
+  "resource.api-versioning-best-practices.title": "Boas práticas de controlo de versões da API",
+  "resource.api-versioning-best-practices.description": "Estratégias para introduzir, manter e retirar versões de API, preservando a compatibilidade com versões anteriores e a confiança dos utilizadores.",
+  "resource.api-versioning-best-practices.outcomes": "Melhor compreensão dos princípios das boas práticas de controlo de versões da API",
+  "resource.api-versioning-best-practices.outcomes.1": "Abordagem normalizada utilizando as boas práticas de controlo de versões da API",
   "resource.api-versioning-best-practices.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
-  "resource.api-versioning-best-practices.steps": "Definir estratégias de controlo de versões para as API para gerir as alterações e garantir a compatibilidade com as versões anteriores.",
-  "resource.api-versioning-best-practices.tips": "Personalizar as práticas recomendadas de controle de versão da API para o seu domínio",
-  "resource.api-versioning-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
+  "resource.api-versioning-best-practices.steps": "Definir estratégias de controlo de versões para as APIs para gerir as alterações e garantir a compatibilidade com as versões anteriores.",
+  "resource.api-versioning-best-practices.tips": "Personalizar as boas práticas de controlo de versões de API ao seu domínio",
+  "resource.api-versioning-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
   "resource.apiops-CI-CD-for-apis.title": "APIOps CI/CD para APIs",
-  "resource.apiops-CI-CD-for-apis.description": "Orientação de implantação que integra tarefas do ciclo de vida da API - design, teste, governança - em pipelines de integração e entrega contínuas.",
+  "resource.apiops-CI-CD-for-apis.description": "Orientação de disponibilização que integra tarefas do ciclo de vida da API - design, teste, governação - em pipelines de integração e entrega contínuas.",
   "resource.apiops-CI-CD-for-apis.outcomes": "Melhor compreensão dos princípios de CI/CD para APIs",
-  "resource.apiops-CI-CD-for-apis.outcomes.1": "Abordagem padronizada usando CI/CD para APIs",
+  "resource.apiops-CI-CD-for-apis.outcomes.1": "Abordagem normalizada utilizando CI/CD para APIs",
   "resource.apiops-CI-CD-for-apis.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
   "resource.apiops-CI-CD-for-apis.steps": "Utilizar pipelines CI/CD para automatizar os processos de construção, teste e implementação, garantindo uma qualidade e rastreabilidade consistentes.",
   "resource.apiops-CI-CD-for-apis.steps.1": "Integrar testes automatizados no pipeline CI/CD para garantir a validação contínua da qualidade da API.",
-  "resource.apiops-CI-CD-for-apis.steps.2": "Implementar estratégias de implantação (por exemplo, implantações blue-green, lançamentos canários) para minimizar os riscos durante os lançamentos de API.",
+  "resource.apiops-CI-CD-for-apis.steps.2": "Implementar estratégias de disponibilização (por exemplo, disponibilizações blue-green, lançamentos canários) para minimizar os riscos durante os lançamentos de API.",
   "resource.apiops-CI-CD-for-apis.steps.3": "Crie o hábito de analisar os indicadores e planear actividades de melhoria contínua.",
-  "resource.apiops-CI-CD-for-apis.tips": "Personalize as APIs CI/CD For para o seu domínio",
-  "resource.apiops-CI-CD-for-apis.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
+  "resource.apiops-CI-CD-for-apis.tips": "Personalize as APIs CI/CD For ao seu domínio",
+  "resource.apiops-CI-CD-for-apis.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
   "resource.competitor-analysis-template.title": "Modelo de análise da concorrência",
   "resource.competitor-analysis-template.description": "Uma folha de cálculo estruturada para comparar as suas ofertas de API com a concorrência, mapeando os pontos fortes, os pontos fracos e os diferenciadores de valor.",
   "resource.competitor-analysis-template.outcomes": "Melhor compreensão dos princípios do modelo de análise da concorrência",
   "resource.competitor-analysis-template.outcomes.1": "Abordagem normalizada utilizando o modelo de análise da concorrência",
   "resource.competitor-analysis-template.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
   "resource.competitor-analysis-template.steps": "Efetuar uma análise da concorrência para identificar os principais concorrentes e as suas ofertas de API.",
-  "resource.competitor-analysis-template.steps.1": "Analisar as API da concorrência para compreender os seus pontos fortes, fracos e pontos de venda únicos.",
-  "resource.competitor-analysis-template.tips": "Personalizar o modelo de análise da concorrência para o seu domínio",
-  "resource.competitor-analysis-template.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
+  "resource.competitor-analysis-template.steps.1": "Analisar as APIs da concorrência para compreender os seus pontos fortes, fracos e pontos de venda únicos.",
+  "resource.competitor-analysis-template.tips": "Personalizar o modelo de análise da concorrência ao seu domínio",
+  "resource.competitor-analysis-template.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
   "resource.contract-first-design.title": "Primeira conceção do contrato",
   "resource.contract-first-design.description": "Uma diretriz que defende abordagens API-first utilizando contratos formais (por exemplo, OpenAPI) para alinhar as partes interessadas antes do desenvolvimento.",
   "resource.contract-first-design.outcomes": "Melhor compreensão dos princípios de conceção da primeira fase do contrato",
-  "resource.contract-first-design.outcomes.1": "Abordagem normalizada utilizando o Contract First Design",
+  "resource.contract-first-design.outcomes.1": "Abordagem normalizada utilizando a conceção orientada por contrato",
   "resource.contract-first-design.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
-  "resource.contract-first-design.steps": "Aplicar abordagens \"contract-first\" ou \"design-first\" para garantir que os contratos API são validados antes da implementação.",
-  "resource.contract-first-design.steps.1": "Definir contratos de API que descrevam as expectativas, responsabilidades e diretrizes de utilização para cada API.",
-  "resource.contract-first-design.steps.2": "Utilizar formatos normalizados (por exemplo, OpenAPI, AsyncAPI) para criar contratos de API legíveis por máquina que sejam fáceis de partilhar e validar.",
-  "resource.contract-first-design.tips": "Personalize o design do Contract First para o seu domínio",
-  "resource.contract-first-design.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
-  "resource.cross-functional-collaboration-best-practices.title": "Melhores práticas de colaboração interfuncional",
-  "resource.cross-functional-collaboration-best-practices.description": "Práticas para facilitar a comunicação e o alinhamento entre as equipas comerciais e técnicas ao planear ou fornecer APIs.",
-  "resource.cross-functional-collaboration-best-practices.outcomes": "Melhor compreensão dos princípios das melhores práticas de colaboração interfuncional",
-  "resource.cross-functional-collaboration-best-practices.outcomes.1": "Abordagem normalizada utilizando as melhores práticas de colaboração interfuncional",
+  "resource.contract-first-design.steps": "Aplicar abordagens \"contract-first\" ou \"design-first\" para garantir que os contratos de interface da API são validados antes da implementação.",
+  "resource.contract-first-design.steps.1": "Definir contratos de interface da API que descrevam as expectativas, responsabilidades e diretrizes de utilização para cada API.",
+  "resource.contract-first-design.steps.2": "Utilizar formatos normalizados (por exemplo, OpenAPI, AsyncAPI) para criar contratos de interface da API legíveis por máquina que sejam fáceis de partilhar e validar.",
+  "resource.contract-first-design.tips": "Personalize a conceção do Contract First ao seu domínio",
+  "resource.contract-first-design.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
+  "resource.cross-functional-collaboration-best-practices.title": "Boas práticas de colaboração interfuncional",
+  "resource.cross-functional-collaboration-best-practices.description": "Práticas para facilitar a comunicação e o alinhamento entre as equipas de negócio e técnicas ao planear ou fornecer APIs.",
+  "resource.cross-functional-collaboration-best-practices.outcomes": "Melhor compreensão dos princípios das boas práticas de colaboração interfuncional",
+  "resource.cross-functional-collaboration-best-practices.outcomes.1": "Abordagem normalizada utilizando as boas práticas de colaboração interfuncional",
   "resource.cross-functional-collaboration-best-practices.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
-  "resource.cross-functional-collaboration-best-practices.steps": "Incentivar a colaboração multifuncional entre equipas de API, unidades empresariais e partes interessadas para alinhar as iniciativas de API com os objectivos empresariais.",
-  "resource.cross-functional-collaboration-best-practices.tips": "Personalize as Melhores Práticas de Colaboração Interfuncional para o seu domínio",
-  "resource.cross-functional-collaboration-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
+  "resource.cross-functional-collaboration-best-practices.steps": "Incentivar a colaboração multifuncional entre equipas de API, unidades empresariais e partes interessadas para alinhar as iniciativas de API com os objetivos empresariais.",
+  "resource.cross-functional-collaboration-best-practices.tips": "Personalize as Melhores Práticas de Colaboração Interfuncional ao seu domínio",
+  "resource.cross-functional-collaboration-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
   "resource.data-privacy-guidelines.title": "Diretrizes de privacidade de dados",
   "resource.data-privacy-guidelines.description": "Considerações de design para garantir que as APIs cumprem os regulamentos de proteção de dados, como o RGPD, através de anonimização e controlos de acesso.",
   "resource.data-privacy-guidelines.outcomes": "Melhor compreensão dos princípios das diretrizes relativas à privacidade dos dados",
   "resource.data-privacy-guidelines.outcomes.1": "Abordagem normalizada utilizando as Diretrizes de Privacidade de Dados",
   "resource.data-privacy-guidelines.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
   "resource.data-privacy-guidelines.steps": "Garantir a privacidade dos dados dos utilizadores através da implementação de medidas de proteção de dados, como a anonimização e os controlos de acesso.",
-  "resource.data-privacy-guidelines.tips": "Personalizar as Diretrizes de Privacidade de Dados para o seu domínio",
-  "resource.data-privacy-guidelines.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
-  "resource.domain-canvas.title": "Domain Canvas",
+  "resource.data-privacy-guidelines.tips": "Personalizar as Diretrizes de Privacidade de Dados ao seu domínio",
+  "resource.data-privacy-guidelines.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
+  "resource.domain-canvas.title": "Canvas de Domínio",
   "resource.domain-canvas.description": "Uma ferramenta de modelação para definir e comunicar as principais entidades e relações no seu domínio, assegurando a consistência semântica entre APIs.",
   "resource.domain-canvas.outcomes": "Melhor compreensão dos princípios do domínio canvas",
-  "resource.domain-canvas.outcomes.1": "Abordagem normalizada utilizando o Domain Canvas",
+  "resource.domain-canvas.outcomes.1": "Abordagem normalizada utilizando o Canvas de Domínio",
   "resource.domain-canvas.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
   "resource.domain-canvas.steps": "Definir entidades principais, os seus atributos e relações para criar um entendimento concetual partilhado entre APIs.",
-  "resource.domain-canvas.tips": "Personalizar o Canvas do domínio para o seu domínio",
-  "resource.domain-canvas.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
+  "resource.domain-canvas.tips": "Personalizar o Canvas de Domínio ao seu domínio",
+  "resource.domain-canvas.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
   "resource.ecosystem-vision-template.title": "Modelo de visão do ecossistema",
   "resource.ecosystem-vision-template.description": "Uma ferramenta de planeamento estratégico para definir o ecossistema API, incluindo parceiros-alvo, cadeias de valor e oportunidades de integração.",
   "resource.ecosystem-vision-template.outcomes": "Melhor compreensão dos princípios do modelo de visão do ecossistema",
-  "resource.ecosystem-vision-template.outcomes.1": "Abordagem padronizada usando o Modelo de Visão do Ecossistema",
+  "resource.ecosystem-vision-template.outcomes.1": "Abordagem normalizada utilizando o Modelo de Visão do Ecossistema",
   "resource.ecosystem-vision-template.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
-  "resource.ecosystem-vision-template.steps": "Realizar estudos de mercado para identificar tendências, oportunidades e ameaças no panorama das API.",
+  "resource.ecosystem-vision-template.steps": "Realizar estudos de mercado para identificar tendências, oportunidades e ameaças no panorama das APIs.",
   "resource.ecosystem-vision-template.steps.1": "Identificar os principais parceiros e intervenientes do ecosistema que irão beneficiar ou contribuir para o ecosistema.",
-  "resource.ecosystem-vision-template.steps.2": "Identifique as lacunas no mercado que as suas API podem preencher, com base nas ofertas da concorrência.",
+  "resource.ecosystem-vision-template.steps.2": "Identifique as lacunas no mercado que as suas APIs podem preencher, com base nas ofertas da concorrência.",
   "resource.ecosystem-vision-template.steps.3": "Identifique potenciais parceiros cujas APIs possam melhorar as suas capacidades de API e a sua proposta de valor.",
-  "resource.ecosystem-vision-template.steps.4": "Desenvolva uma estratégia de diferenciação que destaque as caraterísticas e benefícios únicos das suas APIs.",
+  "resource.ecosystem-vision-template.steps.4": "Desenvolva uma estratégia de diferenciação que destaque as características e benefícios únicos das suas APIs.",
   "resource.ecosystem-vision-template.steps.5": "Defina a visão do ecossistema para as suas APIs, incluindo a forma como estas irão interagir com outros sistemas e plataformas.",
   "resource.ecosystem-vision-template.steps.6": "Conceber APIs para permitir uma integração e colaboração perfeitas no ecossistema.",
-  "resource.ecosystem-vision-template.tips": "Personalizar o modelo de visão do ecossistema para o seu domínio",
-  "resource.ecosystem-vision-template.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
-  "resource.industry-standards-and-best-practices.title": "Normas e melhores práticas do sector",
-  "resource.industry-standards-and-best-practices.description": "Um recurso de referência para alinhar o design e a operação da API com estruturas e especificações amplamente reconhecidas do sector.",
-  "resource.industry-standards-and-best-practices.outcomes": "Melhor compreensão das normas do sector e dos princípios das melhores práticas",
-  "resource.industry-standards-and-best-practices.outcomes.1": "Abordagem normalizada utilizando as normas e as melhores práticas do sector",
+  "resource.ecosystem-vision-template.tips": "Personalizar o modelo de visão do ecossistema ao seu domínio",
+  "resource.ecosystem-vision-template.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
+  "resource.industry-standards-and-best-practices.title": "Normas e boas práticas do sector",
+  "resource.industry-standards-and-best-practices.description": "Um recurso de referência para alinhar a conceção e a operação da API com estruturas e especificações amplamente reconhecidas do sector.",
+  "resource.industry-standards-and-best-practices.outcomes": "Melhor compreensão das normas do sector e dos princípios das boas práticas",
+  "resource.industry-standards-and-best-practices.outcomes.1": "Abordagem normalizada utilizando as normas e as boas práticas do sector",
   "resource.industry-standards-and-best-practices.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
-  "resource.industry-standards-and-best-practices.steps": "Identificar as normas e as melhores práticas do sector para garantir que as API são competitivas e estão em conformidade.",
-  "resource.industry-standards-and-best-practices.tips": "Personalize os padrões e as melhores práticas da indústria para o seu domínio",
-  "resource.industry-standards-and-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
+  "resource.industry-standards-and-best-practices.steps": "Identificar as normas e as boas práticas do sector para garantir que as APIs são competitivas e estão em conformidade.",
+  "resource.industry-standards-and-best-practices.tips": "Personalize os padrões e as boas práticas da indústria ao seu domínio",
+  "resource.industry-standards-and-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
   "resource.partner-integration-guidelines.title": "Diretrizes de integração de parceiros",
   "resource.partner-integration-guidelines.description": "Listas de verificação de integração e padrões de comunicação para gerir os aspectos técnicos e legais das relações com APIs de terceiros.",
   "resource.partner-integration-guidelines.outcomes": "Melhor compreensão dos princípios das diretrizes de integração de parceiros",
@@ -191,26 +191,26 @@
   "resource.partner-integration-guidelines.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
   "resource.partner-integration-guidelines.steps": "Estabelecer processos de integração e orientações para colaborar com os parceiros, incluindo a integração técnica, a partilha de dados e o apoio.",
   "resource.partner-integration-guidelines.steps.1": "Monitorize o desempenho e a conformidade da API do parceiro para garantir a fiabilidade e o alinhamento com a sua estratégia de API.",
-  "resource.partner-integration-guidelines.tips": "Personalizar as Diretrizes de Integração de Parceiros para o seu domínio",
-  "resource.partner-integration-guidelines.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
-  "resource.role-communication-best-practices.title": "Melhores práticas de comunicação de funções",
+  "resource.partner-integration-guidelines.tips": "Personalizar as Diretrizes de Integração de Parceiros ao seu domínio",
+  "resource.partner-integration-guidelines.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
+  "resource.role-communication-best-practices.title": "Boas práticas de comunicação de funções",
   "resource.role-communication-best-practices.description": "Ferramentas para definir e documentar quem é responsável por quê nas iniciativas de API, garantindo que as transferências e a responsabilidade sejam claras.",
-  "resource.role-communication-best-practices.outcomes": "Melhor compreensão dos princípios das melhores práticas de comunicação de funções",
-  "resource.role-communication-best-practices.outcomes.1": "Abordagem normalizada utilizando as melhores práticas de comunicação de funções",
+  "resource.role-communication-best-practices.outcomes": "Melhor compreensão dos princípios das boas práticas de comunicação de funções",
+  "resource.role-communication-best-practices.outcomes.1": "Abordagem normalizada utilizando as boas práticas de comunicação de funções",
   "resource.role-communication-best-practices.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
   "resource.role-communication-best-practices.steps": "Estabelecer responsabilidades claras para cada função, incluindo a conceção, o desenvolvimento, os testes e as operações da API.",
   "resource.role-communication-best-practices.steps.1": "Assegurar que as funções e responsabilidades são comunicadas a todos os membros da equipa e partes interessadas para garantir o alinhamento.",
-  "resource.role-communication-best-practices.tips": "Personalizar as Melhores Práticas de Comunicação de Funções para o seu domínio",
-  "resource.role-communication-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
-  "resource.scalable-infrastructure-best-practices.title": "Melhores práticas de infraestrutura escalável",
-  "resource.scalable-infrastructure-best-practices.description": "Orientação arquitetónica para garantir que as API são implementadas em infra-estruturas que podem lidar elasticamente com picos de utilização e crescimento.",
-  "resource.scalable-infrastructure-best-practices.outcomes": "Melhor compreensão dos princípios das melhores práticas de infra-estruturas escaláveis",
+  "resource.role-communication-best-practices.tips": "Personalizar as Melhores Práticas de Comunicação de Funções ao seu domínio",
+  "resource.role-communication-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
+  "resource.scalable-infrastructure-best-practices.title": "Boas práticas de infraestrutura escalável",
+  "resource.scalable-infrastructure-best-practices.description": "Orientação arquitetónica para garantir que as APIs são implementadas em infra-estruturas que podem lidar elasticamente com picos de utilização e crescimento.",
+  "resource.scalable-infrastructure-best-practices.outcomes": "Melhor compreensão dos princípios das boas práticas de infra-estruturas escaláveis",
   "resource.scalable-infrastructure-best-practices.outcomes.1": "Abordagem normalizada utilizando as Melhores Práticas de Infraestrutura Escalável",
   "resource.scalable-infrastructure-best-practices.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
   "resource.scalable-infrastructure-best-practices.steps": "Conceber a infraestrutura da API para ser escalável e resiliente, utilizando padrões e tecnologias nativos da nuvem.",
   "resource.scalable-infrastructure-best-practices.steps.1": "Monitorizar o desempenho e a capacidade da infraestrutura para garantir que esta consegue dar resposta à crescente procura.",
-  "resource.scalable-infrastructure-best-practices.tips": "Personalize as Melhores Práticas de Infraestrutura Escalável para o seu domínio",
-  "resource.scalable-infrastructure-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
+  "resource.scalable-infrastructure-best-practices.tips": "Personalize as Melhores Práticas de Infraestrutura Escalável ao seu domínio",
+  "resource.scalable-infrastructure-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
   "resource.service-agreement-template.title": "Modelo de contrato de serviço",
   "resource.service-agreement-template.description": "Um formato de acordo personalizável que define expectativas, SLAs, responsabilidades e termos de acesso para o consumo de API.",
   "resource.service-agreement-template.outcomes": "Melhor compreensão dos princípios do modelo de contrato de prestação de serviços",
@@ -219,50 +219,50 @@
   "resource.service-agreement-template.steps": "Defina acordos de serviço que descrevam as expectativas, os níveis de serviço e as responsabilidades de cada API.",
   "resource.service-agreement-template.steps.1": "Utilize formatos normalizados para criar contratos de serviço legíveis por máquina que sejam fáceis de partilhar e validar.",
   "resource.service-agreement-template.steps.2": "Assegurar que os acordos de serviço são revistos e aprovados pelas partes interessadas para garantir o alinhamento e a clareza.",
-  "resource.service-agreement-template.tips": "Personalizar o modelo de contrato de serviço para o seu domínio",
-  "resource.service-agreement-template.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
-  "resource.stakeholder-engagement-best-practices.title": "Melhores práticas de envolvimento das partes interessadas",
-  "resource.stakeholder-engagement-best-practices.description": "Tácticas de envolvimento para alinhar as partes interessadas internas e externas em torno dos objectivos, valor e governação partilhados da API.",
-  "resource.stakeholder-engagement-best-practices.outcomes": "Melhor compreensão dos princípios das melhores práticas de envolvimento das partes interessadas",
-  "resource.stakeholder-engagement-best-practices.outcomes.1": "Abordagem padronizada usando as Melhores Práticas de Envolvimento das Partes Interessadas",
+  "resource.service-agreement-template.tips": "Personalizar o modelo de contrato de serviço ao seu domínio",
+  "resource.service-agreement-template.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
+  "resource.stakeholder-engagement-best-practices.title": "Boas práticas de envolvimento das partes interessadas",
+  "resource.stakeholder-engagement-best-practices.description": "Tácticas de envolvimento para alinhar as partes interessadas internas e externas em torno dos objetivos, valor e governação partilhados da API.",
+  "resource.stakeholder-engagement-best-practices.outcomes": "Melhor compreensão dos princípios das boas práticas de envolvimento das partes interessadas",
+  "resource.stakeholder-engagement-best-practices.outcomes.1": "Abordagem normalizada utilizando as Melhores Práticas de Envolvimento das Partes Interessadas",
   "resource.stakeholder-engagement-best-practices.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
   "resource.stakeholder-engagement-best-practices.steps": "Envolver as partes interessadas para garantir o alinhamento e o apoio às iniciativas da API.",
-  "resource.stakeholder-engagement-best-practices.tips": "Personalize as Melhores Práticas de Envolvimento das Partes Interessadas para o seu domínio",
-  "resource.stakeholder-engagement-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
+  "resource.stakeholder-engagement-best-practices.tips": "Personalize as Melhores Práticas de Envolvimento das Partes Interessadas ao seu domínio",
+  "resource.stakeholder-engagement-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
   "resource.test-automation-frameworks.title": "Estruturas de automatização de testes",
   "resource.test-automation-frameworks.description": "Ferramentas e padrões recomendados para automatizar testes de contrato, regressão e integração de API em vários ambientes.",
   "resource.test-automation-frameworks.outcomes": "Melhor compreensão dos princípios das estruturas de automatização de testes",
   "resource.test-automation-frameworks.outcomes.1": "Abordagem normalizada utilizando estruturas de automatização de testes",
   "resource.test-automation-frameworks.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
   "resource.test-automation-frameworks.steps": "Implementar estruturas de automatização de testes que apoiem os testes de contrato, os testes de integração e os testes de ponta a ponta.",
-  "resource.test-automation-frameworks.tips": "Personalizar as estruturas de automatização de testes para o seu domínio",
-  "resource.test-automation-frameworks.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
-  "resource.vendor-management-best-practices.title": "Melhores práticas de gestão de fornecedores",
+  "resource.test-automation-frameworks.tips": "Personalizar as estruturas de automatização de testes ao seu domínio",
+  "resource.test-automation-frameworks.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
+  "resource.vendor-management-best-practices.title": "Boas práticas de gestão de fornecedores",
   "resource.vendor-management-best-practices.description": "Estrutura para avaliar e gerir fornecedores externos de API e integrações de terceiros com base no risco, desempenho e conformidade.",
-  "resource.vendor-management-best-practices.outcomes": "Melhor compreensão dos princípios das melhores práticas de gestão de fornecedores",
-  "resource.vendor-management-best-practices.outcomes.1": "Abordagem normalizada utilizando as melhores práticas de gestão de fornecedores",
+  "resource.vendor-management-best-practices.outcomes": "Melhor compreensão dos princípios das boas práticas de gestão de fornecedores",
+  "resource.vendor-management-best-practices.outcomes.1": "Abordagem normalizada utilizando as boas práticas de gestão de fornecedores",
   "resource.vendor-management-best-practices.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
   "resource.vendor-management-best-practices.steps": "Estabelecer processos de gestão de fornecedores para avaliar, integrar e monitorizar fornecedores de API de terceiros.",
-  "resource.vendor-management-best-practices.steps.1": "Definir critérios para avaliar as API dos fornecedores, incluindo fiabilidade, segurança e conformidade.",
-  "resource.vendor-management-best-practices.tips": "Personalize as Melhores Práticas de Gestão de Fornecedores para o seu domínio",
-  "resource.vendor-management-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
+  "resource.vendor-management-best-practices.steps.1": "Definir critérios para avaliar as APIs dos fornecedores, incluindo fiabilidade, segurança e conformidade.",
+  "resource.vendor-management-best-practices.tips": "Personalize as Melhores Práticas de Gestão de Fornecedores ao seu domínio",
+  "resource.vendor-management-best-practices.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
   "resource.api-audit-checklist.title": "Lista de verificação de auditoria da API",
-  "resource.api-audit-checklist.description": "Uma lista de verificação baseada no ciclo de vida para verificar a prontidão da API em design, entrega, publicação e conformidade usando critérios de auditoria e evidências definidos.",
+  "resource.api-audit-checklist.description": "Uma lista de verificação baseada no ciclo de vida para verificar a prontidão da API em design, entrega, publicação e conformidade utilizando critérios de auditoria e evidências definidos.",
   "resource.api-audit-checklist.outcomes": "Melhor compreensão dos princípios da lista de controlo de auditoria da API",
-  "resource.api-audit-checklist.outcomes.1": "Abordagem padronizada usando a lista de verificação de auditoria da API",
+  "resource.api-audit-checklist.outcomes.1": "Abordagem normalizada utilizando a lista de verificação de auditoria da API",
   "resource.api-audit-checklist.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
   "resource.api-audit-checklist.steps": "Utilize a lista de verificação de auditoria da API para garantir que a conceção da API cumpre os requisitos funcionais e não funcionais, incluindo segurança, desempenho e conformidade.",
-  "resource.api-audit-checklist.steps.1": "Realize auditorias para avaliar a cobertura do ciclo de vida e verificar se a API atende aos padrões de negócios, design e operacionais.",
+  "resource.api-audit-checklist.steps.1": "Realize auditorias para avaliar a cobertura do ciclo de vida e verificar se a API satisfaz os padrões de negócio, conceção e operacionais.",
   "resource.api-audit-checklist.steps.2": "Certifique-se de que a documentação, os modelos de segurança, a configuração do gateway e os requisitos legais estejam claramente definidos, validados e comprovados por evidências.",
-  "resource.api-audit-checklist.tips": "Cada item de auditoria vincula o trabalho do ciclo de vida (etapas), as diretrizes regulatórias e as evidências de apoio para fornecer uma visão clara da prontidão da API.",
-  "resource.api-audit-checklist.tips.1": "Use a Lista de Verificação de Auditoria de API de forma colaborativa entre as funções de negócios e tecnologia",
-  "resource.api-business-model-canvas.title": "API Business Model Canvas",
-  "resource.api-business-model-canvas.description": "Avaliar estrategicamente a viabilidade do negócio de API, mapeando propostas de valor, segmentos de consumidores e recursos-chave.",
+  "resource.api-audit-checklist.tips": "Cada item de auditoria associa o trabalho do ciclo de vida (etapas), as diretrizes regulatórias e as evidências de apoio para fornecer uma visão clara da prontidão da API.",
+  "resource.api-audit-checklist.tips.1": "Utilize a Lista de Verificação de Auditoria de API de forma colaborativa entre as funções de negócios e tecnologia",
+  "resource.api-business-model-canvas.title": "Canvas do Modelo de Negócio da API",
+  "resource.api-business-model-canvas.description": "Avaliar estrategicamente a viabilidade do negócio de API, mapeando propostas de valor, segmentos de utilizadores e recursos-chave.",
   "resource.api-business-model-canvas.outcomes": "Estratégia comercial clara para APIs",
   "resource.api-business-model-canvas.outcomes.1": "Identificação dos principais recursos e parceiros",
-  "resource.api-business-model-canvas.outcomes.2": "Alinhamento das caraterísticas da API com os objectivos comerciais",
+  "resource.api-business-model-canvas.outcomes.2": "Alinhamento das características da API com os objetivos de negócio",
   "resource.api-business-model-canvas.steps": "Resumir a proposta de valor da API",
-  "resource.api-business-model-canvas.steps.1": "Definir segmentos de consumidores",
+  "resource.api-business-model-canvas.steps.1": "Definir segmentos de utilizadores",
   "resource.api-business-model-canvas.steps.2": "Identificar estratégias de relações com os promotores",
   "resource.api-business-model-canvas.steps.3": "Mapear os canais de distribuição",
   "resource.api-business-model-canvas.steps.4": "documentar os principais recursos e actividades",
@@ -272,31 +272,31 @@
   "resource.api-business-model-canvas.tips.1": "Utilizar métricas como custo vs. benefício para dar prioridade às oportunidades",
   "resource.api-business-model-canvas.tips.2": "Validar os resultados com as principais partes interessadas",
   "resource.api-design-principles.title": "Princípios de conceção da API",
-  "resource.api-design-principles.description": "Um guia conciso sobre usabilidade, descobribilidade e consistência da API, baseado em regras de design compartilhadas e nas necessidades reais dos consumidores.",
+  "resource.api-design-principles.description": "Um guia conciso sobre usabilidade, descobribilidade e consistência da API, baseado em regras de design partilhadas e nas necessidades reais dos utilizadores.",
   "resource.api-design-principles.outcomes": "Melhor compreensão dos princípios de conceção das API",
   "resource.api-design-principles.outcomes.1": "Abordagem normalizada utilizando os princípios de conceção da API",
   "resource.api-design-principles.outcomes.2": "Melhoria da implementação das práticas de API relacionadas",
-  "resource.api-design-principles.steps": "**Design que coloca o consumidor em primeiro lugar:** iniciar cada ciclo de APIOps recolhendo os objectivos do utilizador e os termos do domínio para que as APIs resolvam problemas reais.",
-  "resource.api-design-principles.steps.1": "**Nomeação e comportamento consistentes:** aplicar convenções partilhadas para recursos, erros e formatos para tornar as API previsíveis.",
+  "resource.api-design-principles.steps": "**Conceção que coloca o utilizador em primeiro lugar:** iniciar cada ciclo de APIOps recolhendo os objetivos do utilizador e os termos do domínio para que as APIs resolvam problemas reais.",
+  "resource.api-design-principles.steps.1": "**Nomeação e comportamento consistentes:** aplicar convenções partilhadas para recursos, erros e formatos para tornar as APIs previsíveis.",
   "resource.api-design-principles.steps.2": "**Orientado para contratos:** capturar a interface com OpenAPI ou AsyncAPI antes da codificação para alinhar as equipas e permitir a automatização.",
   "resource.api-design-principles.steps.3": "**Usabilidade e facilidade de descoberta:** fornecer documentação e exemplos claros para que os programadores compreendam rapidamente como utilizar a API.",
-  "resource.api-design-principles.steps.4": "**Iterar com segurança:** desenvolver os projectos em pequenos incrementos, com versões, para que as alterações não perturbem os consumidores existentes.",
-  "resource.api-design-principles.tips": "Personalizar os princípios de conceção da API para o seu domínio",
-  "resource.api-design-principles.tips.1": "Utilize-o de forma colaborativa entre as funções comerciais e tecnológicas",
-  "resource.api-value-proposition-canvas.title": "API Value Proposition Canvas",
+  "resource.api-design-principles.steps.4": "**Iterar com segurança:** desenvolver os projetos em pequenos incrementos, com versões, para que as alterações não perturbem os utilizadores existentes.",
+  "resource.api-design-principles.tips": "Personalizar os princípios de conceção de API ao seu domínio",
+  "resource.api-design-principles.tips.1": "Utilize-o de forma colaborativa entre as funções de negócio e tecnológicas",
+  "resource.api-value-proposition-canvas.title": "Canvas da Proposta de Valor da API",
   "resource.api-value-proposition-canvas.description": "Alinhar as funcionalidades da API com as necessidades dos utilizadores, mapeando tarefas, problemas e ganhos para os produtos da API.",
   "resource.api-value-proposition-canvas.outcomes": "Desenvolvimento de funcionalidades específicas",
   "resource.api-value-proposition-canvas.outcomes.1": "Alinhamento com as necessidades dos utilizadores",
-  "resource.api-value-proposition-canvas.outcomes.2": "Melhoria da satisfação do consumidor da API",
+  "resource.api-value-proposition-canvas.outcomes.2": "Melhoria da satisfação do utilizador da API",
   "resource.api-value-proposition-canvas.steps": "Listar as tarefas do percurso do utilizador",
-  "resource.api-value-proposition-canvas.steps.1": "Identificar as caraterísticas que proporcionam os ganhos esperados",
-  "resource.api-value-proposition-canvas.steps.2": "Definir caraterísticas para enfrentar os desafios",
-  "resource.api-value-proposition-canvas.steps.3": "Mapear caraterísticas para produtos API",
-  "resource.api-value-proposition-canvas.tips": "Utilizar os dados do Customer Journey Canvas",
-  "resource.api-value-proposition-canvas.tips.1": "Destaque para as caraterísticas que aliviam as dores ou aumentam os ganhos",
-  "resource.api-value-proposition-canvas.tips.2": "Validar as caraterísticas com os consumidores da API para garantir o alinhamento",
-  "resource.business-impact-canvas.title": "Business Impact Canvas",
-  "resource.business-impact-canvas.description": "Conceber uma arquitetura de plataforma API escalável e segura que satisfaça os requisitos comerciais e técnicos.",
+  "resource.api-value-proposition-canvas.steps.1": "Identificar as características que proporcionam os ganhos esperados",
+  "resource.api-value-proposition-canvas.steps.2": "Definir características para enfrentar os desafios",
+  "resource.api-value-proposition-canvas.steps.3": "Mapear características para produtos API",
+  "resource.api-value-proposition-canvas.tips": "Utilizar os dados do Canvas do Percurso do Cliente",
+  "resource.api-value-proposition-canvas.tips.1": "Destaque para as características que aliviam as dores ou aumentam os ganhos",
+  "resource.api-value-proposition-canvas.tips.2": "Validar as características com os utilizadores da API para garantir o alinhamento",
+  "resource.business-impact-canvas.title": "Canvas de Impacto no Negócio",
+  "resource.business-impact-canvas.description": "Conceber uma arquitetura de plataforma API escalável e segura que satisfaça os requisitos de negócio e técnicos.",
   "resource.business-impact-canvas.outcomes": "Infraestrutura API escalável",
   "resource.business-impact-canvas.outcomes.1": "Segurança e conformidade melhoradas",
   "resource.business-impact-canvas.outcomes.2": "Desempenho melhorado da API",
@@ -309,8 +309,8 @@
   "resource.business-impact-canvas.tips": "Envolver os arquitectos e os promotores no processo de conceção",
   "resource.business-impact-canvas.tips.1": "Utilizar incidentes anteriores para identificar potenciais riscos",
   "resource.business-impact-canvas.tips.2": "Dar prioridade às APIs críticas com o maior impacto comercial",
-  "resource.capacity-canvas.title": "Capacity Canvas",
-  "resource.capacity-canvas.description": "Planear a capacidade da API para satisfazer as exigências comerciais actuais e futuras, garantindo a escalabilidade e o desempenho.",
+  "resource.capacity-canvas.title": "Canvas de Capacidade",
+  "resource.capacity-canvas.description": "Planear a capacidade da API para satisfazer as exigências de negócio actuais e futuras, garantindo a escalabilidade e o desempenho.",
   "resource.capacity-canvas.outcomes": "Alinhamento da capacidade da API com os volumes de negócios",
   "resource.capacity-canvas.outcomes.1": "Preparado para as futuras tendências de consumo",
   "resource.capacity-canvas.outcomes.2": "Estratégias definidas de armazenamento em cache e limitação de taxa",
@@ -322,7 +322,7 @@
   "resource.capacity-canvas.tips": "Utilizar a análise para prever tendências de crescimento",
   "resource.capacity-canvas.tips.1": "Definir cenários de picos de utilização",
   "resource.capacity-canvas.tips.2": "Incluir testes de escalabilidade na fase de planeamento",
-  "resource.customer-journey-canvas.title": "Customer Journey Canvas",
+  "resource.customer-journey-canvas.title": "Canvas do Percurso do Cliente",
   "resource.customer-journey-canvas.description": "Mapear os percursos dos clientes para identificar necessidades e pontos problemáticos, melhorando a conceção da API e a experiência do utilizador.",
   "resource.customer-journey-canvas.outcomes": "Melhoria da compreensão do cliente",
   "resource.customer-journey-canvas.outcomes.1": "Conceção melhorada da API",
@@ -337,24 +337,24 @@
   "resource.customer-journey-canvas.steps.7": "Definir interações API para cada etapa",
   "resource.customer-journey-canvas.tips": "Iterar com o contributo da equipa para aperfeiçoar as etapas",
   "resource.customer-journey-canvas.tips.1": "Utilize os resultados deste quadro para informar outros quadros, como o quadro de proposta de valor da API",
-  "resource.event-canvas.title": "Event Canvas",
+  "resource.event-canvas.title": "Canvas de Eventos",
   "resource.event-canvas.description": "Conceber APIs orientadas para eventos, definindo eventos, accionadores e lógica de processamento.",
   "resource.event-canvas.outcomes": "Arquitetura orientada para eventos definida",
   "resource.event-canvas.outcomes.1": "Limpar os accionadores de eventos e a lógica de processamento",
   "resource.event-canvas.outcomes.2": "Melhoria da capacidade de resposta a alterações em tempo real",
   "resource.event-canvas.steps": "Identificar os principais eventos do sistema",
   "resource.event-canvas.steps.1": "Definir accionadores para cada evento",
-  "resource.event-canvas.steps.2": "Descrever a lógica de processamento backend para eventos",
+  "resource.event-canvas.steps.2": "Descrever a lógica de processamento back-end para eventos",
   "resource.event-canvas.steps.3": "Especificar os resultados ou reconhecimentos resultantes",
   "resource.event-canvas.tips": "Utilizar esquemas de eventos para normalizar os formatos de eventos",
   "resource.event-canvas.tips.1": "documentar fluxos e dependências de eventos",
   "resource.event-canvas.tips.2": "Validar o processamento de eventos com casos de teste",
-  "resource.graphql-canvas.title": "GraphQL Canvas",
+  "resource.graphql-canvas.title": "Canvas GraphQL",
   "resource.graphql-canvas.description": "Conceber APIs GraphQL definindo tipos, consultas, mutações e subscrições.",
   "resource.graphql-canvas.outcomes": "Conceção da API GraphQL estruturada",
   "resource.graphql-canvas.outcomes.1": "Tipos definidos e suas relações",
   "resource.graphql-canvas.outcomes.2": "Limpar consultas, mutações e subscrições",
-  "resource.graphql-canvas.steps": "Que problemas estão os consumidores de API a tentar resolver? De que dados necessitam?",
+  "resource.graphql-canvas.steps": "Que problemas estão os utilizadores de API a tentar resolver? De que dados necessitam?",
   "resource.graphql-canvas.steps.1": "Definir tipos GraphQL e seus atributos: Quais são os principais tipos expostos (por exemplo, utilizador, encomenda, produto)?",
   "resource.graphql-canvas.steps.2": "Mapear relações entre tipos: Como é que os tipos se relacionam uns com os outros em consultas aninhadas?",
   "resource.graphql-canvas.steps.3": "Especificar consultas para a recuperação de dados",
@@ -365,8 +365,8 @@
   "resource.graphql-canvas.tips": "Utilizar a introspeção para validar definições de tipos",
   "resource.graphql-canvas.tips.1": "documentar exemplos de consultas e mutações",
   "resource.graphql-canvas.tips.2": "Assegurar que os nomes dos tipos são descritivos e coerentes",
-  "resource.interaction-canvas.title": "Interaction Canvas",
-  "resource.interaction-canvas.description": "Definir interações API, fluxos de trabalho e respostas esperadas para garantir uma experiência consistente do consumidor API.",
+  "resource.interaction-canvas.title": "Canvas de Interação",
+  "resource.interaction-canvas.description": "Definir interações API, fluxos de trabalho e respostas esperadas para garantir uma experiência consistente do utilizador API.",
   "resource.interaction-canvas.outcomes": "Fluxos de trabalho de interação API claros",
   "resource.interaction-canvas.outcomes.1": "Entradas e saídas definidas para cada interação",
   "resource.interaction-canvas.outcomes.2": "Regras de validação consistentes em todas as interações",
@@ -378,21 +378,21 @@
   "resource.interaction-canvas.tips": "Comece com casos de utilização comuns antes de lidar com casos extremos",
   "resource.interaction-canvas.tips.1": "Simular interações com dados simulados para validar fluxos de trabalho",
   "resource.interaction-canvas.tips.2": "documentar as respostas esperadas para interações bem e mal sucedidas",
-  "resource.location-canvas.title": "Location Canvas",
-  "resource.location-canvas.description": "Mapeie as localizações dos fornecedores e consumidores de API para garantir a conformidade e o desempenho em todas as regiões.",
+  "resource.location-canvas.title": "Canvas de Localização",
+  "resource.location-canvas.description": "Mapeie as localizações dos fornecedores e utilizadores de API para garantir a conformidade e o desempenho em todas as regiões.",
   "resource.location-canvas.outcomes": "Conformidade com a regulamentação local",
   "resource.location-canvas.outcomes.1": "Desempenho optimizado da API em todas as regiões",
   "resource.location-canvas.outcomes.2": "Melhoria da compreensão das necessidades regionais",
   "resource.location-canvas.steps": "Mapa de localização dos fornecedores de API.",
-  "resource.location-canvas.steps.1": "Documentar a localização dos consumidores.",
+  "resource.location-canvas.steps.1": "Documentar a localização dos utilizadores.",
   "resource.location-canvas.steps.2": "Identificar os regulamentos aplicáveis.",
   "resource.location-canvas.steps.3": "Documentar onde os dados devem residir.",
-  "resource.location-canvas.steps.4": "Assegurar que as API estão acessíveis em todas as regiões da rede previstas.",
+  "resource.location-canvas.steps.4": "Assegurar que as APIs estão acessíveis em todas as regiões da rede previstas.",
   "resource.location-canvas.steps.5": "Validar o desempenho da rede em todas as regiões.",
   "resource.location-canvas.tips": "Colaborar com as equipas jurídicas e de conformidade",
   "resource.location-canvas.tips.1": "Validar o desempenho da rede nas principais regiões",
   "resource.location-canvas.tips.2": "Resolver proactivamente as restrições baseadas na localização",
-  "resource.rest-canvas.title": "REST Canvas",
+  "resource.rest-canvas.title": "Canvas REST",
   "resource.rest-canvas.description": "Conceber APIs utilizando os princípios RESTful, definindo recursos, verbos e exemplos de pedidos e respostas.",
   "resource.rest-canvas.outcomes": "Conceção consistente da API RESTful",
   "resource.rest-canvas.outcomes.1": "Recursos definidos e suas interações",
@@ -403,5 +403,143 @@
   "resource.rest-canvas.steps.3": "Fornecer exemplos de pedidos e respostas para cada verbo",
   "resource.rest-canvas.tips": "Utilizar métodos HTTP padrão (GET, POST, PUT, DELETE)",
   "resource.rest-canvas.tips.1": "Assegurar que os URIs dos recursos são intuitivos e coerentes",
-  "resource.rest-canvas.tips.2": "tratamento de erros de documentos e códigos de resposta"
+  "resource.rest-canvas.tips.2": "tratamento de erros de documentos e códigos de resposta",
+  "resource.capability-value-proposition-canvas.title": "Canvas da Proposta de Valor da Capacidade",
+  "resource.capability-value-proposition-canvas.description": "Um canvas independente da tecnologia para mapear tarefas, ganhos, dores e capacidades reutilizáveis candidatas dos utilizadores antes de selecionar um estilo de implementação.",
+  "resource.capability-value-proposition-canvas.outcomes": "Proposta de valor clara para a capacidade reutilizável",
+  "resource.capability-value-proposition-canvas.outcomes.1": "Tarefas, ganhos e dores dos utilizadores captados sem assumir uma tecnologia",
+  "resource.capability-value-proposition-canvas.outcomes.2": "Capacidades reutilizáveis candidatas identificadas para avaliação de arquitetura",
+  "resource.capability-value-proposition-canvas.steps": "Liste as tarefas e resultados dos utilizadores que a capacidade deve suportar.",
+  "resource.capability-value-proposition-canvas.steps.1": "Identifique funcionalidades da capacidade que permitem ganhos.",
+  "resource.capability-value-proposition-canvas.steps.2": "Identifique funcionalidades da capacidade que aliviam dores.",
+  "resource.capability-value-proposition-canvas.steps.3": "Agrupe as funcionalidades em capacidades reutilizáveis candidatas.",
+  "resource.capability-value-proposition-canvas.tips": "Mantenha-se independente da tecnologia até os requisitos apontarem para um estilo.",
+  "resource.capability-value-proposition-canvas.tips.1": "Utilize este recurso em vez do Canvas da Proposta de Valor da API quando a API ainda não é o estilo de implementação escolhido.",
+  "resource.capability-business-model-canvas.title": "Canvas do Modelo de Negócio da Capacidade",
+  "resource.capability-business-model-canvas.description": "Um canvas de modelo de negócio para capacidades de integração reutilizáveis, cobrindo valor, utilizadores, propriedade, envolvimento, custos e benefícios sem assumir disponibilização por API.",
+  "resource.capability-business-model-canvas.outcomes": "Modelo operacional viável para a capacidade reutilizável",
+  "resource.capability-business-model-canvas.outcomes.1": "Propriedade, utilizadores, canais, parceiros e necessidades de suporte clarificados",
+  "resource.capability-business-model-canvas.outcomes.2": "Custos e benefícios visíveis antes do compromisso com a arquitetura",
+  "resource.capability-business-model-canvas.steps": "Resuma a proposta de valor da capacidade.",
+  "resource.capability-business-model-canvas.steps.1": "Identifique segmentos de utilizadores e canais de envolvimento.",
+  "resource.capability-business-model-canvas.steps.2": "Defina atividades, recursos e parceiros-chave.",
+  "resource.capability-business-model-canvas.steps.3": "Capte custos e benefícios.",
+  "resource.capability-business-model-canvas.steps.4": "Clarifique propriedade, financiamento, suporte e expectativas de ciclo de vida.",
+  "resource.capability-business-model-canvas.steps.5": "Valide o modelo com utilizadores, produtores e partes interessadas de governação.",
+  "resource.capability-business-model-canvas.tips": "Utilize este recurso em vez do Canvas do Modelo de Negócio da API quando o estilo de implementação ainda está em aberto.",
+  "resource.capability-business-model-canvas.tips.1": "Mantenha o foco na viabilidade da capacidade reutilizável, não numa ligação pontual.",
+  "resource.consumer-experience-requirements-canvas.title": "Canvas de Requisitos da Experiência do Utilizador",
+  "resource.consumer-experience-requirements-canvas.description": "Um canvas de requisitos para a experiência orientada para os utilizadores e necessidades não funcionais que deve orientar a escolha de arquitetura posterior.",
+  "resource.consumer-experience-requirements-canvas.outcomes": "Requisitos dos utilizadores independentes da tecnologia",
+  "resource.consumer-experience-requirements-canvas.outcomes.1": "Necessidades de experiência e não funcionais captadas antes do início da conceção",
+  "resource.consumer-experience-requirements-canvas.outcomes.2": "Implicações de arquitetura documentadas para a seleção do estilo",
+  "resource.consumer-experience-requirements-canvas.steps": "Capte objetivos dos utilizadores e contexto de utilização.",
+  "resource.consumer-experience-requirements-canvas.steps.1": "Documente expectativas de disponibilidade, atualidade, volume, desempenho, qualidade dos dados e consistência.",
+  "resource.consumer-experience-requirements-canvas.steps.2": "Documente expectativas de segurança, privacidade, integração, mudança, observabilidade, suporte e recuperação.",
+  "resource.consumer-experience-requirements-canvas.steps.3": "Resuma o que os requisitos implicam para possíveis estilos de arquitetura.",
+  "resource.consumer-experience-requirements-canvas.tips": "Utilize isto como ponte entre o valor da capacidade e a decisão de arquitetura.",
+  "resource.consumer-experience-requirements-canvas.tips.1": "Não escolha API, evento, ficheiro, stream ou produto de dados até os requisitos indicarem o melhor ajuste.",
+  "resource.integration-style-selection-guide.title": "Guia de seleção do estilo de implementação",
+  "resource.integration-style-selection-guide.description": "Orientação para escolher entre API, evento, ficheiro, stream, produto de dados, integração direta ou estilos de implementação híbridos com base nos requisitos e restrições.",
+  "resource.integration-style-selection-guide.outcomes": "Estilo de implementação de integração justificado",
+  "resource.integration-style-selection-guide.outcomes.1": "Compromissos documentados entre opções de estilo de implementação",
+  "resource.integration-style-selection-guide.outcomes.2": "Estilo selecionado rastreável aos requisitos dos utilizadores, da plataforma, dos dados e da operação",
+  "resource.integration-style-selection-guide.steps": "Compare estilos de implementação viáveis face a necessidades de latência, volume, acoplamento, propriedade dos dados, atualidade, governação e operabilidade.",
+  "resource.integration-style-selection-guide.steps.1": "Identifique quando API, evento, ficheiro, stream, produto de dados, integração direta ou abordagens híbridas se ajustam ao caso de utilização.",
+  "resource.integration-style-selection-guide.steps.2": "Documente restrições, riscos e dependências da plataforma para o estilo de implementação selecionado.",
+  "resource.integration-style-selection-guide.steps.3": "Registe por que motivo as alternativas rejeitadas não foram selecionadas.",
+  "resource.integration-style-selection-guide.tips": "Utilize depois de os requisitos estarem explícitos e antes de iniciar o desenho detalhado do contrato.",
+  "resource.integration-style-selection-guide.tips.1": "Mantenha os recursos de REST, evento, GraphQL, ficheiro, stream e produto de dados como recursos opcionais de desenho subsequentes.",
+  "resource.process-workflow-design-guide.title": "Guia de desenho do processo e workflow",
+  "resource.process-workflow-design-guide.description": "Orientação para modelar passos do processo, papéis, passagens de responsabilidade, pontos de decisão, estados, entradas, saídas e exceções que moldam um workflow de automatização.",
+  "resource.process-workflow-design-guide.outcomes": "Desenho claro do workflow de automatização",
+  "resource.process-workflow-design-guide.outcomes.1": "Passos do processo e passagens de responsabilidade documentados antes da implementação",
+  "resource.process-workflow-design-guide.outcomes.2": "Estados do workflow, entradas, saídas e caminhos de exceção compreendidos",
+  "resource.process-workflow-design-guide.steps": "Mapeie o fluxo do processo atual e alvo, incluindo responsabilidades humanas e dos sistemas.",
+  "resource.process-workflow-design-guide.steps.1": "Identifique gatilhos do workflow, estados, decisões, entradas de dados, saídas e critérios de conclusão.",
+  "resource.process-workflow-design-guide.steps.2": "Documente passagens de responsabilidade entre utilizadores, sistemas, operações e papéis de suporte.",
+  "resource.process-workflow-design-guide.steps.3": "Confirme que passos devem ser automatizados e quais exigem julgamento humano.",
+  "resource.process-workflow-design-guide.tips": "Mantenha o desenho do processo separado do desenho de contratos de API ou de integração até o workflow estar claro.",
+  "resource.process-workflow-design-guide.tips.1": "Utilize este como o recurso principal de desenho para workflows de automatização.",
+  "resource.decision-business-rules-guide.title": "Guia de decisões e regras de negócio",
+  "resource.decision-business-rules-guide.description": "Orientação para captar regras, limiares, decisões, aprovações, verificações de elegibilidade e responsabilidade pelas regras no desenho de automatizações.",
+  "resource.decision-business-rules-guide.outcomes": "Decisões e regras de negócio explícitas",
+  "resource.decision-business-rules-guide.outcomes.1": "Regras e limiares documentados com responsáveis",
+  "resource.decision-business-rules-guide.outcomes.2": "Decisões da automatização rastreáveis a políticas, processos ou intenção de negócio",
+  "resource.decision-business-rules-guide.steps": "Liste as decisões que a automatização deve tomar ou apoiar.",
+  "resource.decision-business-rules-guide.steps.1": "Documente condições das regras, limiares, exceções, aprovações e pontos de escalamento.",
+  "resource.decision-business-rules-guide.steps.2": "Identifique responsáveis pelas regras e governação de alterações para cada área de decisão.",
+  "resource.decision-business-rules-guide.tips": "Separe regras de negócio estáveis de parâmetros operacionais configuráveis.",
+  "resource.decision-business-rules-guide.tips.1": "Utilize exemplos e casos-limite para validar a interpretação das regras.",
+  "resource.automation-trigger-handoff-exception-guide.title": "Guia de gatilhos, passagens de responsabilidade e exceções da automatização",
+  "resource.automation-trigger-handoff-exception-guide.description": "Orientação para definir gatilhos de automatização, passagens para intervenção humana, tratamento de exceções, tentativas repetidas, ações compensatórias e caminhos de escalamento de suporte.",
+  "resource.automation-trigger-handoff-exception-guide.outcomes": "Gatilhos de automatização e caminhos de exceção definidos",
+  "resource.automation-trigger-handoff-exception-guide.outcomes.1": "Passagens para intervenção humana e escalamentos de suporte estão explícitos",
+  "resource.automation-trigger-handoff-exception-guide.outcomes.2": "Exceções, tentativas repetidas e ações compensatórias desenhadas antes da entrega",
+  "resource.automation-trigger-handoff-exception-guide.steps": "Defina os eventos, calendários, ações de utilizadores ou estados de sistema que acionam a automatização.",
+  "resource.automation-trigger-handoff-exception-guide.steps.1": "Mapeie passagens da automatização para utilizadores, operadores ou equipas de suporte.",
+  "resource.automation-trigger-handoff-exception-guide.steps.2": "Documente exceções, regras de nova tentativa, comportamento de timeout e caminhos alternativos.",
+  "resource.automation-trigger-handoff-exception-guide.steps.3": "Defina alertas e limiares de escalamento para resultados de automatização falhados ou ambíguos.",
+  "resource.automation-trigger-handoff-exception-guide.tips": "Desenhe caminhos de exceção como comportamento essencial do workflow, não como reflexão tardia.",
+  "resource.automation-trigger-handoff-exception-guide.tips.1": "Inclua papéis de negócio e operações ao validar passagens de responsabilidade.",
+  "resource.automation-testing-guide.title": "Guia de testes de automatização",
+  "resource.automation-testing-guide.description": "Orientação para testar workflows automatizados, decisões, integrações, exceções, comportamento de rollback, supervisão e impacto nos utilizadores antes da publicação.",
+  "resource.automation-testing-guide.outcomes": "Comportamento da automatização validado",
+  "resource.automation-testing-guide.outcomes.1": "Testes de workflow, regras, exceções e integração definidos",
+  "resource.automation-testing-guide.outcomes.2": "Confiança na publicação para caminhos automatizados e assistidos por pessoas",
+  "resource.automation-testing-guide.steps": "Crie testes para caminhos esperados, casos-limite, exceções, tentativas repetidas e passagens de responsabilidade.",
+  "resource.automation-testing-guide.steps.1": "Valide regras de negócio e resultados de decisão com dados representativos.",
+  "resource.automation-testing-guide.steps.2": "Teste rollback, recuperação, observabilidade e caminhos de intervenção manual.",
+  "resource.automation-testing-guide.steps.3": "Inclua utilizadores e operadores em testes de aceitação quando a automatização altera práticas de trabalho.",
+  "resource.automation-testing-guide.tips": "Utilize cenários e formatos de dados semelhantes aos de produção sem expor dados sensíveis.",
+  "resource.automation-testing-guide.tips.1": "Mantenha as evidências de teste disponíveis para a revisão de prontidão.",
+  "resource.automation-operational-ownership-guide.title": "Guia de responsabilidade operacional da automatização",
+  "resource.automation-operational-ownership-guide.description": "Orientação para definir responsabilidade, runbooks, supervisão, suporte, monitorização, controlo de alterações e responsabilidades de melhoria contínua para automatizações.",
+  "resource.automation-operational-ownership-guide.outcomes": "Modelo operacional claro para a automatização",
+  "resource.automation-operational-ownership-guide.outcomes.1": "Responsabilidades de propriedade, suporte e escalamento atribuídas",
+  "resource.automation-operational-ownership-guide.outcomes.2": "Práticas de monitorização e alteração prontas para operação em produção",
+  "resource.automation-operational-ownership-guide.steps": "Defina responsáveis de negócio, técnicos e operacionais pela automatização.",
+  "resource.automation-operational-ownership-guide.steps.1": "Documente runbooks, caminhos de suporte, sinais de monitorização, expectativas de serviço e regras de escalamento.",
+  "resource.automation-operational-ownership-guide.steps.2": "Defina controlo de alterações e práticas de revisão para atualizações de workflow, plataforma e regras.",
+  "resource.automation-operational-ownership-guide.tips": "Não publique uma automatização sem um responsável nomeado por exceções e melhoria contínua.",
+  "resource.automation-operational-ownership-guide.tips.1": "Torne visíveis as necessidades de supervisão antes de terminar o planeamento da entrega.",
+  "resource.automation-rollback-supervision-guide.title": "Guia de rollback e supervisão da automatização",
+  "resource.automation-rollback-supervision-guide.description": "Orientação para desenhar caminhos de rollback, pausa, substituição manual, monitorização, supervisão e recuperação para automatizações.",
+  "resource.automation-rollback-supervision-guide.outcomes": "Caminhos controlados de recuperação da automatização",
+  "resource.automation-rollback-supervision-guide.outcomes.1": "Comportamento de rollback, pausa e substituição manual documentado",
+  "resource.automation-rollback-supervision-guide.outcomes.2": "Necessidades de supervisão e responsabilidades de recuperação definidas",
+  "resource.automation-rollback-supervision-guide.steps": "Identifique ações que devem poder ser revertidas, pausadas ou substituídas manualmente.",
+  "resource.automation-rollback-supervision-guide.steps.1": "Defina procedimentos de rollback, compensação e recuperação para resultados de automatização falhados ou incorretos.",
+  "resource.automation-rollback-supervision-guide.steps.2": "Documente limiares de supervisão, alertas e pontos de decisão manual.",
+  "resource.automation-rollback-supervision-guide.steps.3": "Valide os procedimentos de recuperação antes da publicação.",
+  "resource.automation-rollback-supervision-guide.tips": "Trate rollback e supervisão como parte do desenho do workflow e do plano de entrega.",
+  "resource.automation-rollback-supervision-guide.tips.1": "Utilize incidentes operacionais e quase incidentes para refinar critérios de supervisão.",
+  "resource.automation-readiness-checklist.title": "Checklist de prontidão da automatização",
+  "resource.automation-readiness-checklist.description": "Uma checklist para validar workflow de automatização, controlos, risco, conformidade, supervisão humana, evidências de teste, rollback, operações e prontidão para publicação.",
+  "resource.automation-readiness-checklist.outcomes": "Prontidão da automatização documentada",
+  "resource.automation-readiness-checklist.outcomes.1": "Lacunas de prontidão conhecidas e mitigações antes da publicação",
+  "resource.automation-readiness-checklist.outcomes.2": "Evidências para qualidade, risco, conformidade, supervisão e aprovação operacional",
+  "resource.automation-readiness-checklist.steps": "Reveja desenho do workflow, regras de negócio, controlos, acesso, tratamento de dados e caminhos de exceção.",
+  "resource.automation-readiness-checklist.steps.1": "Verifique evidências de teste, procedimentos de rollback, modelo de supervisão e prontidão do suporte.",
+  "resource.automation-readiness-checklist.steps.2": "Confirme responsabilidade, runbooks, monitorização, controlos de alteração e aprovação de publicação.",
+  "resource.automation-readiness-checklist.steps.3": "Registe lacunas por resolver, decisões e riscos aceites antes da publicação.",
+  "resource.automation-readiness-checklist.tips": "Utilize antes da publicação e novamente após alterações materiais ao workflow ou às regras.",
+  "resource.automation-readiness-checklist.tips.1": "Torne explícitas nas evidências a supervisão humana e a gestão de exceções.",
+  "resource.automation-rollout-enablement-guide.title": "Guia de rollout e enablement da automatização",
+  "resource.automation-rollout-enablement-guide.description": "Orientação para implementar automatizações com comunicação aos utilizadores, onboarding, instruções operacionais, caminhos de suporte, gestão da mudança e ciclos de feedback.",
+  "resource.automation-rollout-enablement-guide.outcomes": "Utilizadores e operadores da automatização preparados",
+  "resource.automation-rollout-enablement-guide.outcomes.1": "Comunicação de rollout, onboarding e caminhos de suporte preparados",
+  "resource.automation-rollout-enablement-guide.outcomes.2": "Utilizadores e operadores compreendem como o trabalho muda após a publicação da automatização",
+  "resource.automation-rollout-enablement-guide.steps": "Defina públicos do rollout, calendário, canais de comunicação e necessidades de formação.",
+  "resource.automation-rollout-enablement-guide.steps.1": "Publique instruções operacionais, caminhos de suporte, orientação para exceções e contactos de escalamento.",
+  "resource.automation-rollout-enablement-guide.steps.2": "Planeie suporte de transição para utilizadores, operadores e responsáveis pelo processo.",
+  "resource.automation-rollout-enablement-guide.steps.3": "Recolha feedback após o rollout e alimente o backlog com melhorias.",
+  "resource.automation-rollout-enablement-guide.tips": "Utilize linguagem de rollout para automatizações em vez de tratar enablement como publicação de API.",
+  "resource.automation-rollout-enablement-guide.tips.1": "Inclua tanto os utilizadores afetados pelo processo como os operadores responsáveis pela automatização.",
+  "resource.api-community-engagement-strategies.tips.2": "Utilize este recurso quando uma API for o estilo de implementação selecionado.",
+  "resource.api-development-best-practices.tips.2": "Utilize este recurso quando uma API for o estilo de implementação selecionado.",
+  "resource.api-metrics-and-analytics.tips.2": "Utilize este recurso quando uma API for o estilo de implementação selecionado.",
+  "resource.api-testing-best-practices.tips.2": "Utilize este recurso quando uma API for o estilo de implementação selecionado.",
+  "resource.apiops-CI-CD-for-apis.tips.2": "Utilize este recurso quando uma API for o estilo de implementação selecionado.",
+  "resource.api-audit-checklist.tips.2": "Utilize este recurso quando uma API for o estilo de implementação selecionado."
 }
diff --git a/src/data/method/pt/labels.stakeholders.json b/src/data/method/pt/labels.stakeholders.json
index 7edce82..0001b05 100644
--- a/src/data/method/pt/labels.stakeholders.json
+++ b/src/data/method/pt/labels.stakeholders.json
@@ -1,35 +1,49 @@
 {
   "stakeholder.involvement.lead": "Líder",
-  "stakeholder.involvement.core": "Principal",
+  "stakeholder.involvement.core": "Núcleo",
   "stakeholder.involvement.consulted": "Consultado",
-  "stakeholder.business-owner.title": "Responsável de Negócios",
-  "stakeholder.business-owner.description": "Representa os objetivos de negócios, financiamento e resultados esperados para a iniciativa API.",
-  "stakeholder.api-program-owner.title": "Proprietário do Programa API",
-  "stakeholder.api-program-owner.description": "Coordena as práticas de portfólio API, alinhamento organizacional e desenvolvimento de capacidades API de longo prazo.",
-  "stakeholder.api-product-owner.title": "Proprietário do Produto API",
-  "stakeholder.api-product-owner.description": "Impulsiona a oportunidade API, priorização e decisões de nível de produto ao longo do ciclo de vida.",
-  "stakeholder.domain-expert.title": "Especialista em Domínio",
-  "stakeholder.domain-expert.description": "Trás conhecimento profundo do domínio de negócios, conceitos, regras e restrições que a API deve refletir.",
-  "stakeholder.customer-or-partner-representative.title": "Representante do Cliente ou Parceiro",
-  "stakeholder.customer-or-partner-representative.description": "Contribui com a perspectiva do cliente ou parceiro de negócios para o percurso, valor e modelo de colaboração.",
-  "stakeholder.api-consumer-representative.title": "Representante do Consumidor API",
-  "stakeholder.api-consumer-representative.description": "Representa as necessidades dos desenvolvedores, integradores ou outros consumidores da API que utilizam a API diretamente.",
-  "stakeholder.platform-architect.title": "Arquiteto da Plataforma",
-  "stakeholder.platform-architect.description": "Orienta decisões sobre a plataforma, integração, escalabilidade e arquitetura que moldam como a API é construída e operada.",
+  "stakeholder.business-owner.title": "Responsável de negócio",
+  "stakeholder.business-owner.description": "Representa os objetivos de negócio, o financiamento e os resultados esperados da iniciativa de capacidade, API ou automatização.",
+  "stakeholder.api-program-owner.title": "Responsável pelo programa API",
+  "stakeholder.api-program-owner.description": "Coordena as práticas do portefólio de APIs, o alinhamento organizacional e o desenvolvimento de capacidades API a longo prazo.",
+  "stakeholder.api-product-owner.title": "Responsável pelo produto API",
+  "stakeholder.api-product-owner.description": "Conduz a oportunidade API, a priorização e as decisões ao nível do produto ao longo do ciclo de vida.",
+  "stakeholder.capability-owner.title": "Responsável pela capacidade",
+  "stakeholder.capability-owner.description": "Responsável pela visão, valor, prioridades, ciclo de vida e reutilização da capacidade junto dos utilizadores.",
+  "stakeholder.domain-specialist.title": "Especialista de domínio",
+  "stakeholder.domain-specialist.description": "Traz conhecimento profundo do domínio de negócio, conceitos, regras e restrições que a capacidade ou interface deve refletir.",
+  "stakeholder.customer-specialist.title": "Representante de cliente ou parceiro",
+  "stakeholder.customer-specialist.description": "Contribui com a perspetiva do cliente ou parceiro para o percurso, valor e modelo de colaboração.",
+  "stakeholder.api-consumer-specialist.title": "Representante dos utilizadores da API",
+  "stakeholder.api-consumer-specialist.description": "Representa as necessidades de programadores, integradores ou outros utilizadores que utilizam a API diretamente.",
+  "stakeholder.platform-architect.title": "Arquiteto de plataforma",
+  "stakeholder.platform-architect.description": "Orienta decisões de plataforma, integração, escalabilidade e arquitetura que moldam como a capacidade ou API é construída e operada.",
+  "stakeholder.api-architect.title": "Arquiteto API",
+  "stakeholder.api-architect.description": "Responsável pela arquitetura API, pelos princípios de desenho e pela qualidade dos contratos de interface.",
+  "stakeholder.integration-architect.title": "Arquiteto de integração",
+  "stakeholder.integration-architect.description": "Desenha abordagens de integração e estilos de implementação que ligam a capacidade ou API a outros sistemas.",
+  "stakeholder.platform-owner.title": "Responsável pela plataforma",
+  "stakeholder.platform-owner.description": "Responsável pelas capacidades da plataforma, roadmap, modelo operacional e expectativas de serviço.",
   "stakeholder.api-designer.title": "Designer API",
-  "stakeholder.api-designer.description": "Modela o contrato API, o modelo de interação, a consistência e a usabilidade das capacidades expostas.",
-  "stakeholder.delivery-engineer.title": "Engenheiro de Entrega",
-  "stakeholder.delivery-engineer.description": "Responsável por implementação, automação, testes e preocupações de fluxo de lançamento necessárias para entregar a API de forma confiável.",
-  "stakeholder.security-specialist.title": "Especialista em Segurança",
-  "stakeholder.security-specialist.description": "Garante que os riscos de segurança, controles e limites de confiança sejam abordados ao longo do ciclo de vida da API.",
-  "stakeholder.compliance-legal-specialist.title": "Especialista em Conformidade e Legal",
-  "stakeholder.compliance-legal-specialist.description": "Esclarece os requisitos legais, de privacidade, regulatórios e contratuais que afetam a API.",
-  "stakeholder.governance-owner.title": "Proprietário da Governança",
-  "stakeholder.governance-owner.description": "Representa práticas de revisão, auditoria e governança em toda a organização para qualidade e conformidade das APIs.",
-  "stakeholder.documentation-devrel-owner.title": "Proprietário da Documentação e Desenvolvimento Comunitário",
-  "stakeholder.documentation-devrel-owner.description": "Possui o conteúdo de integração, a comunicação com os desenvolvedores e a qualidade da documentação para os usuários da API.",
-  "stakeholder.support-operations-owner.title": "Proprietário do Suporte e Operações",
-  "stakeholder.support-operations-owner.description": "Representa o suporte em tempo de execução, o tratamento de incidentes, a observabilidade e a prontidão operacional.",
-  "stakeholder.partner-vendor-manager.title": "Gerente de Parceiros ou Fornecedores",
-  "stakeholder.partner-vendor-manager.description": "Coordena as relações com parceiros externos, fornecedores ou vendedores que influenciam a estratégia e a entrega da API."
+  "stakeholder.api-designer.description": "Modela o contrato de interface, o modelo de interação, a consistência e a usabilidade das capacidades expostas.",
+  "stakeholder.api-engineer.title": "Engenheiro de entrega",
+  "stakeholder.api-engineer.description": "Responsável pela implementação, automatização, testes e fluxo de publicação necessários para entregar a capacidade, API ou automatização de forma fiável.",
+  "stakeholder.automation-owner.title": "Responsável pela automatização",
+  "stakeholder.automation-owner.description": "Responsável pelos objetivos, valor de negócio, prioridades, controlos e resultados do ciclo de vida da automatização.",
+  "stakeholder.process-owner.title": "Responsável pelo processo",
+  "stakeholder.process-owner.description": "Responsável pelo processo de negócio a automatizar, incluindo objetivos, regras, resultados e prioridades de melhoria.",
+  "stakeholder.automation-engineer.title": "Engenheiro de automatização",
+  "stakeholder.automation-engineer.description": "Implementa, testa, integra e mantém soluções de automatização e workflows de suporte.",
+  "stakeholder.security-specialist.title": "Especialista em segurança",
+  "stakeholder.security-specialist.description": "Garante que os riscos de segurança, controlos e fronteiras de confiança são tratados ao longo de todo o ciclo de vida.",
+  "stakeholder.compliance-specialist.title": "Especialista em conformidade e jurídico",
+  "stakeholder.compliance-specialist.description": "Esclarece requisitos legais, de privacidade, regulamentares e contratuais que afetam a capacidade, API, interface ou automatização.",
+  "stakeholder.governance-specialist.title": "Responsável pela governação API",
+  "stakeholder.governance-specialist.description": "Representa práticas de revisão, auditoria e governação em toda a organização para qualidade e conformidade das APIs.",
+  "stakeholder.api-devrel-specialist.title": "Responsável por documentação e DevRel",
+  "stakeholder.api-devrel-specialist.description": "Responsável por conteúdos de onboarding, comunicação com programadores e qualidade da documentação para utilizadores da API.",
+  "stakeholder.operations-specialist.title": "Responsável por suporte e operações",
+  "stakeholder.operations-specialist.description": "Representa o suporte em execução, tratamento de incidentes, observabilidade e prontidão operacional da capacidade, API ou automatização.",
+  "stakeholder.partner-specialist.title": "Gestor de parceiros ou fornecedores",
+  "stakeholder.partner-specialist.description": "Coordena relações com parceiros, fornecedores ou prestadores externos que influenciam a estratégia e entrega da capacidade ou API."
 }
diff --git a/src/data/method/pt/labels.stations.json b/src/data/method/pt/labels.stations.json
index 91984de..1264a33 100644
--- a/src/data/method/pt/labels.stations.json
+++ b/src/data/method/pt/labels.stations.json
@@ -2,22 +2,22 @@
   "group.core-stations.title": "Estações centrais do ciclo de vida da API",
   "group.core-stations.description": "As estações centrais do API Metro, onde as equipas podem aprender a criar e gerir APIs de forma eficaz.",
   "station.api-product-strategy.title": "Estratégia de produtos API - Transforme APIs em produtos estratégicos",
-  "station.api-product-strategy.description": "Antes de construir qualquer coisa, defina o valor da sua API, os utilizadores e os objectivos comerciais desde o primeiro dia.",
-  "station.api-product-strategy.why_it_matters": "Muitas organizações pensam nas APIs como projectos tecnológicos e não como produtos. O resultado? Consumidores confusos, fraca adoção e esforço desperdiçado.\n\nEsta estação ajuda-o a definir o objetivo da sua API, o público-alvo e os critérios de sucesso, para que as equipas possam fornecer APIs que resolvam problemas reais.",
+  "station.api-product-strategy.description": "Antes de construir qualquer coisa, defina o valor da sua API, os utilizadores e os objetivos de negócio desde o primeiro dia.",
+  "station.api-product-strategy.why_it_matters": "Muitas organizações pensam nas APIs como projetos tecnológicos e não como produtos. O resultado? Consumidores confusos, fraca adoção e esforço desperdiçado.\n\nEsta estação ajuda-o a definir o objetivo da sua API, o público-alvo e os critérios de sucesso, para que as equipas possam fornecer APIs que resolvam problemas reais.",
   "station.api-product-strategy.apply_in_work": "Fornecer diretrizes e modelos para a criação de modelos comerciais, propostas de valor e roteiros de API.",
   "station.api-product-strategy.outcomes": "Uma proposta de valor e um público-alvo da API simples",
-  "station.api-product-strategy.outcomes.1": "Linguagem partilhada entre o produto, o design e a tecnologia",
+  "station.api-product-strategy.outcomes.1": "Linguagem partilhada entre o produto, a conceção e a tecnologia",
   "station.api-product-strategy.outcomes.2": "Um argumento sólido ou um caso para financiamento/aprovação",
-  "station.api-product-strategy.how_it_works": "Explore o problema do cliente ou parceiro que espera resolver com as APIs. Mapeie as partes interessadas, os seus percursos e os resultados utilizando a tela do Percurso do Cliente.",
+  "station.api-product-strategy.how_it_works": "Explore o problema do cliente ou parceiro que espera resolver com as APIs. Mapeie as partes interessadas, os seus percursos e os resultados utilizando a Canvas do Percurso do Cliente.",
   "station.api-product-strategy.how_it_works.1": "Definir as entidades principais, os seus atributos e relações para criar um entendimento concetual partilhado entre jornadas e, eventualmente, APIs.",
-  "station.api-product-strategy.how_it_works.2": "Use o API Value Proposition Canvas para capturar as tarefas de negócios suportadas e as dores, ganhos e recursos do consumidor da API que moldam APIs novas ou reutilizáveis.",
-  "station.api-product-strategy.how_it_works.3": "Defina o valor - para os utilizadores e para a empresa - com a tela do modelo de negócio da API para tornar a sua estratégia de API visual, partilhável e fácil de validar com os seus consumidores de API na estação seguinte.",
-  "station.api-consumer-experience.title": "Experiência do consumidor da API - Design para os utilizadores reais da sua API",
+  "station.api-product-strategy.how_it_works.2": "Utilize o Canvas da Proposta de Valor da API para capturar as tarefas de negócios suportadas e as dores, ganhos e recursos do consumidor da API que moldam APIs novas ou reutilizáveis.",
+  "station.api-product-strategy.how_it_works.3": "Defina o valor - para os utilizadores e para a empresa - com a Canvas do Modelo de Negócio da API para tornar a sua estratégia de API visual, partilhável e fácil de validar com os seus consumidores de API na estação seguinte.",
+  "station.api-consumer-experience.title": "Experiência do consumidor da API - Conceção para os utilizadores reais da sua API",
   "station.api-consumer-experience.description": "Certifique-se de que a sua API é detetável, compreensível e utilizável - antes e depois do lançamento.",
-  "station.api-consumer-experience.why_it_matters": "As APIs excelentes não funcionam apenas - elas são intuitivas. Quer o consumidor seja um programador interno, um parceiro externo ou um agente de IA, a sua experiência determina a adoção.\n\nSem um plano de experiência claro:\n- Grandes APIs ficam sem uso\n- As equipas perdem tempo a tentar adivinhar como utilizar a sua API\n- Os ciclos de feedback estão quebrados ou ausentes.\n\nEsta estação ajuda-o a ver a sua API através dos olhos dos seus consumidores.",
-  "station.api-consumer-experience.how_it_works": "Analise o API Value Proposition Canvas existente sob a perspectiva do consumidor da API. Mantenha as tarefas de negócios suportadas estáveis ​​e enriqueça os recursos que aliviam problemas e possibilitam ganhos com as preocupações do consumidor da API, para que elas possam orientar as decisões de design futuras.",
-  "station.api-consumer-experience.how_it_works.1": "Use o Customer Journey Canvas para a jornada do consumidor da API, desde a descoberta e avaliação até a integração, resolução de problemas e uso contínuo.",
-  "station.api-consumer-experience.how_it_works.2": "Use a jornada resultante para melhorar a integração, a documentação, o suporte e os ciclos de feedback para o consumidor da API.",
+  "station.api-consumer-experience.why_it_matters": "As APIs excelentes não funcionam apenas - elas são intuitivas. Quer o consumidor seja um programador interno, um parceiro externo ou um agente de IA, a sua experiência determina a adoção.\n\nSnum plano de experiência claro:\n- Grandes APIs ficam sem uso\n- As equipas perdem tempo a tentar adivinhar como utilizar a sua API\n- Os ciclos de feedback estão quebrados ou ausentes.\n\nEsta estação ajuda-o a ver a sua API através dos olhos dos seus consumidores.",
+  "station.api-consumer-experience.how_it_works": "Analise o Canvas da Proposta de Valor da API existente sob a perspectiva do consumidor da API. Mantenha as tarefas de negócios suportadas estáveis ​​e enriqueça os recursos que aliviam problemas e possibilitam ganhos com as preocupações do consumidor da API, para que elas possam orientar as decisões de conceção futuras.",
+  "station.api-consumer-experience.how_it_works.1": "Utilize o Canvas do Percurso do Cliente para a jornada do consumidor da API, desde a descoberta e avaliação até a integração, resolução de problemas e uso contínuo.",
+  "station.api-consumer-experience.how_it_works.2": "Utilize a jornada resultante para melhorar a integração, a documentação, o suporte e os ciclos de feedback para o consumidor da API.",
   "station.api-consumer-experience.apply_in_work": "Fornecer diretrizes, ferramentas e mecanismos de feedback para compreender, analisar e melhorar a experiência interna e externa dos programadores e parceiros.",
   "station.api-consumer-experience.outcomes": "Identifique e dê prioridade aos seus consumidores de API",
   "station.api-consumer-experience.outcomes.1": "Definir o percurso da experiência API",
@@ -26,59 +26,59 @@
   "station.api-platform-architecture.title": "Arquitetura da plataforma API - Arquitetar APIs para escalabilidade e reutilização",
   "station.api-platform-architecture.description": "Garanta a escalabilidade, a reutilização e a governação da sua API e dos componentes da plataforma.",
   "station.api-platform-architecture.why_it_matters": "Quando as APIs são escalonadas entre equipas, a sua plataforma deve permitir a governação e a reutilização sem bloquear a velocidade. Esta estação mostra como arquitetar APIs para longevidade, segurança e eficiência.",
-  "station.api-platform-architecture.apply_in_work": "Estabelecer uma infraestrutura escalável, segura e compatível com as operações de API. Fornecer orientações sobre as melhores práticas de arquitetura.",
+  "station.api-platform-architecture.apply_in_work": "Estabelecer uma infraestrutura escalável, segura e compatível com as operações de API. Fornecer orientações sobre as boas práticas de arquitetura.",
   "station.api-platform-architecture.outcomes": "Corte APIs redundantes e reduza os custos da plataforma de nuvem",
-  "station.api-platform-architecture.outcomes.1": "Implementar uma governação consistente sem um forte controlo do topo para a base",
+  "station.api-platform-architecture.outcomes.1": "Implementar uma governação consistente snum forte controlo do topo para a base",
   "station.api-platform-architecture.outcomes.2": "Conceção para reutilização interna e escalabilidade externa",
-  "station.api-platform-architecture.how_it_works": "O Business Impact Canvas ajuda a identificar e mitigar os riscos relacionados com a disponibilidade, segurança e funcionalidade da API para apoiar decisões de arquitetura informadas.",
+  "station.api-platform-architecture.how_it_works": "O Canvas de Impacto no Negócio ajuda a identificar e mitigar os riscos relacionados com a disponibilidade, segurança e funcionalidade da API para apoiar decisões de arquitetura informadas.",
   "station.api-platform-architecture.how_it_works.1": "Mapear as localizações regulamentares, de conformidade e de rede dos fornecedores e consumidores de API para garantir a acessibilidade e a conformidade.",
-  "station.api-platform-architecture.how_it_works.2": "O Capacity Canvas alinha os padrões das transacções comerciais, as tendências de consumo futuro e as soluções técnicas para garantir a escalabilidade e o desempenho da API, fornecendo dados essenciais para as decisões de escalabilidade e o planeamento da infraestrutura.",
-  "station.api-platform-architecture.how_it_works.3": "Definir e monitorizar as métricas de desempenho (por exemplo, chamadas API, latência, taxas de erro) e as métricas de adoção (por exemplo, NPS).",
+  "station.api-platform-architecture.how_it_works.2": "O Canvas de Capacidade alinha os padrões das transacções comerciais, as tendências de consumo futuro e as soluções técnicas para garantir a escalabilidade e o desempenho da API, fornecendo dados essenciais para as decisões de escalabilidade e o planeamento da infraestrutura.",
+  "station.api-platform-architecture.how_it_works.3": "Definir e monitorizar as métricas de desempenho (por exemplo, chamadas APIs, latência, taxas de erro) e as métricas de adoção (por exemplo, NPS).",
   "station.api-design.title": "Conceção da API - Conceber APIs que proporcionem valor",
-  "station.api-design.description": "Criar projetos de API que sejam consistentes, reutilizáveis e baseados na intenção de negócios e em padrões compartilhados.",
-  "station.api-design.why_it_matters": "Projetar APIs não se resume apenas a nomear endpoints. Um bom projeto garante que as APIs sejam utilizáveis, consistentes e alinhadas com os objetivos comerciais e técnicos. Um projeto inadequado leva a um acoplamento rígido, baixa reutilização e retrabalho dispendioso entre as equipes.",
+  "station.api-design.description": "Criar conceções de API que sejam consistentes, reutilizáveis e baseados na intenção de negócios e em padrões compartilhados.",
+  "station.api-design.why_it_matters": "Conceber APIs não se resume apenas a nomear endpoints. Um bom projeto garante que as APIs sejam utilizáveis, consistentes e alinhadas com os objetivos de negócio e técnicos. Um projeto inadequado leva a um acoplamento rígido, baixa reutilização e retrabalho dispendioso entre as equipas.",
   "station.api-design.apply_in_work": "Forneça padrões de projeto reutilizáveis, padrões compartilhados e ferramentas de validação para especificações de API. Garanta que as decisões de projeto sejam consistentes, revisadas antecipadamente e alinhadas com a intenção de negócios.",
   "station.api-design.outcomes": "Conceção de API bem documentada e coerente",
-  "station.api-design.outcomes.1": "Contratos API reutilizáveis e validados",
+  "station.api-design.outcomes.1": "Contratos de interface da API reutilizáveis e validados",
   "station.api-design.outcomes.2": "Desenhos alinhados com modelos de domínio e padrões de interação",
-  "station.api-design.outcomes.3": "Rastreabilidade da conceção ao valor comercial",
+  "station.api-design.outcomes.3": "Rastreabilidade da conceção ao valor de negócio",
   "station.api-design.how_it_works": "Definir entidades principais, os seus atributos e relações para criar um entendimento concetual partilhado entre APIs.",
   "station.api-design.how_it_works.1": "Utilize o Canvas de Interação para definir a forma como os consumidores irão interagir com a API, garantindo que esta satisfaz as suas necessidades e expectativas.",
-  "station.api-design.how_it_works.2": "Aplicar padrões de conceção REST para criar contratos de API consistentes e reutilizáveis que são validados com as partes interessadas.",
-  "station.api-design.how_it_works.3": "Aplicar padrões de conceção orientados para eventos para criar contratos de API consistentes e reutilizáveis que são validados com as partes interessadas.",
-  "station.api-design.how_it_works.4": "Aplicar padrões de design GraphQL para criar contratos de API consistentes e reutilizáveis que são validados com as partes interessadas.",
-  "station.api-design.how_it_works.5": "Use os princípios de projeto e o guia de estilo de API para alinhar suas decisões de projeto com regras compartilhadas e permitir uma validação de auditoria consistente.",
-  "station.api-design.how_it_works.6": "Aplique abordagens do tipo ‘contrato primeiro’ ou ‘design primeiro’ para capturar e validar o contrato da API antes da implementação.",
-  "station.api-design.how_it_works.7": "Use a Lista de Verificação de Auditoria da API para garantir que o design da API atenda aos requisitos funcionais e não funcionais, incluindo segurança, desempenho e conformidade.",
+  "station.api-design.how_it_works.2": "Aplicar padrões de conceção REST para criar contratos de interface da API consistentes e reutilizáveis que são validados com as partes interessadas.",
+  "station.api-design.how_it_works.3": "Aplicar padrões de conceção orientados para eventos para criar contratos de interface da API consistentes e reutilizáveis que são validados com as partes interessadas.",
+  "station.api-design.how_it_works.4": "Aplicar padrões de conceção GraphQL para criar contratos de interface da API consistentes e reutilizáveis que são validados com as partes interessadas.",
+  "station.api-design.how_it_works.5": "Utilize os princípios de projeto e o guia de estilo da API para alinhar suas decisões de projeto com regras compartilhadas e permitir uma validação de auditoria consistente.",
+  "station.api-design.how_it_works.6": "Aplique abordagens do tipo ‘contrato primeiro’ ou ‘design primeiro’ para capturar e validar o contrato de interface da API antes da implementação.",
+  "station.api-design.how_it_works.7": "Utilize a Lista de Verificação de Auditoria da API para garantir que a conceção da API satisfaça os requisitos funcionais e não funcionais, incluindo segurança, desempenho e conformidade.",
   "station.api-delivery.title": "Entrega da API - Fornecer APIs seguras e fiáveis",
-  "station.api-delivery.description": "Criar, testar e lançar APIs usando pipelines de entrega modernos e práticas recomendadas de engenharia.",
-  "station.api-delivery.why_it_matters": "Mesmo os melhores projectos de API falham se a entrega for inconsistente. Esta estação assegura que as suas APIs são construídas com qualidade, testadas exaustivamente e implementadas de forma fiável - permitindo iterações mais rápidas e maior confiança.",
-  "station.api-delivery.apply_in_work": "Fornecer estruturas de codificação, bibliotecas e normas para a implementação de API. Implementar pipelines de CI/CD, estruturas de garantia de qualidade e ferramentas de automatização da implantação.",
+  "station.api-delivery.description": "Criar, testar e lançar APIs usando pipelines de entrega modernos e boas práticas de engenharia.",
+  "station.api-delivery.why_it_matters": "Mesmo os melhores conceções de API falham se a entrega for inconsistente. Esta estação assegura que as suas APIs são construídas com qualidade, testadas exaustivamente e implementadas de forma fiável - permitindo iterações mais rápidas e maior confiança.",
+  "station.api-delivery.apply_in_work": "Fornecer estruturas de codificação, bibliotecas e normas para a implementação de API. Implementar pipelines de CI/CD, estruturas de garantia de qualidade e ferramentas de automatização da disponibilização.",
   "station.api-delivery.outcomes": "APIs implementadas utilizando estruturas e padrões testados",
   "station.api-delivery.outcomes.1": "Pipelines de CI/CD fiáveis e automatizados",
   "station.api-delivery.outcomes.2": "Testes funcionais e não funcionais integrados",
   "station.api-delivery.outcomes.3": "Condutas de entrega seguras e conformes",
-  "station.api-delivery.how_it_works": "Use as Melhores Práticas de Desenvolvimento de API como orientação para implementar o contrato validado com frameworks e bibliotecas estabelecidos, garantindo que o resultado seja reutilizável e sustentável.",
-  "station.api-delivery.how_it_works.1": "Construa a implementação da API a partir do contrato validado usando frameworks, bibliotecas e padrões da equipe estabelecidos.",
-  "station.api-delivery.how_it_works.2": "Testar a funcionalidade, a segurança e o desempenho das API, utilizando ferramentas de teste automatizadas.",
+  "station.api-delivery.how_it_works": "Utilize as Melhores Práticas de Desenvolvimento de API como orientação para implementar o contrato validado com frameworks e bibliotecas estabelecidos, garantindo que o resultado seja reutilizável e sustentável.",
+  "station.api-delivery.how_it_works.1": "Construa a implementação da API a partir do contrato validado usando frameworks, bibliotecas e padrões da equipa estabelecidos.",
+  "station.api-delivery.how_it_works.2": "Testar a funcionalidade, a segurança e o desempenho das APIs, utilizando ferramentas de teste automatizadas.",
   "station.api-delivery.how_it_works.3": "Utilize pipelines CI/CD para automatizar os processos de construção, teste e implementação, garantindo uma qualidade e rastreabilidade consistentes.",
   "station.api-delivery.how_it_works.4": "Garantir que as APIs cumprem os requisitos de segurança e conformidade através de verificações e auditorias automatizadas.",
   "station.api-delivery.how_it_works.5": "Utilize a lista de verificação de auditoria da API para garantir que a API cumpre os requisitos funcionais e não funcionais, incluindo segurança, desempenho e conformidade.",
   "station.api-audit.title": "Auditoria de API - Auditoria de APIs para conformidade e qualidade",
-  "station.api-audit.description": "Valide se as APIs atendem aos padrões de negócios, design e operacionais antes da publicação e exposição.",
-  "station.api-audit.why_it_matters": "As APIs são produtos de longa duração e devem atender às expectativas de qualidade, consistência e conformidade. A auditoria conecta as decisões de design, a implementação e a prontidão operacional a padrões definidos, reduzindo o risco antes da exposição.",
+  "station.api-audit.description": "Valide se as APIs satisfazemos padrões de negócio, conceção e operacionais antes da publicação e exposição.",
+  "station.api-audit.why_it_matters": "As APIs são produtos de longa duração e devem atender às expectativas de qualidade, consistência e conformidade. A auditoria conecta as decisões de conceção, a implementação e a prontidão operacional a padrões definidos, reduzindo o risco antes da exposição.",
   "station.api-audit.apply_in_work": "Estabeleça um processo de auditoria consistente que avalie a prontidão da API em todas as etapas do ciclo de vida usando critérios, evidências e padrões definidos. Garanta que as lacunas sejam identificadas antecipadamente e resolvidas antes da publicação.",
-  "station.api-audit.outcomes": "As APIs cumprem as normas internas e externas",
+  "station.api-audit.outcomes": "As APIs cumprems normas internas e externas",
   "station.api-audit.outcomes.1": "Documentação clara das decisões de conceção e implementação da API",
   "station.api-audit.outcomes.2": "Segurança, desempenho e conformidade validados",
   "station.api-audit.outcomes.3": "Redução do risco de problemas na produção",
-  "station.api-audit.how_it_works": "Realizar auditorias para garantir que as APIs cumprem as normas organizacionais, técnicas e legais antes da publicação.",
+  "station.api-audit.how_it_works": "Realizar auditorias para garantir que as APIs cumprems normas organizacionais, técnicas e legais antes da publicação.",
   "station.api-audit.how_it_works.1": "Utilizar listas de controlo, linters e ferramentas de teste para verificar a consistência e a conformidade com as normas.",
-  "station.api-audit.how_it_works.2": "Colaborar com as equipas de governação e especialistas no domínio para garantir que as API estão prontas para produção.",
+  "station.api-audit.how_it_works.2": "Colaborar com as equipas de governação e especialistas no domínio para garantir que as APIs estão prontas para produção.",
   "station.api-publishing.title": "Publicação de API - Publique APIs com confiança",
   "station.api-publishing.description": "Exponha as APIs de forma segura e clara ao público certo com a documentação e os processos corretos.",
-  "station.api-publishing.why_it_matters": "A publicação é mais do que a implantação - trata-se de capacidade de descoberta, acesso e suporte. Se as APIs não forem publicadas corretamente, não serão utilizadas, reutilizadas ou protegidas de forma eficaz.",
-  "station.api-publishing.apply_in_work": "Permitir que as API sejam publicadas no ambiente relevante e ter mecanismos claros de registo e acesso (por exemplo, chaves de API, OAuth, planos de subscrição), dependendo dos segmentos de consumidores de API e dos requisitos de segurança e conformidade.",
+  "station.api-publishing.why_it_matters": "A publicação é mais do que a disponibilização - trata-se de capacidade de descoberta, acesso e suporte. Se as APIs não forem publicadas corretamente, não serão utilizadas, reutilizadas ou protegidas de forma eficaz.",
+  "station.api-publishing.apply_in_work": "Permitir que as APIs sejam publicadas no ambiente relevante e ter mecanismos claros de registo e acesso (por exemplo, chaves de API, OAuth, planos de subscrição), dependendo dos segmentos de consumidores de API e dos requisitos de segurança e conformidade.",
   "station.api-publishing.outcomes": "APIs publicadas no ambiente correto (privado, parceiro, público)",
   "station.api-publishing.outcomes.1": "Processos claros de integração e registo da API",
   "station.api-publishing.outcomes.2": "Documentação, modelos e políticas de segurança disponíveis",
@@ -94,14 +94,14 @@
   "station.monitoring-and-improving.outcomes.1": "Ciclos de feedback do programador em vigor",
   "station.monitoring-and-improving.outcomes.2": "Questões identificadas e tratadas continuamente",
   "station.monitoring-and-improving.outcomes.3": "Iteração da API alinhada com as necessidades dos utilizadores",
-  "station.monitoring-and-improving.how_it_works": "Monitorizar as métricas de desempenho (por exemplo, chamadas API, latência, taxas de erro) e as métricas de adoção (por exemplo, NPS).",
+  "station.monitoring-and-improving.how_it_works": "Monitorizar as métricas de desempenho (por exemplo, chamadas APIs, latência, taxas de erro) e as métricas de adoção (por exemplo, NPS).",
   "station.monitoring-and-improving.how_it_works.1": "Analisar as métricas de utilização da API e incorporar o feedback dos utilizadores nas iterações da API.",
   "station.monitoring-and-improving.how_it_works.2": "Crie o hábito de analisar os indicadores e planear actividades de melhoria contínua.",
   "group.sub-stations.title": "Sub-estações do ciclo de vida API",
-  "group.sub-stations.description": "Subestações que fornecem recursos adicionais, ferramentas e melhores práticas para equipas de API.",
+  "group.sub-stations.description": "Subestações que fornecem recursos adicionais, ferramentas e boas práticas para equipas de API.",
   "station.user-experience.title": "Experiência do utilizador - Conceber APIs com o utilizador em mente",
-  "station.user-experience.description": "Assegurar que as API são concebidas tendo em mente o utilizador final, proporcionando uma experiência intuitiva e sem descontinuidades.",
-  "station.user-experience.why_it_matters": "As API não são apenas produtos técnicos; são produtos virados para o utilizador. Uma má experiência do utilizador pode levar a uma baixa adoção e à frustração. Esta estação ajuda as equipas a conceber APIs que sejam fáceis de utilizar e que satisfaçam as necessidades dos consumidores.",
+  "station.user-experience.description": "Assegurar que as APIs são concebidas tendo em mente o utilizador final, proporcionando uma experiência intuitiva e sem descontinuidades.",
+  "station.user-experience.why_it_matters": "As APIs não são apenas produtos técnicos; são produtos virados para o utilizador. Uma má experiência do utilizador pode levar a uma baixa adoção e à frustração. Esta estação ajuda as equipas a conceber APIs que sejam fáceis de utilizar e que satisfaçam as necessidades dos consumidores.",
   "station.user-experience.apply_in_work": "Fornecer orientações, modelos e ferramentas de experiência do utilizador para a conceção de API. Assegurar que as equipas seguem práticas de design centradas no utilizador e incorporam o feedback do utilizador nas iterações da API.",
   "station.user-experience.outcomes": "APIs concebidas a pensar nas necessidades dos utilizadores",
   "station.user-experience.outcomes.1": "Interfaces de utilizador intuitivas e coerentes",
@@ -111,26 +111,26 @@
   "station.user-experience.how_it_works.1": "Realize estudos de utilizadores para obter informações sobre a forma como os consumidores interagem com os serviços do ecossistema ou com as suas aplicações que consomem API.",
   "station.user-experience.how_it_works.2": "Documentar os requisitos da experiência do utilizador para que possam ser utilizados na conceção da API, garantindo que são intuitivos e fáceis de utilizar.",
   "station.market-insights.title": "Informações sobre o mercado - Compreender o cenário das API",
-  "station.market-insights.description": "Analisar as tendências do mercado, as API da concorrência e as normas da indústria para informar a estratégia de API.",
+  "station.market-insights.description": "Analisar as tendências do mercado, as APIs da concorrência e as normas da indústria para informar a estratégia de API.",
   "station.market-insights.why_it_matters": "Compreender o panorama do mercado ajuda as equipas a identificar oportunidades, evitar armadilhas e alinhar as suas APIs com as normas da indústria. Esta estação fornece ferramentas para analisar as tendências do mercado e as ofertas dos concorrentes.",
   "station.market-insights.apply_in_work": "Fornecer ferramentas de pesquisa de mercado, modelos de análise da concorrência e recursos de normas do sector. Assegurar que as equipas se mantêm informadas sobre as tendências do mercado e incorporam os conhecimentos na estratégia de API.",
   "station.market-insights.outcomes": "Análise das tendências do mercado e das APIs dos concorrentes",
-  "station.market-insights.outcomes.1": "Identificação das normas e melhores práticas do sector",
+  "station.market-insights.outcomes.1": "Identificação das normas e boas práticas do sector",
   "station.market-insights.outcomes.2": "Estratégia de API alinhada com as necessidades do mercado",
   "station.market-insights.outcomes.3": "Tomada de decisões informadas com base em conhecimentos do mercado",
-  "station.market-insights.how_it_works": "Realizar estudos de mercado para identificar tendências, oportunidades e ameaças no panorama das API.",
-  "station.market-insights.how_it_works.1": "Analisar as API da concorrência para compreender os seus pontos fortes, fracos e pontos de venda únicos.",
-  "station.market-insights.how_it_works.2": "Identificar as normas e as melhores práticas do sector para garantir que as API são competitivas e estão em conformidade.",
-  "station.business-goals.title": "Objectivos comerciais - Alinhar as APIs com os objectivos comerciais",
-  "station.business-goals.description": "Assegurar que as API estão alinhadas com os objectivos comerciais e contribuem para os objectivos organizacionais globais.",
-  "station.business-goals.why_it_matters": "As APIs não devem ser construídas isoladamente; elas devem apoiar e impulsionar os objectivos comerciais. Esta estação ajuda as equipas a alinharem as suas APIs com os objectivos estratégicos, assegurando que fornecem um verdadeiro valor comercial.",
-  "station.business-goals.apply_in_work": "Fornecer estruturas, modelos e ferramentas de alinhamento comercial para definir o valor comercial da API. Garantir que as equipas revejam e alinhem regularmente as APIs com os objectivos comerciais em mudança.",
-  "station.business-goals.outcomes": "APIs alinhadas com os objectivos comerciais",
-  "station.business-goals.outcomes.1": "Valor comercial claro definido para cada API",
+  "station.market-insights.how_it_works": "Realizar estudos de mercado para identificar tendências, oportunidades e ameaças no panorama das APIs.",
+  "station.market-insights.how_it_works.1": "Analisar as APIs da concorrência para compreender os seus pontos fortes, fracos e pontos de venda únicos.",
+  "station.market-insights.how_it_works.2": "Identificar as normas e as boas práticas do sector para garantir que as APIs são competitivas e estão em conformidade.",
+  "station.business-goals.title": "Objectivos comerciais - Alinhar as APIs com os objetivos de negócio",
+  "station.business-goals.description": "Assegurar que as APIs estão alinhadas com os objetivos de negócio e contribuem para os objetivos organizacionais globais.",
+  "station.business-goals.why_it_matters": "As APIs não devem ser construídas isoladamente; elas devem apoiar e impulsionar os objetivos de negócio. Esta estação ajuda as equipas a alinharem as suas APIs com os objetivos estratégicos, assegurando que fornecnum verdadeiro valor de negócio.",
+  "station.business-goals.apply_in_work": "Fornecer estruturas, modelos e ferramentas de alinhamento comercial para definir o valor de negócio da API. Garantir que as equipas revejam e alinhem regularmente as APIs com os objetivos de negócio em mudança.",
+  "station.business-goals.outcomes": "APIs alinhadas com os objetivos de negócio",
+  "station.business-goals.outcomes.1": "Valor de negócio claro definido para cada API",
   "station.business-goals.outcomes.2": "Adesão e apoio das partes interessadas às iniciativas API",
   "station.business-goals.outcomes.3": "As APIs contribuem para o sucesso organizacional",
-  "station.business-goals.how_it_works": "Definir os objectivos comerciais e a forma como as API podem apoiá-los utilizando **o Business Model Canvas**. Se o seu negócio é fornecer APIs, passe pela *estação de Estratégia de Produto de API* e preencha **o Modelo de Negócio de API Canvas**.",
-  "station.business-goals.how_it_works.1": "Identificar indicadores-chave de desempenho (KPIs) para medir o sucesso da API em relação aos objectivos comerciais.",
+  "station.business-goals.how_it_works": "Definir os objetivos de negócio e a forma como as APIs podem apoiá-los utilizando **o Business Model Canvas**. Se o seu negócio é fornecer APIs, passe pela *estação de Estratégia de Produto de API* e preencha **o Modelo de Negócio de API Canvas**.",
+  "station.business-goals.how_it_works.1": "Identificar indicadores-chave de desempenho (KPIs) para medir o sucesso da API em relação aos objetivos de negócio.",
   "station.business-goals.how_it_works.2": "Envolver as partes interessadas para garantir o alinhamento e o apoio às iniciativas da API.",
   "station.competitive-analysis.title": "Análise competitiva - Fique à frente no mercado de API",
   "station.competitive-analysis.description": "Analisar as APIs dos concorrentes para identificar pontos fortes, pontos fracos e oportunidades de diferenciação.",
@@ -141,8 +141,8 @@
   "station.competitive-analysis.outcomes.2": "Estratégia de API baseada em informações sobre a concorrência",
   "station.competitive-analysis.outcomes.3": "Aumento da competitividade no mercado de API",
   "station.competitive-analysis.how_it_works": "Efetuar uma análise da concorrência para identificar os principais concorrentes, as suas ofertas de API e os seus pontos fortes e fracos.",
-  "station.competitive-analysis.how_it_works.1": "Identifique as lacunas no mercado que as suas API podem preencher, com base nas ofertas da concorrência.",
-  "station.competitive-analysis.how_it_works.2": "Desenvolva uma estratégia de diferenciação que destaque as caraterísticas e benefícios únicos das suas APIs.",
+  "station.competitive-analysis.how_it_works.1": "Identifique as lacunas no mercado que as suas APIs podem preencher, com base nas ofertas da concorrência.",
+  "station.competitive-analysis.how_it_works.2": "Desenvolva uma estratégia de diferenciação que destaque as características e benefícios únicos das suas APIs.",
   "station.ecosystem-vision.title": "Visão do ecossistema - Criar APIs para um ecossistema próspero",
   "station.ecosystem-vision.description": "Crie uma visão de como as suas APIs se encaixam num ecossistema maior, permitindo a colaboração e a inovação.",
   "station.ecosystem-vision.why_it_matters": "As APIs não são produtos autónomos; fazem parte de um ecossistema maior. Esta estação ajuda as equipas a definir como as suas APIs interagem com outros sistemas, plataformas e serviços para criar um ecossistema próspero que promove a colaboração e a inovação.",
@@ -150,7 +150,7 @@
   "station.ecosystem-vision.outcomes": "Definição de uma visão clara do ecossistema para as API",
   "station.ecosystem-vision.outcomes.1": "APIs concebidas para permitir a colaboração e a integração",
   "station.ecosystem-vision.outcomes.2": "Parceiros do ecossistema identificados e envolvidos",
-  "station.ecosystem-vision.outcomes.3": "As API contribuem para um ecossistema dinâmico",
+  "station.ecosystem-vision.outcomes.3": "As APIs contribuem para um ecossistema dinâmico",
   "station.ecosystem-vision.how_it_works": "Defina a visão do ecossistema para as suas APIs, incluindo a forma como estas irão interagir com outros sistemas e plataformas.",
   "station.ecosystem-vision.how_it_works.1": "Identificar os principais parceiros e intervenientes do ecosistema que irão beneficiar ou contribuir para o ecosistema.",
   "station.ecosystem-vision.how_it_works.2": "Conceber APIs para permitir uma integração e colaboração perfeitas no ecossistema.",
@@ -163,9 +163,9 @@
   "station.scalable-infrastructure.outcomes.2": "Infra-estruturas concebidas para o crescimento futuro",
   "station.scalable-infrastructure.outcomes.3": "Redução do tempo de inatividade e melhoria da experiência do utilizador",
   "station.scalable-infrastructure.how_it_works": "Conceber a infraestrutura da API para ser escalável e resiliente, utilizando padrões e tecnologias nativos da nuvem.",
-  "station.scalable-infrastructure.how_it_works.1": "Implementar o equilíbrio de carga, o armazenamento em cache e outras técnicas para garantir uma elevada disponibilidade e desempenho. Recolher os requisitos de infraestrutura das equipas de API utilizando o Capacity Canvas",
+  "station.scalable-infrastructure.how_it_works.1": "Implementar o equilíbrio de carga, o armazenamento em cache e outras técnicas para garantir uma elevada disponibilidade e desempenho. Recolher os requisitos de infraestrutura das equipas de API utilizando o Canvas de Capacidade",
   "station.scalable-infrastructure.how_it_works.2": "Monitorizar o desempenho e a capacidade da infraestrutura para garantir que esta consegue dar resposta à crescente procura.",
-  "station.legal-and-compliance.title": "Legal e Conformidade - Garantir que as APIs cumprem as normas regulamentares",
+  "station.legal-and-compliance.title": "Legal e Conformidade - Garantir que as APIs cumprems normas regulamentares",
   "station.legal-and-compliance.description": "Garanta que as APIs cumprem os requisitos legais e regulamentares, protegendo a sua organização e os seus utilizadores.",
   "station.legal-and-compliance.why_it_matters": "As APIs devem cumprir as normas legais e regulamentares para proteger a sua organização e os utilizadores. Esta estação fornece ferramentas e diretrizes para garantir que as APIs cumprem os requisitos de conformidade, reduzindo os riscos legais e garantindo a proteção de dados.",
   "station.legal-and-compliance.apply_in_work": "Fornecer estruturas legais e de conformidade, listas de verificação e ferramentas para garantir a conformidade da API. Assegurar que as equipas compreendem e implementam os requisitos legais na conceção, desenvolvimento e publicação de API.",
@@ -177,21 +177,21 @@
   "station.legal-and-compliance.how_it_works.1": "Implementar medidas para garantir que as APIs cumprem estes requisitos, incluindo encriptação de dados, controlos de acesso e pistas de auditoria.",
   "station.legal-and-compliance.how_it_works.2": "Documentar as medidas de conformidade e garantir que são comunicadas às partes interessadas e aos consumidores.",
   "station.security-and-privacy.title": "Segurança e privacidade - Proteja as suas APIs e os seus utilizadores",
-  "station.security-and-privacy.description": "Implementar medidas de segurança e privacidade para proteger as API e os dados dos utilizadores contra ameaças e violações.",
+  "station.security-and-privacy.description": "Implementar medidas de segurança e privacidade para proteger as APIs e os dados dos utilizadores contra ameaças e violações.",
   "station.security-and-privacy.why_it_matters": "As APIs são vulneráveis a ameaças de segurança e violações de dados. Esta estação fornece orientações para a implementação de medidas de segurança e privacidade que protegem as APIs e os dados dos utilizadores, garantindo a confiança e a conformidade.",
-  "station.security-and-privacy.apply_in_work": "Fornecer estruturas de segurança, ferramentas e melhores práticas para a segurança e privacidade da API. Assegurar que as equipas implementam medidas de segurança em todo o ciclo de vida da API, desde a conceção até à publicação e monitorização.",
+  "station.security-and-privacy.apply_in_work": "Fornecer estruturas de segurança, ferramentas e boas práticas para a segurança e privacidade da API. Assegurar que as equipas implementam medidas de segurança em todo o ciclo de vida da API, desde a conceção até à publicação e monitorização.",
   "station.security-and-privacy.outcomes": "APIs protegidas contra ameaças e vulnerabilidades",
   "station.security-and-privacy.outcomes.1": "Dados do utilizador protegidos através de medidas de privacidade",
-  "station.security-and-privacy.outcomes.2": "Melhores práticas de segurança implementadas na conceção e desenvolvimento de API",
+  "station.security-and-privacy.outcomes.2": "Boas práticas de segurança implementadas na conceção e desenvolvimento de API",
   "station.security-and-privacy.outcomes.3": "Conformidade com as normas e regulamentos de segurança",
   "station.security-and-privacy.how_it_works": "Implemente medidas de segurança como autenticação, autorização, encriptação e limitação de taxas para proteger as APIs de ameaças.",
   "station.security-and-privacy.how_it_works.1": "Garantir a privacidade dos dados dos utilizadores através da implementação de medidas de proteção de dados, como a anonimização e os controlos de acesso.",
   "station.security-and-privacy.how_it_works.2": "Efetuar auditorias de segurança regulares e avaliações de vulnerabilidade para identificar e atenuar os riscos.",
   "station.design-standards.title": "Normas de conceção - Garantir uma conceção de API consistente e de alta qualidade",
   "station.design-standards.description": "Estabelecer normas e diretrizes de design para garantir um design API consistente e de alta qualidade em toda a organização.",
-  "station.design-standards.why_it_matters": "Um design de API consistente e de alta qualidade é essencial para a usabilidade, manutenção e escalabilidade. Esta estação fornece normas e diretrizes de design que ajudam as equipas a criar APIs que são fáceis de utilizar, compreender e manter.",
+  "station.design-standards.why_it_matters": "Um conceção de API consistente e de alta qualidade é essencial para a usabilidade, manutenção e escalabilidade. Esta estação fornece normas e diretrizes de design que ajudam as equipas a criar APIs que são fáceis de utilizar, compreender e manter.",
   "station.design-standards.apply_in_work": "Fornecer documentação sobre normas de conceção, componentes reutilizáveis e processos de revisão da conceção. Assegurar que as equipas seguem as normas de conceção e realizam revisões regulares para manter uma conceção de API de alta qualidade.",
-  "station.design-standards.outcomes": "Design consistente da API em toda a organização",
+  "station.design-standards.outcomes": "Conceção consistente da API em toda a organização",
   "station.design-standards.outcomes.1": "APIs de alta qualidade que satisfazem as necessidades dos utilizadores",
   "station.design-standards.outcomes.2": "Componentes e padrões de conceção reutilizáveis",
   "station.design-standards.outcomes.3": "Redução das inconsistências de conceção e da dívida técnica",
@@ -207,45 +207,45 @@
   "station.vendor-management.outcomes.2": "Conformidade do fornecedor com as normas organizacionais",
   "station.vendor-management.outcomes.3": "Redução dos riscos associados a dependências de terceiros",
   "station.vendor-management.how_it_works": "Estabelecer processos de gestão de fornecedores para avaliar, integrar e monitorizar fornecedores de API de terceiros.",
-  "station.vendor-management.how_it_works.1": "Definir critérios para avaliar as API dos fornecedores, incluindo fiabilidade, segurança e conformidade.",
+  "station.vendor-management.how_it_works.1": "Definir critérios para avaliar as APIs dos fornecedores, incluindo fiabilidade, segurança e conformidade.",
   "station.vendor-management.how_it_works.2": "Monitorizar o desempenho dos fornecedores e o cumprimento dos acordos de nível de serviço (SLA) e das normas organizacionais.",
-  "station.contract-design.title": "Conceção de contratos - Definir contratos API claros",
-  "station.contract-design.description": "Criar contratos de API claros e bem definidos que descrevam as expectativas, responsabilidades e diretrizes de utilização.",
-  "station.contract-design.why_it_matters": "Os contratos de API são essenciais para garantir a clareza e o alinhamento entre os fornecedores e os consumidores de API. Esta estação fornece diretrizes para a conceção de contratos de API que sejam claros, abrangentes e fáceis de compreender.",
-  "station.contract-design.apply_in_work": "Fornecer modelos de design de contratos, formatos padronizados e processos de revisão. Assegurar que as equipas criam contratos de API claros e bem definidos que descrevem as expectativas, responsabilidades e diretrizes de utilização.",
-  "station.contract-design.outcomes": "Contratos API claros definidos para cada API",
+  "station.contract-design.title": "Conceção de contratos - Definir contratos de interface da API claros",
+  "station.contract-design.description": "Criar contratos de interface da API claros e bem definidos que descrevam as expectativas, responsabilidades e diretrizes de utilização.",
+  "station.contract-design.why_it_matters": "Os contratos de interface da API são essenciais para garantir a clareza e o alinhamento entre os fornecedores e os consumidores de API. Esta estação fornece diretrizes para a conceção de contratos de interface da API que sejam claros, abrangentes e fáceis de compreender.",
+  "station.contract-design.apply_in_work": "Fornecer modelos de design de contratos, formatos normalizados e processos de revisão. Assegurar que as equipas criam contratos de interface da API claros e bem definidos que descrevem as expectativas, responsabilidades e diretrizes de utilização.",
+  "station.contract-design.outcomes": "Contratos de interface da API claros definidos para cada API",
   "station.contract-design.outcomes.1": "Expectativas e responsabilidades definidas para os fornecedores e consumidores de API",
-  "station.contract-design.outcomes.2": "Orientações de utilização e melhores práticas documentadas",
+  "station.contract-design.outcomes.2": "Orientações de utilização e boas práticas documentadas",
   "station.contract-design.outcomes.3": "Redução de mal-entendidos e litígios sobre a utilização da API",
-  "station.contract-design.how_it_works": "Definir contratos de API que descrevam as expectativas, responsabilidades e diretrizes de utilização para cada API.",
-  "station.contract-design.how_it_works.1": "Utilizar formatos normalizados (por exemplo, OpenAPI, AsyncAPI) para criar contratos de API legíveis por máquina que sejam fáceis de partilhar e validar.",
-  "station.contract-design.how_it_works.2": "Assegurar que os contratos API são revistos e aprovados pelas partes interessadas para garantir o alinhamento e a clareza.",
-  "station.development.title": "Desenvolvimento - Criar APIs com as melhores práticas",
-  "station.development.description": "Implementar APIs utilizando as melhores práticas e estruturas para garantir a qualidade, a capacidade de manutenção e a escalabilidade.",
-  "station.development.why_it_matters": "O desenvolvimento de API é uma fase crítica que determina a qualidade e a fiabilidade da API. Esta estação fornece as melhores práticas e estruturas para o desenvolvimento de APIs, garantindo que as APIs são construídas de acordo com padrões elevados e podem ser mantidas e escaladas de forma eficaz.",
-  "station.development.apply_in_work": "Fornecer estruturas de desenvolvimento, bibliotecas e normas de codificação para a implementação da API. Garantir que as equipas seguem as melhores práticas e realizam revisões de código para manter um desenvolvimento de API de alta qualidade.",
-  "station.development.outcomes": "APIs desenvolvidas utilizando as melhores práticas e estruturas",
+  "station.contract-design.how_it_works": "Definir contratos de interface da API que descrevam as expectativas, responsabilidades e diretrizes de utilização para cada API.",
+  "station.contract-design.how_it_works.1": "Utilizar formatos normalizados (por exemplo, OpenAPI, AsyncAPI) para criar contratos de interface da API legíveis por máquina que sejam fáceis de partilhar e validar.",
+  "station.contract-design.how_it_works.2": "Assegurar que os contratos de interface da API são revistos e aprovados pelas partes interessadas para garantir o alinhamento e a clareza.",
+  "station.development.title": "Desenvolvimento - Criar APIs com as boas práticas",
+  "station.development.description": "Implementar APIs utilizando as boas práticas e estruturas para garantir a qualidade, a capacidade de manutenção e a escalabilidade.",
+  "station.development.why_it_matters": "O desenvolvimento de API é uma fase crítica que determina a qualidade e a fiabilidade da API. Esta estação fornece as boas práticas e estruturas para o desenvolvimento de APIs, garantindo que as APIs são construídas de acordo com padrões elevados e podem ser mantidas e escaladas de forma eficaz.",
+  "station.development.apply_in_work": "Fornecer estruturas de desenvolvimento, bibliotecas e normas de codificação para a implementação da API. Garantir que as equipas seguem as boas práticas e realizam revisões de código para manter um desenvolvimento de API de alta qualidade.",
+  "station.development.outcomes": "APIs desenvolvidas utilizando as boas práticas e estruturas",
   "station.development.outcomes.1": "APIs de alta qualidade, fáceis de manter e escaláveis",
   "station.development.outcomes.2": "Seguimento de normas e práticas de codificação consistentes",
   "station.development.outcomes.3": "Redução do tempo de desenvolvimento e da dívida técnica",
   "station.development.how_it_works": "Utilizar estruturas e bibliotecas estabelecidas para implementar APIs, assegurando a sua reutilização e manutenção.",
-  "station.development.how_it_works.1": "Aplicar abordagens \"contract-first\" ou \"design-first\" para garantir que os contratos API são validados antes da implementação.",
-  "station.development.how_it_works.2": "Seguir as normas de codificação e as melhores práticas para garantir um desenvolvimento de API consistente e de alta qualidade.",
+  "station.development.how_it_works.1": "Aplicar abordagens \"contract-first\" ou \"design-first\" para garantir que os contratos de interface da API são validados antes da implementação.",
+  "station.development.how_it_works.2": "Seguir as normas de codificação e as boas práticas para garantir um desenvolvimento de API consistente e de alta qualidade.",
   "station.ci-cd.title": "CI/CD - Automatizar a entrega da API",
   "station.ci-cd.description": "Implementar pipelines de integração contínua e entrega contínua (CI/CD) para automatizar a entrega de API e garantir uma qualidade consistente.",
-  "station.ci-cd.why_it_matters": "A CI/CD é essencial para garantir que as APIs sejam entregues rapidamente, de forma confiável e com alta qualidade. Esta estação fornece diretrizes para a implementação de pipelines de CI/CD que automatizam os processos de criação, teste e implantação de APIs.",
-  "station.ci-cd.apply_in_work": "Fornecer estruturas, ferramentas e melhores práticas de CI/CD para a entrega de API. Garantir que as equipas implementam pipelines automatizados que suportam a integração, os testes e a implementação contínuos de APIs.",
+  "station.ci-cd.why_it_matters": "A CI/CD é essencial para garantir que as APIs sejam entregues rapidamente, de forma confiável e com alta qualidade. Esta estação fornece diretrizes para a implementação de pipelines de CI/CD que automatizam os processos de criação, teste e disponibilização de APIs.",
+  "station.ci-cd.apply_in_work": "Fornecer estruturas, ferramentas e boas práticas de CI/CD para a entrega de API. Garantir que as equipas implementam pipelines automatizados que suportam a integração, os testes e a implementação contínuos de APIs.",
   "station.ci-cd.outcomes": "Pipelines CI/CD automatizados estabelecidos para a entrega de API",
   "station.ci-cd.outcomes.1": "Qualidade e rastreabilidade consistentes na entrega de API",
   "station.ci-cd.outcomes.2": "iterações mais rápidas e redução do tempo de colocação no mercado",
   "station.ci-cd.outcomes.3": "Melhoria da colaboração e dos ciclos de feedback no desenvolvimento de API",
-  "station.ci-cd.how_it_works": "Utilize pipelines CI/CD para automatizar os processos de construção, teste e implantação, garantindo qualidade e rastreabilidade consistentes.",
-  "station.ci-cd.how_it_works.1": "Integrar testes funcionais e não funcionais no pipeline CI/CD para garantir que as APIs cumprem as normas de qualidade.",
+  "station.ci-cd.how_it_works": "Utilize pipelines CI/CD para automatizar os processos de construção, teste e disponibilização, garantindo qualidade e rastreabilidade consistentes.",
+  "station.ci-cd.how_it_works.1": "Integrar testes funcionais e não funcionais no pipeline CI/CD para garantir que as APIs cumprems normas de qualidade.",
   "station.ci-cd.how_it_works.2": "Implementar verificações de segurança automatizadas e validações de conformidade no pipeline CI/CD para garantir que as APIs são seguras e compatíveis.",
   "station.test-automation.title": "Automatização de testes - Garantir a qualidade da API",
   "station.test-automation.description": "Implementar práticas de teste automatizadas para garantir a qualidade, fiabilidade e desempenho da API.",
-  "station.test-automation.why_it_matters": "Os testes automatizados são cruciais para garantir que as APIs funcionam corretamente e cumprem as normas de qualidade. Esta estação fornece diretrizes para a implementação de práticas de teste automatizado que abrangem testes funcionais, de segurança e de desempenho para APIs.",
-  "station.test-automation.apply_in_work": "Fornecer estruturas de automatização de testes, ferramentas e melhores práticas para testes de API. Assegurar que as equipas implementam testes automatizados que abrangem aspectos funcionais, de segurança e de desempenho das API.",
+  "station.test-automation.why_it_matters": "Os testes automatizados são cruciais para garantir que as APIs funcionam corretamente e cumprems normas de qualidade. Esta estação fornece diretrizes para a implementação de práticas de teste automatizado que abrangem testes funcionais, de segurança e de desempenho para APIs.",
+  "station.test-automation.apply_in_work": "Fornecer estruturas de automatização de testes, ferramentas e boas práticas para testes de API. Assegurar que as equipas implementam testes automatizados que abrangem aspectos funcionais, de segurança e de desempenho das APIs.",
   "station.test-automation.outcomes": "Práticas de teste automatizadas implementadas para APIs",
   "station.test-automation.outcomes.1": "Testes funcionais, de segurança e de desempenho automatizados",
   "station.test-automation.outcomes.2": "Redução do esforço de teste manual e aumento da cobertura dos testes",
@@ -256,18 +256,18 @@
   "station.release-management.title": "Gestão de versões - Gerir eficazmente as versões da API",
   "station.release-management.description": "Implementar práticas de gestão de lançamentos para garantir lançamentos de API sem problemas e controlados.",
   "station.release-management.why_it_matters": "A gestão eficaz de lançamentos é essencial para garantir que os lançamentos de APIs sejam fáceis, controlados e alinhados com as necessidades do negócio. Esta estação fornece diretrizes para a gestão de lançamentos de API, incluindo versões, estratégias de implementação e procedimentos de reversão.",
-  "station.release-management.apply_in_work": "Fornecer estruturas de gestão de versões, diretrizes de controlo de versões e estratégias de implementação. Assegurar que as equipas seguem as melhores práticas para a gestão de lançamentos de API, incluindo procedimentos de versão, implementação e reversão.",
+  "station.release-management.apply_in_work": "Fornecer estruturas de gestão de versões, diretrizes de controlo de versões e estratégias de implementação. Assegurar que as equipas seguem as boas práticas para a gestão de lançamentos de API, incluindo procedimentos de versão, implementação e reversão.",
   "station.release-management.outcomes": "Lançamentos de API controlados e sem problemas",
-  "station.release-management.outcomes.1": "Definição de estratégias de versão e implantação",
+  "station.release-management.outcomes.1": "Definição de estratégias de versão e disponibilização",
   "station.release-management.outcomes.2": "Procedimentos de reversão estabelecidos para libertações de API",
   "station.release-management.outcomes.3": "Redução dos riscos associados às alterações da API",
-  "station.release-management.how_it_works": "Definir estratégias de controlo de versões para as API para gerir as alterações e garantir a compatibilidade com as versões anteriores.",
-  "station.release-management.how_it_works.1": "Implementar estratégias de implantação (por exemplo, implantações blue-green, lançamentos canários) para minimizar os riscos durante os lançamentos de API.",
+  "station.release-management.how_it_works": "Definir estratégias de controlo de versões para as APIs para gerir as alterações e garantir a compatibilidade com as versões anteriores.",
+  "station.release-management.how_it_works.1": "Implementar estratégias de disponibilização (por exemplo, disponibilizações blue-green, lançamentos canários) para minimizar os riscos durante os lançamentos de API.",
   "station.release-management.how_it_works.2": "Estabelecer procedimentos de reversão para reverter rapidamente as alterações em caso de problemas durante os lançamentos da API.",
   "station.service-agreements.title": "Acordos de serviço - Definir níveis de serviço de API",
   "station.service-agreements.description": "Estabelecer acordos de serviço que definam as expectativas, os níveis de serviço e as responsabilidades dos fornecedores e consumidores de API.",
   "station.service-agreements.why_it_matters": "Os acordos de serviço são essenciais para garantir a clareza e o alinhamento entre os fornecedores de API e os consumidores. Esta estação fornece diretrizes para a criação de acordos de serviço que definem expectativas, níveis de serviço e responsabilidades, reduzindo mal-entendidos e disputas.",
-  "station.service-agreements.apply_in_work": "Fornecer modelos de contratos de serviço, formatos padronizados e processos de revisão. Garantir que as equipas criam contratos de serviço claros e bem definidos que descrevem as expectativas, os níveis de serviço e as responsabilidades dos fornecedores e consumidores de API.",
+  "station.service-agreements.apply_in_work": "Fornecer modelos de contratos de serviço, formatos normalizados e processos de revisão. Garantir que as equipas criam contratos de serviço claros e bem definidos que descrevem as expectativas, os níveis de serviço e as responsabilidades dos fornecedores e consumidores de API.",
   "station.service-agreements.outcomes": "Acordos de serviço claros definidos para cada API",
   "station.service-agreements.outcomes.1": "Expectativas e níveis de serviço definidos para fornecedores e consumidores de API",
   "station.service-agreements.outcomes.2": "Responsabilidades e processos de apoio documentados",
@@ -276,33 +276,33 @@
   "station.service-agreements.how_it_works.1": "Utilize formatos normalizados para criar contratos de serviço legíveis por máquina que sejam fáceis de partilhar e validar.",
   "station.service-agreements.how_it_works.2": "Assegurar que os acordos de serviço são revistos e aprovados pelas partes interessadas para garantir o alinhamento e a clareza.",
   "station.api-consumer-adoption.title": "Adoção pelo consumidor da API - Impulsionar a utilização da API",
-  "station.api-consumer-adoption.description": "Implementar estratégias para promover a adoção e o envolvimento dos consumidores de API, assegurando que as API são utilizadas eficazmente.",
-  "station.api-consumer-adoption.why_it_matters": "A adoção pelos consumidores de APIs é crucial para a concretização do valor das APIs. Esta estação fornece estratégias e práticas recomendadas para envolver os consumidores de API, garantindo que eles entendam como usar as APIs de forma eficaz e obter valor delas.",
+  "station.api-consumer-adoption.description": "Implementar estratégias para promover a adoção e o envolvimento dos consumidores de API, assegurando que as APIs são utilizadas eficazmente.",
+  "station.api-consumer-adoption.why_it_matters": "A adoção pelos consumidores de APIs é crucial para a concretização do valor das APIs. Esta estação fornece estratégias e boas práticas para envolver os consumidores de API, garantindo que eles entendam como utilizar as APIs de forma eficaz e obter valor delas.",
   "station.api-consumer-adoption.apply_in_work": "Fornecer recursos de integração, materiais educativos e estratégias de envolvimento para os consumidores da API. Assegurar que as equipas implementam estratégias que promovem a adoção, o envolvimento e a satisfação dos consumidores da API.",
   "station.api-consumer-adoption.outcomes": "Estratégias de adoção pelos consumidores da API implementadas",
   "station.api-consumer-adoption.outcomes.1": "Aumento da utilização e do envolvimento da API",
-  "station.api-consumer-adoption.outcomes.2": "Consumidores da API informados sobre as caraterísticas e vantagens da API",
+  "station.api-consumer-adoption.outcomes.2": "Consumidores da API informados sobre as características e vantagens da API",
   "station.api-consumer-adoption.outcomes.3": "Melhoria da satisfação e da lealdade do consumidor API",
-  "station.api-consumer-adoption.how_it_works": "Desenvolver processos de integração e recursos para ajudar os consumidores de API a compreender como utilizar as API de forma eficaz.",
-  "station.api-consumer-adoption.how_it_works.1": "Criar materiais educativos (por exemplo, tutoriais, documentação) que expliquem as caraterísticas, as vantagens e os padrões de utilização da API.",
+  "station.api-consumer-adoption.how_it_works": "Desenvolver processos de integração e recursos para ajudar os consumidores de API a compreender como utilizar as APIs de forma eficaz.",
+  "station.api-consumer-adoption.how_it_works.1": "Criar materiais educativos (por exemplo, tutoriais, documentação) que expliquem as características, as vantagens e os padrões de utilização da API.",
   "station.api-consumer-adoption.how_it_works.2": "Interagir com os consumidores da API através de ciclos de feedback, canais de apoio e fóruns da comunidade para compreender as suas necessidades e melhorar a adoção da API.",
   "station.api-promotion.title": "Promoção da API - Aumente a visibilidade e a utilização da API",
-  "station.api-promotion.description": "Promover as API para aumentar a visibilidade, a utilização e a adoção entre os públicos-alvo.",
-  "station.api-promotion.why_it_matters": "A promoção das APIs é essencial para aumentar a sua visibilidade e impulsionar a sua utilização. Esta estação fornece estratégias e melhores práticas para promover eficazmente as APIs junto de públicos-alvo, assegurando que estes têm conhecimento das APIs e compreendem o seu valor.",
+  "station.api-promotion.description": "Promover as APIs para aumentar a visibilidade, a utilização e a adoção entre os públicos-alvo.",
+  "station.api-promotion.why_it_matters": "A promoção das APIs é essencial para aumentar a sua visibilidade e impulsionar a sua utilização. Esta estação fornece estratégias e boas práticas para promover eficazmente as APIs junto de públicos-alvo, assegurando que estes têm conhecimento das APIs e compreendem o seu valor.",
   "station.api-promotion.apply_in_work": "Fornecer estratégias de marketing, materiais promocionais e recursos de envolvimento da comunidade. Assegurar que as equipas implementam estratégias eficazes de promoção da API que aumentam a visibilidade, a utilização e a adoção entre os públicos-alvo.",
   "station.api-promotion.outcomes": "Estratégias de promoção da API implementadas",
   "station.api-promotion.outcomes.1": "Maior visibilidade e conhecimento da API",
   "station.api-promotion.outcomes.2": "Taxas de utilização e adoção de API mais elevadas",
   "station.api-promotion.outcomes.3": "Melhoria do envolvimento e da satisfação dos consumidores da API",
-  "station.api-promotion.how_it_works": "Desenvolver estratégias de marketing para promover as API junto de públicos-alvo, incluindo redes sociais, blogues e webinars.",
-  "station.api-promotion.how_it_works.1": "Criar materiais promocionais (por exemplo, estudos de casos, histórias de sucesso) que realcem o valor e as vantagens das API.",
+  "station.api-promotion.how_it_works": "Desenvolver estratégias de marketing para promover as APIs junto de públicos-alvo, incluindo redes sociais, blogues e webinars.",
+  "station.api-promotion.how_it_works.1": "Criar materiais promocionais (por exemplo, estudos de casos, histórias de sucesso) que realcem o valor e as vantagens das APIs.",
   "station.api-promotion.how_it_works.2": "Participar em comunidades e fóruns de API para partilhar actualizações da API, recolher feedback e promover a utilização da API.",
   "station.partner-integration.title": "Integração de parceiros - Colaborar com parceiros",
   "station.partner-integration.description": "Facilitar as integrações de parceiros para melhorar as capacidades da API e expandir o alcance.",
   "station.partner-integration.why_it_matters": "As integrações de parceiros podem melhorar as capacidades da API e expandir o seu alcance. Esta estação fornece diretrizes para colaborar com os parceiros na integração das suas APIs, garantindo uma interoperabilidade perfeita e a criação de valor.",
   "station.partner-integration.apply_in_work": "Fornecer estruturas de integração de parceiros, diretrizes e ferramentas de monitorização. Garantir que as equipas colaboram eficazmente com os parceiros para melhorar as capacidades da API, expandir o alcance e impulsionar a inovação.",
   "station.partner-integration.outcomes": "Processos de integração de parceiros estabelecidos",
-  "station.partner-integration.outcomes.1": "Capacidades API melhoradas através de APIs de parceiros",
+  "station.partner-integration.outcomes.1": "Capacidades API melhoradas através de API de parceiros",
   "station.partner-integration.outcomes.2": "Maior alcance e oportunidades de mercado através de parcerias",
   "station.partner-integration.outcomes.3": "Melhoria da colaboração e da inovação com os parceiros",
   "station.partner-integration.how_it_works": "Identifique potenciais parceiros cujas APIs possam melhorar as suas capacidades de API e a sua proposta de valor.",
@@ -310,15 +310,15 @@
   "station.partner-integration.how_it_works.2": "Monitorize o desempenho e a conformidade da API do parceiro para garantir a fiabilidade e o alinhamento com a sua estratégia de API.",
   "station.api-mindset.title": "Mentalidade API - Promover uma cultura API-First",
   "station.api-mindset.description": "Cultivar uma mentalidade API-first em toda a organização para impulsionar a inovação e a colaboração.",
-  "station.api-mindset.why_it_matters": "Uma mentalidade API-first é essencial para promover a inovação e a colaboração em toda a organização. Esta estação fornece estratégias para cultivar uma cultura API-first, garantindo que as APIs sejam vistas como activos estratégicos que geram valor comercial.",
+  "station.api-mindset.why_it_matters": "Uma mentalidade API-first é essencial para promover a inovação e a colaboração em toda a organização. Esta estação fornece estratégias para cultivar uma cultura API-first, garantindo que as APIs sejam vistas como activos estratégicos que geram valor de negócio.",
   "station.api-mindset.apply_in_work": "Fornecer programas de formação, recursos e estratégias de comunicação para promover uma cultura de prioridade à API. Assegurar que as equipas compreendem o valor das APIs e estão habilitadas a conduzir a estratégia e as iniciativas das APIs.",
   "station.api-mindset.outcomes": "Cultura API-first estabelecida em toda a organização",
-  "station.api-mindset.outcomes.1": "Maior inovação e colaboração através de APIs",
+  "station.api-mindset.outcomes.1": "Maior inovação e colaboração através de API",
   "station.api-mindset.outcomes.2": "Equipas de API habilitadas a conduzir a estratégia e as iniciativas de API",
-  "station.api-mindset.outcomes.3": "Melhoria do alinhamento entre os objectivos comerciais e o desenvolvimento de API",
-  "station.api-mindset.how_it_works": "Promover o valor das APIs como activos estratégicos que geram valor comercial e inovação.",
-  "station.api-mindset.how_it_works.1": "Incentivar a colaboração multifuncional entre equipas de API, unidades empresariais e partes interessadas para alinhar as iniciativas de API com os objectivos empresariais.",
-  "station.api-mindset.how_it_works.2": "Fornecer formação e recursos para ajudar as equipas a adotar uma mentalidade de prioridade à API e a compreender as vantagens das API.",
+  "station.api-mindset.outcomes.3": "Melhoria do alinhamento entre os objetivos de negócio e o desenvolvimento de API",
+  "station.api-mindset.how_it_works": "Promover o valor das APIs como activos estratégicos que geram valor de negócio e inovação.",
+  "station.api-mindset.how_it_works.1": "Incentivar a colaboração multifuncional entre equipas de API, unidades empresariais e partes interessadas para alinhar as iniciativas de API com os objetivos empresariais.",
+  "station.api-mindset.how_it_works.2": "Fornecer formação e recursos para ajudar as equipas a adotar uma mentalidade de prioridade à API e a compreender as vantagens das APIs.",
   "station.roles-and-responsibilities.title": "Funções e responsabilidades - Definir as estruturas da equipa API",
   "station.roles-and-responsibilities.description": "Definir funções e responsabilidades claras para as equipas de API para garantir uma colaboração e responsabilização eficazes.",
   "station.roles-and-responsibilities.why_it_matters": "Funções e responsabilidades claras são essenciais para uma colaboração e responsabilidade eficazes nas equipas de API. Esta estação fornece diretrizes para a definição das estruturas, funções e responsabilidades da equipa, assegurando que todos compreendem as suas contribuições para as iniciativas da API.",
@@ -339,39 +339,225 @@
   "station.upskilling.outcomes.2": "Melhoria da capacidade de adoção de novas tecnologias e práticas",
   "station.upskilling.outcomes.3": "Equipas capacitadas para impulsionar a inovação e a qualidade da API",
   "station.upskilling.how_it_works": "Identificar as principais competências e áreas de conhecimento da API que precisam de ser melhoradas, como a conceção, a segurança e o desempenho da API.",
-  "station.upskilling.how_it_works.1": "Fornecer programas de formação, workshops e recursos para ajudar as equipas a melhorar as suas competências e conhecimentos em matéria de API.",
-  "station.upskilling.how_it_works.2": "Incentivar a aprendizagem contínua através de cursos em linha, certificações e envolvimento da comunidade.",
   "station.operating-guidelines.title": "Diretrizes operacionais - Estabelecer a governação da API",
   "station.operating-guidelines.description": "Estabelecer diretrizes operacionais e práticas de governação para garantir uma gestão e qualidade consistentes da API.",
-  "station.operating-guidelines.why_it_matters": "A governação eficaz da API é essencial para garantir uma gestão, qualidade e conformidade consistentes da API. Esta estação fornece diretrizes operacionais e práticas de governação que ajudam as equipas a gerir as APIs de forma eficaz, assegurando o seu alinhamento com as normas organizacionais e as melhores práticas.",
+  "station.operating-guidelines.why_it_matters": "A governação eficaz da API é essencial para garantir uma gestão, qualidade e conformidade consistentes da API. Esta estação fornece diretrizes operacionais e práticas de governação que ajudam as equipas a gerir as APIs de forma eficaz, assegurando o seu alinhamento com as normas organizacionais e as boas práticas.",
   "station.operating-guidelines.apply_in_work": "Fornecer diretrizes operacionais, quadros de governação e ferramentas de monitorização para a gestão de API. Assegurar que as equipas seguem as práticas estabelecidas que promovem a gestão consistente da API, a qualidade e a conformidade com as normas organizacionais.",
   "station.operating-guidelines.outcomes": "Práticas de governação da API estabelecidas",
   "station.operating-guidelines.outcomes.1": "Gestão e qualidade consistentes da API em toda a organização",
-  "station.operating-guidelines.outcomes.2": "Conformidade com as normas organizacionais e as melhores práticas",
+  "station.operating-guidelines.outcomes.2": "Conformidade com as normas organizacionais e as boas práticas",
   "station.operating-guidelines.outcomes.3": "Melhoria da visibilidade e do controlo das iniciativas API",
-  "station.operating-guidelines.how_it_works": "Definir diretrizes operacionais baseadas nos Ciclos APIOps que descrevem os processos, as normas e as melhores práticas para a gestão de API.",
-  "station.operating-guidelines.how_it_works.1": "Estabelecer práticas de governação que garantam que as API são geridas de forma consistente, incluindo análises, auditorias e verificações de conformidade.",
-  "station.operating-guidelines.how_it_works.2": "Monitorizar as iniciativas API para garantir o cumprimento das orientações operacionais e das práticas de governação",
+  "station.operating-guidelines.how_it_works": "Definir diretrizes operacionais baseadas nos Ciclos APIOps que descrevem os processos, as normas e as boas práticas para a gestão de API.",
+  "station.operating-guidelines.how_it_works.1": "Estabelecer práticas de governação que garantam que as APIs são geridas de forma consistente, incluindo análises, auditorias e verificações de conformidade.",
+  "station.operating-guidelines.how_it_works.2": "Monitorizar as iniciativas APIs para garantir o cumprimento das orientações operacionais e das práticas de governação",
   "station.portfolio-management.title": "Gestão de portfólio - Gerir eficazmente o portfólio de API",
-  "station.portfolio-management.description": "Gerir eficazmente a carteira de API para garantir o alinhamento com os objectivos comerciais e as iniciativas estratégicas.",
-  "station.portfolio-management.why_it_matters": "O gerenciamento eficaz do portfólio de APIs é essencial para garantir que as APIs se alinhem às metas comerciais e às iniciativas estratégicas. Esta estação fornece diretrizes para o gerenciamento do portfólio de APIs, garantindo que as APIs sejam priorizadas, monitoradas e otimizadas para fornecer o máximo de valor.",
-  "station.portfolio-management.apply_in_work": "Fornecer estruturas de gestão de carteiras, critérios de priorização e ferramentas de monitorização para a gestão de API. Assegurar que as equipas gerem eficazmente o portfólio de API, garantindo o alinhamento com os objectivos comerciais, as iniciativas estratégicas e a obtenção do máximo valor.",
+  "station.portfolio-management.description": "Gerir eficazmente a carteira de API para garantir o alinhamento com os objetivos de negócio e as iniciativas estratégicas.",
+  "station.portfolio-management.why_it_matters": "O gestão eficaz do portfólio de APIs é essencial para garantir que as APIs se alinhem às metas comerciais e às iniciativas estratégicas. Esta estação fornece diretrizes para o gestão do portfólio de APIs, garantindo que as APIs sejam priorizadas, monitoradas e otimizadas para fornecer o máximo de valor.",
+  "station.portfolio-management.apply_in_work": "Fornecer estruturas de gestão de carteiras, critérios de priorização e ferramentas de monitorização para a gestão de API. Assegurar que as equipas gerem eficazmente o portfólio de API, garantindo o alinhamento com os objetivos de negócio, as iniciativas estratégicas e a obtenção do máximo valor.",
   "station.portfolio-management.outcomes": "Estabelecimento de práticas de gestão de carteiras API",
-  "station.portfolio-management.outcomes.1": "APIs alinhadas com objectivos comerciais e iniciativas estratégicas",
+  "station.portfolio-management.outcomes.1": "APIs alinhadas com objetivos de negócio e iniciativas estratégicas",
   "station.portfolio-management.outcomes.2": "Priorização e otimização de APIs com base no valor e no impacto",
   "station.portfolio-management.outcomes.3": "Melhoria da visibilidade e do controlo da carteira de API",
   "station.portfolio-management.how_it_works": "Definir práticas de gestão da carteira que descrevam os processos de gestão da carteira de API, incluindo a definição de prioridades, a monitorização e a otimização.",
-  "station.portfolio-management.how_it_works.1": "Estabelecer critérios para avaliar e dar prioridade às APIs com base no valor comercial, no impacto e no alinhamento com iniciativas estratégicas.",
-  "station.portfolio-management.how_it_works.2": "Monitorizar a carteira de APIs para garantir que as APIs estão a fornecer valor, a cumprir as expectativas de desempenho e a alinhar-se com os objectivos comerciais.",
   "station.budget-and-resource-management.title": "Orçamento e gestão de recursos - Otimizar os investimentos em API",
   "station.budget-and-resource-management.description": "Otimizar o orçamento e a gestão de recursos para as iniciativas API, a fim de garantir investimentos e atribuição de recursos eficazes.",
-  "station.budget-and-resource-management.why_it_matters": "A gestão eficaz do orçamento e dos recursos é essencial para garantir que as iniciativas de API sejam bem financiadas e dotadas de recursos. Esta estação fornece diretrizes para otimizar a gestão do orçamento e dos recursos, assegurando que as iniciativas de API estão alinhadas com os objectivos comerciais e proporcionam o máximo valor.",
+  "station.budget-and-resource-management.why_it_matters": "A gestão eficaz do orçamento e dos recursos é essencial para garantir que as iniciativas de API sejam bem financiadas e dotadas de recursos. Esta estação fornece diretrizes para otimizar a gestão do orçamento e dos recursos, assegurando que as iniciativas de API estão alinhadas com os objetivos de negócio e proporcionam o máximo valor.",
   "station.budget-and-resource-management.apply_in_work": "Fornecer estruturas de gestão orçamental, critérios de prioritização e ferramentas de monitorização para iniciativas de API. Assegurar que as equipas gerem eficazmente os orçamentos e os recursos, optimizando os investimentos no desenvolvimento e na gestão de API para obter o máximo valor.",
   "station.budget-and-resource-management.outcomes": "Práticas de gestão orçamental e de recursos estabelecidas para as iniciativas API",
   "station.budget-and-resource-management.outcomes.1": "Afetação efectiva de recursos às iniciativas API",
   "station.budget-and-resource-management.outcomes.2": "Investimentos optimizados no desenvolvimento e gestão de API",
   "station.budget-and-resource-management.outcomes.3": "Melhoria da visibilidade financeira e do controlo das iniciativas API",
   "station.budget-and-resource-management.how_it_works": "Definir práticas de gestão orçamental e de recursos que descrevam os processos de gestão de orçamentos e recursos para iniciativas de API.",
-  "station.budget-and-resource-management.how_it_works.1": "Estabelecer critérios para avaliar e dar prioridade às dotações orçamentais com base no valor comercial, no impacto e no alinhamento com as iniciativas estratégicas.",
-  "station.budget-and-resource-management.how_it_works.2": "Controlar o orçamento e a utilização dos recursos para garantir investimentos eficazes e a afetação de recursos às iniciativas da API."
+  "cycle.api-productization-cycle.station.api-product-strategy.title": "Estratégia de produtos API - Transforme APIs em produtos estratégicos",
+  "cycle.api-productization-cycle.station.api-product-strategy.description": "Antes de construir qualquer coisa, defina o valor da sua API, os utilizadores e os objetivos de negócio desde o primeiro dia.",
+  "cycle.api-productization-cycle.station.api-product-strategy.why_it_matters": "Muitas organizações pensam nas APIs como projetos tecnológicos e não como produtos. O resultado? Consumidores confusos, fraca adoção e esforço desperdiçado.\n\nEsta estação ajuda-o a definir o objetivo da sua API, o público-alvo e os critérios de sucesso, para que as equipas possam fornecer APIs que resolvam problemas reais.",
+  "cycle.api-productization-cycle.station.api-product-strategy.apply_in_work": "Fornecer diretrizes e modelos para a criação de modelos comerciais, propostas de valor e roteiros de API.",
+  "cycle.api-productization-cycle.station.api-product-strategy.outcomes": "Uma proposta de valor e um público-alvo da API simples",
+  "cycle.api-productization-cycle.station.api-product-strategy.outcomes.1": "Linguagem partilhada entre o produto, a conceção e a tecnologia",
+  "cycle.api-productization-cycle.station.api-product-strategy.outcomes.2": "Um argumento sólido ou um caso para financiamento/aprovação",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works": "Explore o problema do cliente ou parceiro que espera resolver com as APIs. Mapeie as partes interessadas, os seus percursos e os resultados utilizando a Canvas do Percurso do Cliente.",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works.1": "Definir as entidades principais, os seus atributos e relações para criar um entendimento concetual partilhado entre jornadas e, eventualmente, APIs.",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works.2": "Utilize o Canvas da Proposta de Valor da API para capturar as tarefas de negócios suportadas e as dores, ganhos e recursos do consumidor da API que moldam APIs novas ou reutilizáveis.",
+  "cycle.api-productization-cycle.station.api-product-strategy.how_it_works.3": "Defina o valor - para os utilizadores e para a empresa - com a Canvas do Modelo de Negócio da API para tornar a sua estratégia de API visual, partilhável e fácil de validar com os seus consumidores de API na estação seguinte.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.title": "Experiência do consumidor da API - Conceção para os utilizadores reais da sua API",
+  "cycle.api-productization-cycle.station.api-consumer-experience.description": "Certifique-se de que a sua API é detetável, compreensível e utilizável - antes e depois do lançamento.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.why_it_matters": "As APIs excelentes não funcionam apenas - elas são intuitivas. Quer o consumidor seja um programador interno, um parceiro externo ou um agente de IA, a sua experiência determina a adoção.\n\nSnum plano de experiência claro:\n- Grandes APIs ficam sem uso\n- As equipas perdem tempo a tentar adivinhar como utilizar a sua API\n- Os ciclos de feedback estão quebrados ou ausentes.\n\nEsta estação ajuda-o a ver a sua API através dos olhos dos seus consumidores.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.how_it_works": "Analise o Canvas da Proposta de Valor da API existente sob a perspectiva do consumidor da API. Mantenha as tarefas de negócios suportadas estáveis ​​e enriqueça os recursos que aliviam problemas e possibilitam ganhos com as preocupações do consumidor da API, para que elas possam orientar as decisões de conceção futuras.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.how_it_works.1": "Utilize o Canvas do Percurso do Cliente para a jornada do consumidor da API, desde a descoberta e avaliação até a integração, resolução de problemas e uso contínuo.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.how_it_works.2": "Utilize a jornada resultante para melhorar a integração, a documentação, o suporte e os ciclos de feedback para o consumidor da API.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.apply_in_work": "Fornecer diretrizes, ferramentas e mecanismos de feedback para compreender, analisar e melhorar a experiência interna e externa dos programadores e parceiros.",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes": "Identifique e dê prioridade aos seus consumidores de API",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes.1": "Definir o percurso da experiência API",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes.2": "Planeamento da integração, documentação e feedback",
+  "cycle.api-productization-cycle.station.api-consumer-experience.outcomes.3": "Melhorar a adoção através de empatia genuína + Experiência do Programador (DX)",
+  "cycle.api-productization-cycle.station.api-platform-architecture.title": "Arquitetura da plataforma API - Arquitetar APIs para escalabilidade e reutilização",
+  "cycle.api-productization-cycle.station.api-platform-architecture.description": "Garanta a escalabilidade, a reutilização e a governação da sua API e dos componentes da plataforma.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.why_it_matters": "Quando as APIs são escalonadas entre equipas, a sua plataforma deve permitir a governação e a reutilização sem bloquear a velocidade. Esta estação mostra como arquitetar APIs para longevidade, segurança e eficiência.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.apply_in_work": "Estabelecer uma infraestrutura escalável, segura e compatível com as operações de API. Fornecer orientações sobre as boas práticas de arquitetura.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.outcomes": "Corte APIs redundantes e reduza os custos da plataforma de nuvem",
+  "cycle.api-productization-cycle.station.api-platform-architecture.outcomes.1": "Implementar uma governação consistente snum forte controlo do topo para a base",
+  "cycle.api-productization-cycle.station.api-platform-architecture.outcomes.2": "Conceção para reutilização interna e escalabilidade externa",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works": "O Canvas de Impacto no Negócio ajuda a identificar e mitigar os riscos relacionados com a disponibilidade, segurança e funcionalidade da API para apoiar decisões de arquitetura informadas.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works.1": "Mapear as localizações regulamentares, de conformidade e de rede dos fornecedores e consumidores de API para garantir a acessibilidade e a conformidade.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works.2": "O Canvas de Capacidade alinha os padrões das transacções comerciais, as tendências de consumo futuro e as soluções técnicas para garantir a escalabilidade e o desempenho da API, fornecendo dados essenciais para as decisões de escalabilidade e o planeamento da infraestrutura.",
+  "cycle.api-productization-cycle.station.api-platform-architecture.how_it_works.3": "Definir e monitorizar as métricas de desempenho (por exemplo, chamadas APIs, latência, taxas de erro) e as métricas de adoção (por exemplo, NPS).",
+  "cycle.api-productization-cycle.station.api-design.title": "Conceção da API - Conceber APIs que proporcionem valor",
+  "cycle.api-productization-cycle.station.api-design.description": "Criar conceções de API que sejam consistentes, reutilizáveis e baseados na intenção de negócios e em padrões compartilhados.",
+  "cycle.api-productization-cycle.station.api-design.why_it_matters": "Conceber APIs não se resume apenas a nomear endpoints. Um bom projeto garante que as APIs sejam utilizáveis, consistentes e alinhadas com os objetivos de negócio e técnicos. Um projeto inadequado leva a um acoplamento rígido, baixa reutilização e retrabalho dispendioso entre as equipas.",
+  "cycle.api-productization-cycle.station.api-design.apply_in_work": "Forneça padrões de projeto reutilizáveis, padrões compartilhados e ferramentas de validação para especificações de API. Garanta que as decisões de projeto sejam consistentes, revisadas antecipadamente e alinhadas com a intenção de negócios.",
+  "cycle.api-productization-cycle.station.api-design.outcomes": "Conceção de API bem documentada e coerente",
+  "cycle.api-productization-cycle.station.api-design.outcomes.1": "Contratos de interface da API reutilizáveis e validados",
+  "cycle.api-productization-cycle.station.api-design.outcomes.2": "Desenhos alinhados com modelos de domínio e padrões de interação",
+  "cycle.api-productization-cycle.station.api-design.outcomes.3": "Rastreabilidade da conceção ao valor de negócio",
+  "cycle.api-productization-cycle.station.api-design.how_it_works": "Definir entidades principais, os seus atributos e relações para criar um entendimento concetual partilhado entre APIs.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.1": "Utilize o Canvas de Interação para definir a forma como os consumidores irão interagir com a API, garantindo que esta satisfaz as suas necessidades e expectativas.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.2": "Aplicar padrões de conceção REST para criar contratos de interface da API consistentes e reutilizáveis que são validados com as partes interessadas.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.3": "Aplicar padrões de conceção orientados para eventos para criar contratos de interface da API consistentes e reutilizáveis que são validados com as partes interessadas.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.4": "Aplicar padrões de conceção GraphQL para criar contratos de interface da API consistentes e reutilizáveis que são validados com as partes interessadas.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.5": "Utilize os princípios de projeto e o guia de estilo da API para alinhar suas decisões de projeto com regras compartilhadas e permitir uma validação de auditoria consistente.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.6": "Aplique abordagens do tipo ‘contrato primeiro’ ou ‘design primeiro’ para capturar e validar o contrato de interface da API antes da implementação.",
+  "cycle.api-productization-cycle.station.api-design.how_it_works.7": "Utilize a Lista de Verificação de Auditoria da API para garantir que a conceção da API satisfaça os requisitos funcionais e não funcionais, incluindo segurança, desempenho e conformidade.",
+  "cycle.api-productization-cycle.station.api-delivery.title": "Entrega da API - Fornecer APIs seguras e fiáveis",
+  "cycle.api-productization-cycle.station.api-delivery.description": "Criar, testar e lançar APIs usando pipelines de entrega modernos e boas práticas de engenharia.",
+  "cycle.api-productization-cycle.station.api-delivery.why_it_matters": "Mesmo os melhores conceções de API falham se a entrega for inconsistente. Esta estação assegura que as suas APIs são construídas com qualidade, testadas exaustivamente e implementadas de forma fiável - permitindo iterações mais rápidas e maior confiança.",
+  "cycle.api-productization-cycle.station.api-delivery.apply_in_work": "Fornecer estruturas de codificação, bibliotecas e normas para a implementação de API. Implementar pipelines de CI/CD, estruturas de garantia de qualidade e ferramentas de automatização da disponibilização.",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes": "APIs implementadas utilizando estruturas e padrões testados",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes.1": "Pipelines de CI/CD fiáveis e automatizados",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes.2": "Testes funcionais e não funcionais integrados",
+  "cycle.api-productization-cycle.station.api-delivery.outcomes.3": "Condutas de entrega seguras e conformes",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works": "Utilize as Melhores Práticas de Desenvolvimento de API como orientação para implementar o contrato validado com frameworks e bibliotecas estabelecidos, garantindo que o resultado seja reutilizável e sustentável.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.1": "Construa a implementação da API a partir do contrato validado usando frameworks, bibliotecas e padrões da equipa estabelecidos.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.2": "Testar a funcionalidade, a segurança e o desempenho das APIs, utilizando ferramentas de teste automatizadas.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.3": "Utilize pipelines CI/CD para automatizar os processos de construção, teste e implementação, garantindo uma qualidade e rastreabilidade consistentes.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.4": "Garantir que as APIs cumprem os requisitos de segurança e conformidade através de verificações e auditorias automatizadas.",
+  "cycle.api-productization-cycle.station.api-delivery.how_it_works.5": "Utilize a lista de verificação de auditoria da API para garantir que a API cumpre os requisitos funcionais e não funcionais, incluindo segurança, desempenho e conformidade.",
+  "cycle.api-productization-cycle.station.api-audit.title": "Auditoria de API - Auditoria de APIs para conformidade e qualidade",
+  "cycle.api-productization-cycle.station.api-audit.description": "Valide se as APIs satisfazemos padrões de negócio, conceção e operacionais antes da publicação e exposição.",
+  "cycle.api-productization-cycle.station.api-audit.why_it_matters": "As APIs são produtos de longa duração e devem atender às expectativas de qualidade, consistência e conformidade. A auditoria conecta as decisões de conceção, a implementação e a prontidão operacional a padrões definidos, reduzindo o risco antes da exposição.",
+  "cycle.api-productization-cycle.station.api-audit.apply_in_work": "Estabeleça um processo de auditoria consistente que avalie a prontidão da API em todas as etapas do ciclo de vida usando critérios, evidências e padrões definidos. Garanta que as lacunas sejam identificadas antecipadamente e resolvidas antes da publicação.",
+  "cycle.api-productization-cycle.station.api-audit.outcomes": "As APIs cumprems normas internas e externas",
+  "cycle.api-productization-cycle.station.api-audit.outcomes.1": "Documentação clara das decisões de conceção e implementação da API",
+  "cycle.api-productization-cycle.station.api-audit.outcomes.2": "Segurança, desempenho e conformidade validados",
+  "cycle.api-productization-cycle.station.api-audit.outcomes.3": "Redução do risco de problemas na produção",
+  "cycle.api-productization-cycle.station.api-audit.how_it_works": "Realizar auditorias para garantir que as APIs cumprems normas organizacionais, técnicas e legais antes da publicação.",
+  "cycle.api-productization-cycle.station.api-audit.how_it_works.1": "Utilizar listas de controlo, linters e ferramentas de teste para verificar a consistência e a conformidade com as normas.",
+  "cycle.api-productization-cycle.station.api-audit.how_it_works.2": "Colaborar com as equipas de governação e especialistas no domínio para garantir que as APIs estão prontas para produção.",
+  "cycle.api-productization-cycle.station.api-publishing.title": "Publicação de API - Publique APIs com confiança",
+  "cycle.api-productization-cycle.station.api-publishing.description": "Exponha as APIs de forma segura e clara ao público certo com a documentação e os processos corretos.",
+  "cycle.api-productization-cycle.station.api-publishing.why_it_matters": "A publicação é mais do que a disponibilização - trata-se de capacidade de descoberta, acesso e suporte. Se as APIs não forem publicadas corretamente, não serão utilizadas, reutilizadas ou protegidas de forma eficaz.",
+  "cycle.api-productization-cycle.station.api-publishing.apply_in_work": "Permitir que as APIs sejam publicadas no ambiente relevante e ter mecanismos claros de registo e acesso (por exemplo, chaves de API, OAuth, planos de subscrição), dependendo dos segmentos de consumidores de API e dos requisitos de segurança e conformidade.",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes": "APIs publicadas no ambiente correto (privado, parceiro, público)",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes.1": "Processos claros de integração e registo da API",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes.2": "Documentação, modelos e políticas de segurança disponíveis",
+  "cycle.api-productization-cycle.station.api-publishing.outcomes.3": "APIs prontas para escala e governação",
+  "cycle.api-productization-cycle.station.api-publishing.how_it_works": "Publicar APIs nos gateways e ambientes adequados para apoiar a reutilização por vários consumidores de API.",
+  "cycle.api-productization-cycle.station.api-publishing.how_it_works.1": "Documentar a forma como os consumidores encontram e utilizam a API, incluindo processos de integração e registo.",
+  "cycle.api-productization-cycle.station.api-publishing.how_it_works.2": "Garantir que os modelos de segurança, a configuração da porta de ligação e os termos legais sejam claros e acessíveis aos consumidores.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.title": "Monitorização e melhoria - para valor API",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.description": "Utilizar métricas e feedback para acompanhar o desempenho da API e promover a melhoria contínua.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.why_it_matters": "A entrega da API não pára no lançamento. Sem monitorização, as equipas não podem melhorar a adoção, o desempenho ou o ROI. Esta estação garante que as APIs permaneçam úteis, seguras e evoluindo com as necessidades do negócio.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.apply_in_work": "Criar quadros analíticos para acompanhar o desempenho e o envolvimento. Desenvolver ciclos de feedback, ferramentas de análise e estratégias de envolvimento para APIs.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes": "Métricas de desempenho e utilização definidas e controladas",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes.1": "Ciclos de feedback do programador em vigor",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes.2": "Questões identificadas e tratadas continuamente",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.outcomes.3": "Iteração da API alinhada com as necessidades dos utilizadores",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.how_it_works": "Monitorizar as métricas de desempenho (por exemplo, chamadas APIs, latência, taxas de erro) e as métricas de adoção (por exemplo, NPS).",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.how_it_works.1": "Analisar as métricas de utilização da API e incorporar o feedback dos utilizadores nas iterações da API.",
+  "cycle.api-productization-cycle.station.monitoring-and-improving.how_it_works.2": "Crie o hábito de analisar os indicadores e planear actividades de melhoria contínua.",
+  "cycle.capability-productization-cycle.station.api-product-strategy.title": "Estratégia",
+  "cycle.capability-productization-cycle.station.api-product-strategy.description": "Antes de construir qualquer coisa, defina o valor, os consumidores, a propriedade e os objetivos de negócio da capacidade.",
+  "cycle.capability-productization-cycle.station.api-product-strategy.why_it_matters": "O trabalho de integração e API salta muitas vezes demasiado cedo para um padrão técnico. Esta estação mantém a equipa focada na jornada de negócio, no significado do domínio, no valor, no potencial de reutilização, na propriedade e na viabilidade antes de selecionar APIs, eventos, ficheiros, streams, produtos de dados ou integração direta.",
+  "cycle.capability-productization-cycle.station.api-product-strategy.apply_in_work": "Utilize canvases partilhados de jornada, domínio, proposta de valor e modelo de negócio para recolher requisitos independentes da tecnologia e decidir se a capacidade deve ser reutilizável.",
+  "cycle.capability-productization-cycle.station.api-product-strategy.outcomes": "Uma declaração de oportunidade de capacidade independente da tecnologia",
+  "cycle.capability-productization-cycle.station.api-product-strategy.outcomes.1": "Compreensão partilhada dos consumidores, produtores, conceitos de domínio e potencial de reutilização",
+  "cycle.capability-productization-cycle.station.api-product-strategy.outcomes.2": "Uma proposta de valor e um modelo de negócio da capacidade antes da seleção da arquitetura",
+  "cycle.capability-productization-cycle.station.api-product-strategy.how_it_works": "Mapeie a jornada do cliente ou parceiro que cria a necessidade da capacidade e revela tarefas, dores, ganhos, entradas, saídas e pontos de decisão.",
+  "cycle.capability-productization-cycle.station.api-product-strategy.how_it_works.1": "Defina as entidades principais, atributos, relações, propriedade e regras de negócio que a capacidade deve respeitar.",
+  "cycle.capability-productization-cycle.station.api-product-strategy.how_it_works.2": "Utilize o Canvas da Proposta de Valor da Capacidade para captar tarefas, ganhos, dores e funcionalidades reutilizáveis da capacidade para os consumidores, sem nomear a tecnologia de disponibilização demasiado cedo.",
+  "cycle.capability-productization-cycle.station.api-product-strategy.how_it_works.3": "Utilize o Canvas do Modelo de Negócio da Capacidade para clarificar propriedade, parceiros, canais, custos, benefícios, suporte e expectativas de ciclo de vida da capacidade reutilizável.",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.title": "Requisitos e integração de consumidores",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.description": "Recolha requisitos de integração dos consumidores, normas, requisitos não funcionais, expectativas de serviço, restrições, necessidades de segurança, protocolos permitidos, atualidade dos dados, SLAs, observabilidade, recuperação, requisitos de adoção e responsabilidades dos produtores.",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.why_it_matters": "A arquitetura certa depende dos objetivos dos consumidores, das expectativas de integração, dos níveis de serviço, das necessidades de qualidade dos dados, da tolerância à mudança, da observabilidade, do suporte e das restrições dos produtores.",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.how_it_works": "Utilize o Canvas de Requisitos da Experiência do Consumidor para captar objetivos dos consumidores, disponibilidade, atualidade, volume, desempenho, qualidade dos dados, segurança, integração, mudança, observabilidade e expectativas de recuperação.",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.how_it_works.1": "Utilize orientação de integração para descrever como os consumidores vão encontrar, solicitar, testar, obter aprovação e começar a utilizar a capacidade.",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.how_it_works.2": "Utilize a jornada e os requisitos resultantes para melhorar a integração, a documentação, o suporte e os ciclos de feedback dos consumidores da capacidade.",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.apply_in_work": "Utilize orientação de experiência e integração de consumidores para tornar explícitas as expectativas de consumidores e produtores.",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.outcomes": "Requisitos dos consumidores e expectativas de integração documentados",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.outcomes.1": "Responsabilidades dos produtores e expectativas de suporte claras",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.outcomes.2": "Restrições relevantes para a arquitetura prontas para apoiar decisões",
+  "cycle.capability-productization-cycle.station.api-consumer-experience.outcomes.3": "Adoção melhorada através de empatia com os consumidores, normas e clareza dos produtores",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.title": "Decisões de arquitetura e plataforma",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.description": "Utilize requisitos e restrições para decidir o padrão de arquitetura certo e as capacidades de plataforma de suporte.",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.why_it_matters": "As escolhas de arquitetura devem resultar de evidências sobre impacto de negócio, localizações, fronteiras de confiança, capacidade, latência, propriedade dos dados, consistência, operabilidade, segurança, privacidade, governação e custo.",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.apply_in_work": "Compare estilos de arquitetura viáveis com os requisitos recolhidos e documente o padrão selecionado e a respetiva justificação.",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.outcomes": "Uma escolha de arquitetura justificada",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.outcomes.1": "Riscos, localizações, capacidade, segurança, privacidade e restrições de operabilidade documentados",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.outcomes.2": "Justificação clara para API, evento, ficheiro, stream, produto de dados, integração direta ou disponibilização híbrida",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.how_it_works": "Utilize o Canvas de Impacto no Negócio para identificar riscos de disponibilidade, segurança e dados que influenciam as opções de arquitetura.",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.how_it_works.1": "Utilize o Canvas de Localizações para captar restrições geopolíticas, regulamentares, de rede, residência e fronteiras de confiança.",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.how_it_works.2": "Utilize o Canvas de Capacidade para captar volumes atuais e futuros, picos, latência, cache, limitação de pedidos e expectativas de escala.",
+  "cycle.capability-productization-cycle.station.api-platform-architecture.how_it_works.3": "Utilize orientação de métricas e análise para definir como a capacidade escolhida será monitorizada e melhorada.",
+  "cycle.capability-productization-cycle.station.api-design.title": "Conceção da solução e da interface",
+  "cycle.capability-productization-cycle.station.api-design.description": "Conceba o contrato de interface e o modelo de interação para o estilo de disponibilização selecionado.",
+  "cycle.capability-productization-cycle.station.api-design.why_it_matters": "Depois de conhecido o padrão de arquitetura, a conceção deve transformar os requisitos da capacidade em contratos de interface, interações, esquemas, regras de dados, expectativas de ciclo de vida e obrigações dos consumidores claros.",
+  "cycle.capability-productization-cycle.station.api-design.apply_in_work": "Selecione os recursos de conceção adequados ao estilo de disponibilização escolhido e documente o contrato de interface antes da implementação.",
+  "cycle.capability-productization-cycle.station.api-design.outcomes": "Um contrato de interface validado para o estilo de disponibilização selecionado",
+  "cycle.capability-productization-cycle.station.api-design.outcomes.1": "Decisões consistentes sobre interação, dados, eventos, ficheiros, fluxos de trabalho ou contratos de API",
+  "cycle.capability-productization-cycle.station.api-design.outcomes.2": "Rastreabilidade da conceção até aos requisitos da capacidade e dos consumidores",
+  "cycle.capability-productization-cycle.station.api-design.outcomes.3": "Conceções alinhadas com modelos de domínio e padrões de interação",
+  "cycle.capability-productization-cycle.station.api-design.how_it_works": "Reutilize o Canvas de Domínio para confirmar objetos de negócio, termos, regras e propriedade antes da conceção do contrato.",
+  "cycle.capability-productization-cycle.station.api-design.how_it_works.1": "Utilize o Canvas de Interação para descrever como consumidores, sistemas ou utilizadores interagem com a capacidade.",
+  "cycle.capability-productization-cycle.station.api-design.how_it_works.2": "Utilize recursos de conceção REST quando a interface selecionada for uma API REST.",
+  "cycle.capability-productization-cycle.station.api-design.how_it_works.3": "Utilize recursos de Canvas de Eventos quando a interface selecionada for orientada por eventos.",
+  "cycle.capability-productization-cycle.station.api-design.how_it_works.4": "Utilize recursos de conceção GraphQL quando a interface selecionada for GraphQL.",
+  "cycle.capability-productization-cycle.station.api-design.how_it_works.5": "Utilize os princípios de conceção e a orientação de estilo para alinhar decisões de conceção com regras partilhadas e permitir validação de auditoria consistente.",
+  "cycle.capability-productization-cycle.station.api-design.how_it_works.6": "Aplique abordagens contract-first ou design-first para captar e validar o contrato de interface antes da implementação.",
+  "cycle.capability-productization-cycle.station.api-design.how_it_works.7": "Utilize a lista de verificação de auditoria para garantir que a conceção cumpre requisitos funcionais e não funcionais, incluindo segurança, desempenho e conformidade.",
+  "cycle.capability-productization-cycle.station.api-delivery.title": "Entrega e operações",
+  "cycle.capability-productization-cycle.station.api-delivery.description": "Construa, teste, disponibilize e opere a capacidade usando o estilo de disponibilização selecionado e o contrato de interface validado.",
+  "cycle.capability-productization-cycle.station.api-delivery.why_it_matters": "Uma capacidade reutilizável precisa de entrega e operações fiáveis, quer se torne uma API, stream de eventos, troca de ficheiros, produto de dados ou integração direta.",
+  "cycle.capability-productization-cycle.station.api-delivery.apply_in_work": "Aplique orientação de entrega, testes, CI/CD, operações e segurança ao estilo de disponibilização escolhido.",
+  "cycle.capability-productization-cycle.station.api-delivery.outcomes": "Uma capacidade entregue e alinhada com o contrato de interface validado",
+  "cycle.capability-productization-cycle.station.api-delivery.outcomes.1": "Testes, disponibilização e controlos de ambiente automatizados",
+  "cycle.capability-productization-cycle.station.api-delivery.outcomes.2": "Práticas de segurança, operações e qualidade adequadas ao padrão escolhido",
+  "cycle.capability-productization-cycle.station.api-delivery.outcomes.3": "Controlos de entrega e disponibilização rastreáveis",
+  "cycle.capability-productization-cycle.station.api-delivery.how_it_works": "Utilize boas práticas de desenvolvimento para implementar o contrato de interface validado com frameworks, bibliotecas e normas da equipa estabelecidos.",
+  "cycle.capability-productization-cycle.station.api-delivery.how_it_works.1": "Construa a implementação a partir do contrato de interface validado, usando frameworks, bibliotecas e normas da equipa estabelecidos.",
+  "cycle.capability-productization-cycle.station.api-delivery.how_it_works.2": "Utilize orientação de testes para verificar funcionalidade, qualidade dos dados, compatibilidade, segurança, desempenho, resiliência e expectativas de recuperação.",
+  "cycle.capability-productization-cycle.station.api-delivery.how_it_works.3": "Utilize orientação de CI/CD para automatizar construção, testes, disponibilização, configuração e rastreabilidade.",
+  "cycle.capability-productization-cycle.station.api-delivery.how_it_works.4": "Utilize orientação de segurança para proteger dados, acesso, credenciais e fronteiras da plataforma.",
+  "cycle.capability-productization-cycle.station.api-delivery.how_it_works.5": "Utilize a lista de verificação de auditoria para garantir que a solução cumpre requisitos funcionais e não funcionais, incluindo segurança, desempenho e conformidade.",
+  "cycle.capability-productization-cycle.station.api-audit.title": "Garantia de qualidade e prontidão",
+  "cycle.capability-productization-cycle.station.api-audit.description": "Audite o contrato de interface, os controlos, o modelo de suporte, a observabilidade, a documentação e a prontidão de ciclo de vida da capacidade antes da disponibilização.",
+  "cycle.capability-productization-cycle.station.api-audit.why_it_matters": "As capacidades reutilizáveis criam riscos operacionais, de dados, segurança, privacidade, conformidade e impacto nos consumidores. As verificações de prontidão reduzem surpresas antes da publicação ou utilização em produção.",
+  "cycle.capability-productization-cycle.station.api-audit.apply_in_work": "Utilize recursos de auditoria e conformidade para verificar que a capacidade está pronta para disponibilização controlada e reutilização.",
+  "cycle.capability-productization-cycle.station.api-audit.outcomes": "Prontidão para disponibilização e reutilização documentada",
+  "cycle.capability-productization-cycle.station.api-audit.outcomes.1": "Lacunas e mitigações conhecidas antes da publicação",
+  "cycle.capability-productization-cycle.station.api-audit.outcomes.2": "Evidências para aprovação de governação, conformidade, suporte e operações",
+  "cycle.capability-productization-cycle.station.api-audit.outcomes.3": "Risco reduzido de problemas em produção",
+  "cycle.capability-productization-cycle.station.api-audit.how_it_works": "Utilize a lista de verificação de auditoria como checklist de qualidade reutilizável para contrato de interface, documentação, segurança, desempenho e prontidão de conformidade.",
+  "cycle.capability-productization-cycle.station.api-audit.how_it_works.1": "Utilize checklists, linters e ferramentas de teste para verificar consistência e conformidade com normas.",
+  "cycle.capability-productization-cycle.station.api-audit.how_it_works.2": "Colabore com equipas de governação e especialistas de domínio para garantir que a capacidade está pronta para produção.",
+  "cycle.capability-productization-cycle.station.api-publishing.title": "Publicação e capacitação",
+  "cycle.capability-productization-cycle.station.api-publishing.description": "Publique informação sobre a capacidade reutilizável para que os consumidores a possam descobrir, solicitar, integrar, utilizar e obter suporte.",
+  "cycle.capability-productization-cycle.station.api-publishing.why_it_matters": "As capacidades reutilizáveis só criam valor quando os consumidores as conseguem encontrar, compreender o respetivo contrato de interface e expectativas de serviço, solicitar acesso e saber quem é responsável pelo suporte e pelas decisões de ciclo de vida.",
+  "cycle.capability-productization-cycle.station.api-publishing.apply_in_work": "Publique propriedade, documentação, integração, contactos de suporte, expectativas de serviço, estado de ciclo de vida e caminhos para pedidos de acesso.",
+  "cycle.capability-productization-cycle.station.api-publishing.outcomes": "Uma capacidade reutilizável detetável",
+  "cycle.capability-productization-cycle.station.api-publishing.outcomes.1": "Expectativas claras de integração, acesso, suporte e serviço",
+  "cycle.capability-productization-cycle.station.api-publishing.outcomes.2": "Informação de ciclo de vida e propriedade disponível para consumidores e equipas de governação",
+  "cycle.capability-productization-cycle.station.api-publishing.outcomes.3": "Consumidores capacitados para utilizar e reutilizar a capacidade",
+  "cycle.capability-productization-cycle.station.api-publishing.how_it_works": "Publique informação sobre a capacidade nos catálogos, portais, gateways ou ambientes adequados para apoiar a reutilização por vários consumidores.",
+  "cycle.capability-productization-cycle.station.api-publishing.how_it_works.1": "Documente como os consumidores encontram e utilizam a capacidade, incluindo processos de integração e registo.",
+  "cycle.capability-productization-cycle.station.api-publishing.how_it_works.2": "Garanta que os modelos de segurança, a configuração de acesso e os termos legais são claros e acessíveis aos consumidores.",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.title": "Monitorização e melhoria",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.description": "Monitorize a utilização, fiabilidade, qualidade dos dados, resultados dos consumidores, custo operacional e oportunidades de reutilização após a disponibilização.",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.why_it_matters": "As capacidades precisam de feedback contínuo para permanecerem fiáveis, valiosas, rentáveis e reutilizáveis à medida que consumidores, sistemas, dados e plataformas mudam.",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.apply_in_work": "Utilize práticas de métricas, análise e envolvimento para melhorar a capacidade ao longo do tempo.",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.outcomes": "Saúde e valor da capacidade medidos",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.outcomes.1": "Backlog de melhorias informado por feedback operacional e dos consumidores",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.outcomes.2": "Sinais de reutilização, fiabilidade, qualidade dos dados e custo disponíveis para os responsáveis",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.outcomes.3": "Melhoria contínua alinhada com as necessidades dos consumidores",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.how_it_works": "Utilize orientação de métricas e análise para definir medidas de utilização da capacidade, fiabilidade, qualidade dos dados, custo, adoção e valor para os consumidores.",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.how_it_works.1": "Analise métricas de utilização e incorpore feedback dos consumidores nas iterações da capacidade.",
+  "cycle.capability-productization-cycle.station.monitoring-and-improving.how_it_works.2": "Estabeleça o hábito de rever métricas e planear atividades de melhoria contínua."
 }
diff --git a/src/data/method/resources.json b/src/data/method/resources.json
index 72cafb8..191ca29 100644
--- a/src/data/method/resources.json
+++ b/src/data/method/resources.json
@@ -24,7 +24,8 @@
         ],
         "tips": [
           "resource.api-community-engagement-strategies.tips",
-          "resource.api-community-engagement-strategies.tips.1"
+          "resource.api-community-engagement-strategies.tips.1",
+          "resource.api-community-engagement-strategies.tips.2"
         ]
       },
       "category": "guideline"
@@ -61,7 +62,6 @@
       "title": "resource.api-development-best-practices.title",
       "slug": "resources/api-development-best-practices",
       "icon": "edit-document-outline",
-      "daft": "true",
       "order": 112,
       "description": "resource.api-development-best-practices.description",
       "image": "",
@@ -78,7 +78,8 @@
         ],
         "tips": [
           "resource.api-development-best-practices.tips",
-          "resource.api-development-best-practices.tips.1"
+          "resource.api-development-best-practices.tips.1",
+          "resource.api-development-best-practices.tips.2"
         ]
       },
       "category": "guideline",
@@ -89,7 +90,6 @@
       "title": "resource.api-metrics-and-analytics.title",
       "slug": "resources/api-metrics-and-analytics",
       "icon": "edit-document-outline",
-      "daft": "true",
       "order": 119,
       "description": "resource.api-metrics-and-analytics.description",
       "image": "",
@@ -106,7 +106,8 @@
         ],
         "tips": [
           "resource.api-metrics-and-analytics.tips",
-          "resource.api-metrics-and-analytics.tips.1"
+          "resource.api-metrics-and-analytics.tips.1",
+          "resource.api-metrics-and-analytics.tips.2"
         ]
       },
       "category": "guideline",
@@ -241,7 +242,8 @@
         ],
         "tips": [
           "resource.api-testing-best-practices.tips",
-          "resource.api-testing-best-practices.tips.1"
+          "resource.api-testing-best-practices.tips.1",
+          "resource.api-testing-best-practices.tips.2"
         ]
       },
       "category": "guideline"
@@ -322,7 +324,8 @@
         ],
         "tips": [
           "resource.apiops-CI-CD-for-apis.tips",
-          "resource.apiops-CI-CD-for-apis.tips.1"
+          "resource.apiops-CI-CD-for-apis.tips.1",
+          "resource.apiops-CI-CD-for-apis.tips.2"
         ]
       },
       "category": "guideline"
@@ -714,7 +717,8 @@
         ],
         "tips": [
           "resource.api-audit-checklist.tips",
-          "resource.api-audit-checklist.tips.1"
+          "resource.api-audit-checklist.tips.1",
+          "resource.api-audit-checklist.tips.2"
         ]
       },
       "category": "checklist"
@@ -1044,6 +1048,339 @@
         ]
       },
       "category": "canvas"
+    },
+    {
+      "id": "capabilityValuePropositionCanvas",
+      "title": "resource.capability-value-proposition-canvas.title",
+      "slug": "resources/capability-value-proposition-canvas",
+      "icon": "dashboard-outline",
+      "order": 2.1,
+      "description": "resource.capability-value-proposition-canvas.description",
+      "canvas": "capabilityValuePropositionCanvas",
+      "outcomes": [
+        "resource.capability-value-proposition-canvas.outcomes",
+        "resource.capability-value-proposition-canvas.outcomes.1",
+        "resource.capability-value-proposition-canvas.outcomes.2"
+      ],
+      "how_it_works": {
+        "steps": [
+          "resource.capability-value-proposition-canvas.steps",
+          "resource.capability-value-proposition-canvas.steps.1",
+          "resource.capability-value-proposition-canvas.steps.2",
+          "resource.capability-value-proposition-canvas.steps.3"
+        ],
+        "tips": [
+          "resource.capability-value-proposition-canvas.tips",
+          "resource.capability-value-proposition-canvas.tips.1"
+        ]
+      },
+      "category": "canvas"
+    },
+    {
+      "id": "capabilityBusinessModelCanvas",
+      "title": "resource.capability-business-model-canvas.title",
+      "slug": "resources/capability-business-model-canvas",
+      "icon": "dashboard-outline",
+      "order": 3.1,
+      "description": "resource.capability-business-model-canvas.description",
+      "canvas": "capabilityBusinessModelCanvas",
+      "outcomes": [
+        "resource.capability-business-model-canvas.outcomes",
+        "resource.capability-business-model-canvas.outcomes.1",
+        "resource.capability-business-model-canvas.outcomes.2"
+      ],
+      "how_it_works": {
+        "steps": [
+          "resource.capability-business-model-canvas.steps",
+          "resource.capability-business-model-canvas.steps.1",
+          "resource.capability-business-model-canvas.steps.2",
+          "resource.capability-business-model-canvas.steps.3",
+          "resource.capability-business-model-canvas.steps.4",
+          "resource.capability-business-model-canvas.steps.5"
+        ],
+        "tips": [
+          "resource.capability-business-model-canvas.tips",
+          "resource.capability-business-model-canvas.tips.1"
+        ]
+      },
+      "category": "canvas"
+    },
+    {
+      "id": "consumerExperienceRequirementsCanvas",
+      "title": "resource.consumer-experience-requirements-canvas.title",
+      "slug": "resources/consumer-experience-requirements-canvas",
+      "icon": "dashboard-outline",
+      "order": 3.2,
+      "description": "resource.consumer-experience-requirements-canvas.description",
+      "canvas": "consumerExperienceRequirementsCanvas",
+      "outcomes": [
+        "resource.consumer-experience-requirements-canvas.outcomes",
+        "resource.consumer-experience-requirements-canvas.outcomes.1",
+        "resource.consumer-experience-requirements-canvas.outcomes.2"
+      ],
+      "how_it_works": {
+        "steps": [
+          "resource.consumer-experience-requirements-canvas.steps",
+          "resource.consumer-experience-requirements-canvas.steps.1",
+          "resource.consumer-experience-requirements-canvas.steps.2",
+          "resource.consumer-experience-requirements-canvas.steps.3"
+        ],
+        "tips": [
+          "resource.consumer-experience-requirements-canvas.tips",
+          "resource.consumer-experience-requirements-canvas.tips.1"
+        ]
+      },
+      "category": "canvas"
+    },
+    {
+      "id": "integration-style-selection-guide",
+      "title": "resource.integration-style-selection-guide.title",
+      "slug": "resources/integration-style-selection-guide",
+      "icon": "edit-document-outline",
+      "draft": "true",
+      "order": 180,
+      "description": "resource.integration-style-selection-guide.description",
+      "image": "",
+      "outcomes": [
+        "resource.integration-style-selection-guide.outcomes",
+        "resource.integration-style-selection-guide.outcomes.1",
+        "resource.integration-style-selection-guide.outcomes.2"
+      ],
+      "how_it_works": {
+        "steps": [
+          "resource.integration-style-selection-guide.steps",
+          "resource.integration-style-selection-guide.steps.1",
+          "resource.integration-style-selection-guide.steps.2",
+          "resource.integration-style-selection-guide.steps.3"
+        ],
+        "tips": [
+          "resource.integration-style-selection-guide.tips",
+          "resource.integration-style-selection-guide.tips.1"
+        ]
+      },
+      "category": "guideline"
+    },
+    {
+      "id": "process-workflow-design-guide",
+      "title": "resource.process-workflow-design-guide.title",
+      "slug": "resources/process-workflow-design-guide",
+      "icon": "edit-document-outline",
+      "draft": "true",
+      "order": 181,
+      "description": "resource.process-workflow-design-guide.description",
+      "image": "",
+      "outcomes": [
+        "resource.process-workflow-design-guide.outcomes",
+        "resource.process-workflow-design-guide.outcomes.1",
+        "resource.process-workflow-design-guide.outcomes.2"
+      ],
+      "how_it_works": {
+        "steps": [
+          "resource.process-workflow-design-guide.steps",
+          "resource.process-workflow-design-guide.steps.1",
+          "resource.process-workflow-design-guide.steps.2",
+          "resource.process-workflow-design-guide.steps.3"
+        ],
+        "tips": [
+          "resource.process-workflow-design-guide.tips",
+          "resource.process-workflow-design-guide.tips.1"
+        ]
+      },
+      "category": "guideline"
+    },
+    {
+      "id": "decision-business-rules-guide",
+      "title": "resource.decision-business-rules-guide.title",
+      "slug": "resources/decision-business-rules-guide",
+      "icon": "edit-document-outline",
+      "draft": "true",
+      "order": 182,
+      "description": "resource.decision-business-rules-guide.description",
+      "image": "",
+      "outcomes": [
+        "resource.decision-business-rules-guide.outcomes",
+        "resource.decision-business-rules-guide.outcomes.1",
+        "resource.decision-business-rules-guide.outcomes.2"
+      ],
+      "how_it_works": {
+        "steps": [
+          "resource.decision-business-rules-guide.steps",
+          "resource.decision-business-rules-guide.steps.1",
+          "resource.decision-business-rules-guide.steps.2"
+        ],
+        "tips": [
+          "resource.decision-business-rules-guide.tips",
+          "resource.decision-business-rules-guide.tips.1"
+        ]
+      },
+      "category": "guideline"
+    },
+    {
+      "id": "automation-trigger-handoff-exception-guide",
+      "title": "resource.automation-trigger-handoff-exception-guide.title",
+      "slug": "resources/automation-trigger-handoff-exception-guide",
+      "icon": "edit-document-outline",
+      "draft": "true",
+      "order": 183,
+      "description": "resource.automation-trigger-handoff-exception-guide.description",
+      "image": "",
+      "outcomes": [
+        "resource.automation-trigger-handoff-exception-guide.outcomes",
+        "resource.automation-trigger-handoff-exception-guide.outcomes.1",
+        "resource.automation-trigger-handoff-exception-guide.outcomes.2"
+      ],
+      "how_it_works": {
+        "steps": [
+          "resource.automation-trigger-handoff-exception-guide.steps",
+          "resource.automation-trigger-handoff-exception-guide.steps.1",
+          "resource.automation-trigger-handoff-exception-guide.steps.2",
+          "resource.automation-trigger-handoff-exception-guide.steps.3"
+        ],
+        "tips": [
+          "resource.automation-trigger-handoff-exception-guide.tips",
+          "resource.automation-trigger-handoff-exception-guide.tips.1"
+        ]
+      },
+      "category": "guideline"
+    },
+    {
+      "id": "automation-testing-guide",
+      "title": "resource.automation-testing-guide.title",
+      "slug": "resources/automation-testing-guide",
+      "icon": "edit-document-outline",
+      "draft": "true",
+      "order": 184,
+      "description": "resource.automation-testing-guide.description",
+      "image": "",
+      "outcomes": [
+        "resource.automation-testing-guide.outcomes",
+        "resource.automation-testing-guide.outcomes.1",
+        "resource.automation-testing-guide.outcomes.2"
+      ],
+      "how_it_works": {
+        "steps": [
+          "resource.automation-testing-guide.steps",
+          "resource.automation-testing-guide.steps.1",
+          "resource.automation-testing-guide.steps.2",
+          "resource.automation-testing-guide.steps.3"
+        ],
+        "tips": [
+          "resource.automation-testing-guide.tips",
+          "resource.automation-testing-guide.tips.1"
+        ]
+      },
+      "category": "guideline"
+    },
+    {
+      "id": "automation-operational-ownership-guide",
+      "title": "resource.automation-operational-ownership-guide.title",
+      "slug": "resources/automation-operational-ownership-guide",
+      "icon": "edit-document-outline",
+      "draft": "true",
+      "order": 185,
+      "description": "resource.automation-operational-ownership-guide.description",
+      "image": "",
+      "outcomes": [
+        "resource.automation-operational-ownership-guide.outcomes",
+        "resource.automation-operational-ownership-guide.outcomes.1",
+        "resource.automation-operational-ownership-guide.outcomes.2"
+      ],
+      "how_it_works": {
+        "steps": [
+          "resource.automation-operational-ownership-guide.steps",
+          "resource.automation-operational-ownership-guide.steps.1",
+          "resource.automation-operational-ownership-guide.steps.2"
+        ],
+        "tips": [
+          "resource.automation-operational-ownership-guide.tips",
+          "resource.automation-operational-ownership-guide.tips.1"
+        ]
+      },
+      "category": "guideline"
+    },
+    {
+      "id": "automation-rollback-supervision-guide",
+      "title": "resource.automation-rollback-supervision-guide.title",
+      "slug": "resources/automation-rollback-supervision-guide",
+      "icon": "edit-document-outline",
+      "draft": "true",
+      "order": 186,
+      "description": "resource.automation-rollback-supervision-guide.description",
+      "image": "",
+      "outcomes": [
+        "resource.automation-rollback-supervision-guide.outcomes",
+        "resource.automation-rollback-supervision-guide.outcomes.1",
+        "resource.automation-rollback-supervision-guide.outcomes.2"
+      ],
+      "how_it_works": {
+        "steps": [
+          "resource.automation-rollback-supervision-guide.steps",
+          "resource.automation-rollback-supervision-guide.steps.1",
+          "resource.automation-rollback-supervision-guide.steps.2",
+          "resource.automation-rollback-supervision-guide.steps.3"
+        ],
+        "tips": [
+          "resource.automation-rollback-supervision-guide.tips",
+          "resource.automation-rollback-supervision-guide.tips.1"
+        ]
+      },
+      "category": "guideline"
+    },
+    {
+      "id": "automation-readiness-checklist",
+      "title": "resource.automation-readiness-checklist.title",
+      "slug": "resources/automation-readiness-checklist",
+      "icon": "check-box-outline",
+      "draft": "true",
+      "order": 187,
+      "description": "resource.automation-readiness-checklist.description",
+      "image": "",
+      "outcomes": [
+        "resource.automation-readiness-checklist.outcomes",
+        "resource.automation-readiness-checklist.outcomes.1",
+        "resource.automation-readiness-checklist.outcomes.2"
+      ],
+      "how_it_works": {
+        "steps": [
+          "resource.automation-readiness-checklist.steps",
+          "resource.automation-readiness-checklist.steps.1",
+          "resource.automation-readiness-checklist.steps.2",
+          "resource.automation-readiness-checklist.steps.3"
+        ],
+        "tips": [
+          "resource.automation-readiness-checklist.tips",
+          "resource.automation-readiness-checklist.tips.1"
+        ]
+      },
+      "category": "checklist"
+    },
+    {
+      "id": "automation-rollout-enablement-guide",
+      "title": "resource.automation-rollout-enablement-guide.title",
+      "slug": "resources/automation-rollout-enablement-guide",
+      "icon": "edit-document-outline",
+      "draft": "true",
+      "order": 188,
+      "description": "resource.automation-rollout-enablement-guide.description",
+      "image": "",
+      "outcomes": [
+        "resource.automation-rollout-enablement-guide.outcomes",
+        "resource.automation-rollout-enablement-guide.outcomes.1",
+        "resource.automation-rollout-enablement-guide.outcomes.2"
+      ],
+      "how_it_works": {
+        "steps": [
+          "resource.automation-rollout-enablement-guide.steps",
+          "resource.automation-rollout-enablement-guide.steps.1",
+          "resource.automation-rollout-enablement-guide.steps.2",
+          "resource.automation-rollout-enablement-guide.steps.3"
+        ],
+        "tips": [
+          "resource.automation-rollout-enablement-guide.tips",
+          "resource.automation-rollout-enablement-guide.tips.1"
+        ]
+      },
+      "category": "guideline"
     }
   ]
 }
diff --git a/src/data/method/stakeholders.json b/src/data/method/stakeholders.json
index 0ff6739..e55eef5 100644
--- a/src/data/method/stakeholders.json
+++ b/src/data/method/stakeholders.json
@@ -16,34 +16,69 @@
       "description": "stakeholder.api-product-owner.description"
     },
     {
-      "id": "domain-expert",
-      "title": "stakeholder.domain-expert.title",
-      "description": "stakeholder.domain-expert.description"
+      "id": "capability-owner",
+      "title": "stakeholder.capability-owner.title",
+      "description": "stakeholder.capability-owner.description"
     },
     {
-      "id": "customer-or-partner-representative",
-      "title": "stakeholder.customer-or-partner-representative.title",
-      "description": "stakeholder.customer-or-partner-representative.description"
+      "id": "domain-specialist",
+      "title": "stakeholder.domain-specialist.title",
+      "description": "stakeholder.domain-specialist.description"
     },
     {
-      "id": "api-consumer-representative",
-      "title": "stakeholder.api-consumer-representative.title",
-      "description": "stakeholder.api-consumer-representative.description"
+      "id": "customer-specialist",
+      "title": "stakeholder.customer-specialist.title",
+      "description": "stakeholder.customer-specialist.description"
+    },
+    {
+      "id": "api-consumer-specialist",
+      "title": "stakeholder.api-consumer-specialist.title",
+      "description": "stakeholder.api-consumer-specialist.description"
     },
     {
       "id": "platform-architect",
       "title": "stakeholder.platform-architect.title",
       "description": "stakeholder.platform-architect.description"
     },
+    {
+      "id": "api-architect",
+      "title": "stakeholder.api-architect.title",
+      "description": "stakeholder.api-architect.description"
+    },
+    {
+      "id": "integration-architect",
+      "title": "stakeholder.integration-architect.title",
+      "description": "stakeholder.integration-architect.description"
+    },
+    {
+      "id": "platform-owner",
+      "title": "stakeholder.platform-owner.title",
+      "description": "stakeholder.platform-owner.description"
+    },
     {
       "id": "api-designer",
       "title": "stakeholder.api-designer.title",
       "description": "stakeholder.api-designer.description"
     },
     {
-      "id": "delivery-engineer",
-      "title": "stakeholder.delivery-engineer.title",
-      "description": "stakeholder.delivery-engineer.description"
+      "id": "api-engineer",
+      "title": "stakeholder.api-engineer.title",
+      "description": "stakeholder.api-engineer.description"
+    },
+    {
+      "id": "automation-owner",
+      "title": "stakeholder.automation-owner.title",
+      "description": "stakeholder.automation-owner.description"
+    },
+    {
+      "id": "process-owner",
+      "title": "stakeholder.process-owner.title",
+      "description": "stakeholder.process-owner.description"
+    },
+    {
+      "id": "automation-engineer",
+      "title": "stakeholder.automation-engineer.title",
+      "description": "stakeholder.automation-engineer.description"
     },
     {
       "id": "security-specialist",
@@ -51,29 +86,29 @@
       "description": "stakeholder.security-specialist.description"
     },
     {
-      "id": "compliance-legal-specialist",
-      "title": "stakeholder.compliance-legal-specialist.title",
-      "description": "stakeholder.compliance-legal-specialist.description"
+      "id": "compliance-specialist",
+      "title": "stakeholder.compliance-specialist.title",
+      "description": "stakeholder.compliance-specialist.description"
     },
     {
-      "id": "governance-owner",
-      "title": "stakeholder.governance-owner.title",
-      "description": "stakeholder.governance-owner.description"
+      "id": "governance-specialist",
+      "title": "stakeholder.governance-specialist.title",
+      "description": "stakeholder.governance-specialist.description"
     },
     {
-      "id": "documentation-devrel-owner",
-      "title": "stakeholder.documentation-devrel-owner.title",
-      "description": "stakeholder.documentation-devrel-owner.description"
+      "id": "api-devrel-specialist",
+      "title": "stakeholder.api-devrel-specialist.title",
+      "description": "stakeholder.api-devrel-specialist.description"
     },
     {
-      "id": "support-operations-owner",
-      "title": "stakeholder.support-operations-owner.title",
-      "description": "stakeholder.support-operations-owner.description"
+      "id": "operations-specialist",
+      "title": "stakeholder.operations-specialist.title",
+      "description": "stakeholder.operations-specialist.description"
     },
     {
-      "id": "partner-vendor-manager",
-      "title": "stakeholder.partner-vendor-manager.title",
-      "description": "stakeholder.partner-vendor-manager.description"
+      "id": "partner-specialist",
+      "title": "stakeholder.partner-specialist.title",
+      "description": "stakeholder.partner-specialist.description"
     }
   ]
 }
diff --git a/src/data/method/station-stakeholders.json b/src/data/method/station-stakeholders.json
index f806c78..4c34d47 100644
--- a/src/data/method/station-stakeholders.json
+++ b/src/data/method/station-stakeholders.json
@@ -1,1044 +1,1250 @@
 {
-  "api-product-strategy": [
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "domain-expert",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "customer-or-partner-representative",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-consumer-representative",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "consulted"
-    }
-  ],
-  "api-consumer-experience": [
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-consumer-representative",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "documentation-devrel-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "domain-expert",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "api-designer",
-      "involvement": "consulted"
-    }
-  ],
-  "api-platform-architecture": [
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "domain-expert",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-consumer-representative",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "api-design": [
-    {
-      "stakeholder": "api-designer",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "domain-expert",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-consumer-representative",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "documentation-devrel-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "api-delivery": [
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-designer",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "api-audit": [
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-designer",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "api-publishing": [
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "documentation-devrel-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-consumer-representative",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "monitoring-and-improving": [
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-consumer-representative",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "documentation-devrel-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "domain-expert",
-      "involvement": "consulted"
-    }
-  ],
-  "user-experience": [
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-consumer-representative",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "customer-or-partner-representative",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "documentation-devrel-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "domain-expert",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "api-designer",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "market-insights": [
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "customer-or-partner-representative",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "domain-expert",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-consumer-representative",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "api-program-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "partner-vendor-manager",
-      "involvement": "consulted"
-    }
-  ],
-  "business-goals": [
-    {
-      "stakeholder": "business-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "domain-expert",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-program-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "competitive-analysis": [
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "customer-or-partner-representative",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "partner-vendor-manager",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "domain-expert",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "api-consumer-representative",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "api-program-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "ecosystem-vision": [
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "partner-vendor-manager",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "domain-expert",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "api-program-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "customer-or-partner-representative",
-      "involvement": "consulted"
-    }
-  ],
-  "scalable-infrastructure": [
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "legal-and-compliance": [
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "security-and-privacy": [
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "design-standards": [
-    {
-      "stakeholder": "api-designer",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-consumer-representative",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "documentation-devrel-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "vendor-management": [
-    {
-      "stakeholder": "partner-vendor-manager",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "contract-design": [
-    {
-      "stakeholder": "api-designer",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "domain-expert",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "api-consumer-representative",
-      "involvement": "consulted"
-    }
-  ],
-  "development": [
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-designer",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "domain-expert",
-      "involvement": "consulted"
-    }
-  ],
-  "ci-cd": [
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-designer",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "test-automation": [
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-designer",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "release-management": [
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "documentation-devrel-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "service-agreements": [
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-consumer-representative",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "partner-vendor-manager",
-      "involvement": "consulted"
-    }
-  ],
-  "api-consumer-adoption": [
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-consumer-representative",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "documentation-devrel-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "domain-expert",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "partner-vendor-manager",
-      "involvement": "consulted"
-    }
-  ],
-  "api-promotion": [
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "documentation-devrel-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-consumer-representative",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "partner-vendor-manager",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "api-program-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "partner-integration": [
-    {
-      "stakeholder": "partner-vendor-manager",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "api-mindset": [
-    {
-      "stakeholder": "api-program-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "documentation-devrel-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "domain-expert",
-      "involvement": "consulted"
-    }
-  ],
-  "roles-and-responsibilities": [
-    {
-      "stakeholder": "api-program-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "upskilling": [
-    {
-      "stakeholder": "api-program-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-designer",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "business-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "operating-guidelines": [
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-program-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "security-specialist",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "compliance-legal-specialist",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "portfolio-management": [
-    {
-      "stakeholder": "business-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-program-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "documentation-devrel-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "consulted"
-    }
-  ],
-  "budget-and-resource-management": [
-    {
-      "stakeholder": "business-owner",
-      "involvement": "lead"
-    },
-    {
-      "stakeholder": "api-program-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "api-product-owner",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "delivery-engineer",
-      "involvement": "core"
-    },
-    {
-      "stakeholder": "platform-architect",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "governance-owner",
-      "involvement": "consulted"
-    },
-    {
-      "stakeholder": "support-operations-owner",
-      "involvement": "consulted"
+  "stationStakeholdersByCycle": {
+    "capability-productization-cycle": {
+      "api-product-strategy": [
+        {
+          "stakeholder": "capability-owner",
+          "involvement": "lead",
+          "responsibilities": [
+            {
+              "resource": "capabilityValuePropositionCanvas",
+              "role": "suggested-answer-owner"
+            },
+            {
+              "resource": "capabilityBusinessModelCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "customerJourneyCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "domain-specialist",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "domainCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "customer-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-program-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        }
+      ],
+      "api-consumer-experience": [
+        {
+          "stakeholder": "customer-specialist",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "capability-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-consumer-specialist",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "consumerExperienceRequirementsCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "domain-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "api-devrel-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "consulted"
+        }
+      ],
+      "api-platform-architecture": [
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "lead",
+          "responsibilities": [
+            {
+              "resource": "locationsCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "capability-owner",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "businessImpactCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "platform-owner",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "capacityCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "api-product-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "integration-architect",
+          "involvement": "consulted"
+        }
+      ],
+      "api-design": [
+        {
+          "stakeholder": "api-designer",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "capability-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "domain-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-consumer-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-product-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "integration-architect",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "consulted"
+        }
+      ],
+      "api-delivery": [
+        {
+          "stakeholder": "api-engineer",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "capability-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "api-designer",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        }
+      ],
+      "api-audit": [
+        {
+          "stakeholder": "governance-specialist",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "capability-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-designer",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "api-engineer",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "consulted"
+        }
+      ],
+      "api-publishing": [
+        {
+          "stakeholder": "capability-owner",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "api-devrel-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-consumer-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "partner-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "consulted"
+        }
+      ],
+      "monitoring-and-improving": [
+        {
+          "stakeholder": "capability-owner",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-consumer-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-devrel-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        }
+      ]
+    },
+    "api-productization-cycle": {
+      "api-product-strategy": [
+        {
+          "stakeholder": "api-product-owner",
+          "involvement": "lead",
+          "responsibilities": [
+            {
+              "resource": "apiValuePropositionCanvas",
+              "role": "suggested-answer-owner"
+            },
+            {
+              "resource": "apiBusinessModelCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "customerJourneyCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "domain-specialist",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "domainCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "customer-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-consumer-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "consulted"
+        }
+      ],
+      "api-consumer-experience": [
+        {
+          "stakeholder": "api-product-owner",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "api-consumer-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-devrel-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "domain-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "api-designer",
+          "involvement": "consulted"
+        }
+      ],
+      "api-platform-architecture": [
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "api-product-owner",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "businessImpactCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "api-architect",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "locationsCanvas",
+              "role": "suggested-answer-owner"
+            },
+            {
+              "resource": "capacityCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "domain-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-consumer-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "api-engineer",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "consulted"
+        }
+      ],
+      "api-design": [
+        {
+          "stakeholder": "api-designer",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "api-product-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "domain-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-consumer-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "api-engineer",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "api-devrel-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "consulted"
+        }
+      ],
+      "api-delivery": [
+        {
+          "stakeholder": "api-engineer",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "api-designer",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-product-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "consulted"
+        }
+      ],
+      "api-audit": [
+        {
+          "stakeholder": "governance-specialist",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-designer",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-engineer",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-product-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "consulted"
+        }
+      ],
+      "api-publishing": [
+        {
+          "stakeholder": "api-product-owner",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "api-devrel-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-consumer-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-engineer",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "consulted"
+        }
+      ],
+      "monitoring-and-improving": [
+        {
+          "stakeholder": "api-product-owner",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-consumer-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-devrel-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-engineer",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "domain-specialist",
+          "involvement": "consulted"
+        }
+      ]
+    },
+    "integration-productization-cycle": {
+      "api-product-strategy": [
+        {
+          "stakeholder": "integration-architect",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "customerJourneyCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "domain-specialist",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "domainCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "capability-owner",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "capabilityValuePropositionCanvas",
+              "role": "suggested-answer-owner"
+            },
+            {
+              "resource": "capabilityBusinessModelCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "platform-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-product-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "partner-specialist",
+          "involvement": "consulted"
+        }
+      ],
+      "api-consumer-experience": [
+        {
+          "stakeholder": "api-consumer-specialist",
+          "involvement": "lead",
+          "responsibilities": [
+            {
+              "resource": "consumerExperienceRequirementsCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "integration-architect",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "domain-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "customer-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "api-devrel-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "partner-specialist",
+          "involvement": "consulted"
+        }
+      ],
+      "api-platform-architecture": [
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "lead",
+          "responsibilities": [
+            {
+              "resource": "locationsCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "integration-architect",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "businessImpactCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "platform-owner",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "capacityCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "api-architect",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "api-engineer",
+          "involvement": "consulted"
+        }
+      ],
+      "api-design": [
+        {
+          "stakeholder": "integration-architect",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "api-designer",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "domain-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-consumer-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-engineer",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        }
+      ],
+      "api-delivery": [
+        {
+          "stakeholder": "api-engineer",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "integration-architect",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-designer",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "partner-specialist",
+          "involvement": "consulted"
+        }
+      ],
+      "api-audit": [
+        {
+          "stakeholder": "governance-specialist",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "integration-architect",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "api-engineer",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "consulted"
+        }
+      ],
+      "api-publishing": [
+        {
+          "stakeholder": "integration-architect",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "api-devrel-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-consumer-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "partner-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "consulted"
+        }
+      ],
+      "monitoring-and-improving": [
+        {
+          "stakeholder": "integration-architect",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-consumer-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-engineer",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "platform-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        }
+      ]
+    },
+    "automation-cycle": {
+      "api-product-strategy": [
+        {
+          "stakeholder": "automation-owner",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "process-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "customerJourneyCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "domain-specialist",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "domainCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "automation-engineer",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "platform-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        }
+      ],
+      "api-consumer-experience": [
+        {
+          "stakeholder": "process-owner",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "automation-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "customer-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "domain-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-consumer-specialist",
+          "involvement": "consulted",
+          "responsibilities": [
+            {
+              "resource": "consumerExperienceRequirementsCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        }
+      ],
+      "api-platform-architecture": [
+        {
+          "stakeholder": "platform-owner",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "automation-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "automation-engineer",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "integration-architect",
+          "involvement": "consulted"
+        }
+      ],
+      "api-design": [
+        {
+          "stakeholder": "automation-engineer",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "process-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "automation-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "integration-architect",
+          "involvement": "core",
+          "responsibilities": [
+            {
+              "resource": "interactionCanvas",
+              "role": "suggested-answer-owner"
+            }
+          ]
+        },
+        {
+          "stakeholder": "domain-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-designer",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        }
+      ],
+      "api-delivery": [
+        {
+          "stakeholder": "automation-engineer",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "automation-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "process-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "api-engineer",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        }
+      ],
+      "api-audit": [
+        {
+          "stakeholder": "governance-specialist",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "automation-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "process-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "automation-engineer",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "platform-architect",
+          "involvement": "consulted"
+        }
+      ],
+      "api-publishing": [
+        {
+          "stakeholder": "automation-owner",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "process-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "api-devrel-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "automation-engineer",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        }
+      ],
+      "monitoring-and-improving": [
+        {
+          "stakeholder": "automation-owner",
+          "involvement": "lead"
+        },
+        {
+          "stakeholder": "process-owner",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "operations-specialist",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "automation-engineer",
+          "involvement": "core"
+        },
+        {
+          "stakeholder": "business-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "platform-owner",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "security-specialist",
+          "involvement": "consulted"
+        },
+        {
+          "stakeholder": "compliance-specialist",
+          "involvement": "consulted"
+        }
+      ]
     }
-  ]
-}
+  }
+}
\ No newline at end of file
diff --git a/src/data/method/stations.json b/src/data/method/stations.json
index 51bd44b..90409c4 100644
--- a/src/data/method/stations.json
+++ b/src/data/method/stations.json
@@ -1046,14 +1046,6 @@
           {
             "step": "station.upskilling.how_it_works",
             "resource": "api-training-programs"
-          },
-          {
-            "step": "station.upskilling.how_it_works.1",
-            "resource": "api-training-programs"
-          },
-          {
-            "step": "station.upskilling.how_it_works.2",
-            "resource": "api-training-programs"
           }
         ],
         "apply_in_work": "station.upskilling.apply_in_work"
@@ -1106,14 +1098,6 @@
           {
             "step": "station.portfolio-management.how_it_works",
             "resource": "api-portfolio-management-guidelines"
-          },
-          {
-            "step": "station.portfolio-management.how_it_works.1",
-            "resource": "api-portfolio-management-guidelines"
-          },
-          {
-            "step": "station.portfolio-management.how_it_works.2",
-            "resource": "api-portfolio-management-guidelines"
           }
         ],
         "apply_in_work": "station.portfolio-management.apply_in_work"
@@ -1136,14 +1120,6 @@
           {
             "step": "station.budget-and-resource-management.how_it_works",
             "resource": "api-portfolio-management-guidelines"
-          },
-          {
-            "step": "station.budget-and-resource-management.how_it_works.1",
-            "resource": "api-portfolio-management-guidelines"
-          },
-          {
-            "step": "station.budget-and-resource-management.how_it_works.2",
-            "resource": "api-portfolio-management-guidelines"
           }
         ],
         "apply_in_work": "station.budget-and-resource-management.apply_in_work"
diff --git a/src/data/partners.json b/src/data/partners.json
new file mode 100644
index 0000000..46532d8
--- /dev/null
+++ b/src/data/partners.json
@@ -0,0 +1,32 @@
+[
+  {
+    "title": "Osaango",
+    "href": "https://www.osaango.com",
+    "logo": "/partners/osaango-black.svg",
+    "description": "Coordinates the global APIOps Cycles community and method development. Provides consulting, training and method support globally, main partner in the Nordics."
+  },
+  {
+    "title": "adorsys GmbH & Co. KG",
+    "href": "https://adorsys.com/",
+    "logo": "/partners/adorsys.svg",
+    "description": "adorsys designs secure, scalable digital ecosystems for API-driven organisations. We combine deep technical expertise with strong API strategies, governance, and enablement models to help teams build, scale, and operate APIs effectively, turning them into strategic assets that drive innovation and sustainable digital growth. "
+  },
+  {
+    "title": "APIsFirst",
+    "href": "https://www.apisfirst.com",
+    "logo": "/partners/apisfirst.svg",
+    "description": "Provides consulting and team coaching for getting value from API-related investments and API economics, using the method to accelerate understanding and impact. Global reach with local focus in the UK and Australia. "
+  },
+  {
+    "title": "API Evangelist",
+    "href": "https://apievangelist.com/",
+    "logo": "/partners/api-evangelist-logo-butterfly-transparent.png",
+    "description": "API Evangelist is committed to helping your teams focus on the fundamentals of APIs, while also working with you to make sense of the leading edge of APIs, and where all of this is going."
+  },
+  {
+    "title": "You?",
+    "href": "https://tally.so/r/3yQEpp",
+    "logo": "/favicon.svg",
+    "description": "Join the APIOps Cycles community as a partner! Click to learn more..."
+  }
+]
diff --git a/src/lib/method-engine.js b/src/lib/method-engine.js
index 8a03f9b..2a51c08 100644
--- a/src/lib/method-engine.js
+++ b/src/lib/method-engine.js
@@ -9,6 +9,7 @@ const repoRoot = path.resolve(__dirname, "..", "..");
 export const DEFAULT_LOCALE = "en";
 export const DEFAULT_OUTPUT_DIR = "specs/canvases";
 export const DEFAULT_STYLE = "Not sure yet";
+export const DEFAULT_CYCLE_ID = "api-productization-cycle";
 export const DEFAULT_NOTE_SIZE = 80;
 export const NOTE_COLOR_PALETTE = Object.freeze({
   benefit: "#C0EB6A",
@@ -73,6 +74,35 @@ export const CANVAS_SECTION_NOTE_INTENTS = Object.freeze({
     painRelievingFeatures: "benefit",
     apiProducts: "neutral"
   },
+  capabilityValuePropositionCanvas: {
+    consumerTasks: "task",
+    gainEnablingCapabilities: "benefit",
+    painRelievingCapabilities: "benefit",
+    reusableCapabilities: "neutral"
+  },
+  capabilityBusinessModelCanvas: {
+    keyPartners: "neutral",
+    keyActivities: "task",
+    keyResources: "neutral",
+    capabilityValueProposition: "benefit",
+    consumerEngagement: "neutral",
+    channels: "task",
+    capabilityConsumerSegments: "neutral",
+    costs: "negative",
+    benefits: "benefit"
+  },
+  consumerExperienceRequirementsCanvas: {
+    consumerGoals: "benefit",
+    availabilityAndTimeliness: "neutral",
+    volumeAndPerformance: "neutral",
+    dataQualityAndConsistency: "neutral",
+    securityPrivacyAndCompliance: "negative",
+    onboardingAndAccess: "task",
+    changeAndVersioning: "negative",
+    observabilityAndSupport: "task",
+    recoveryAndContinuity: "task",
+    architectureImplications: "neutral"
+  },
   businessImpactCanvas: {
     availabilityRisks: "negative",
     securityRisks: "negative",
@@ -237,10 +267,8 @@ export function getCoreStations() {
 
 export function getStations() {
   const stations = readJson(resolveMethodFile("stations.json"));
-  return [
-    ...((stations["core-stations"] && stations["core-stations"].items) || []),
-    ...((stations["sub-stations"] && stations["sub-stations"].items) || [])
-  ]
+  return Object.values(stations)
+    .flatMap((group) => group.items || [])
     .slice()
     .sort((left, right) => left.order - right.order);
 }
@@ -280,6 +308,10 @@ export function getStationCriteriaMap() {
   return readJson(resolveMethodFile("station-criteria.json"));
 }
 
+export function getCriteria() {
+  return readJson(resolveMethodFile("criteria.json"));
+}
+
 export function getStakeholders() {
   return readJson(resolveMethodFile("stakeholders.json")).stakeholders || [];
 }
@@ -288,10 +320,45 @@ export function getStationStakeholderMap() {
   return readJson(resolveMethodFile("station-stakeholders.json"));
 }
 
+export function getStationStakeholderMapForCycle(cycleId = DEFAULT_CYCLE_ID) {
+  const stationStakeholderMap = getStationStakeholderMap();
+  if (stationStakeholderMap.stationStakeholdersByCycle) {
+    const cycle = resolveCycle(cycleId);
+    const entries = stationStakeholderMap.stationStakeholdersByCycle[cycle.id];
+    if (!entries) {
+      throw new Error(`Unknown station stakeholder cycle mapping: ${cycle.id}`);
+    }
+    return entries;
+  }
+
+  return stationStakeholderMap;
+}
+
 export function getResources() {
   return readJson(resolveMethodFile("resources.json")).resources || [];
 }
 
+export function getLines() {
+  return readJson(resolveMethodFile("lines.json")).lines?.items || [];
+}
+
+export function getCycles() {
+  return readJson(resolveMethodFile("cycles.json")).cycles?.items || [];
+}
+
+export function getCycle(cycleId) {
+  const normalizedCycleId = String(cycleId || "").trim();
+  const cycle = getCycles().find((entry) => entry.id === normalizedCycleId || entry.slug === normalizedCycleId);
+  if (!cycle) {
+    throw new Error(`Unknown cycle: ${cycleId}`);
+  }
+  return cycle;
+}
+
+export function resolveCycle(cycleId = DEFAULT_CYCLE_ID) {
+  return getCycle(cycleId || DEFAULT_CYCLE_ID);
+}
+
 export function normalizeResourceId(resourceId) {
   const normalized = String(resourceId || "").trim();
   return LEGACY_CANVAS_RESOURCE_ALIASES.get(normalized) || normalized;
@@ -310,6 +377,15 @@ function translate(labelKey, labels) {
   return labels[labelKey] || labelKey;
 }
 
+function translateFromLabelSets(labelKey, ...labelSets) {
+  for (const labels of labelSets) {
+    if (labels[labelKey]) {
+      return labels[labelKey];
+    }
+  }
+  return labelKey;
+}
+
 export function buildStakeholderCatalog(locale = DEFAULT_LOCALE) {
   const stakeholderLabels = getLocalizedLabels(locale, "stakeholders");
   return new Map(getStakeholders().map((stakeholder) => [
@@ -322,14 +398,14 @@ export function buildStakeholderCatalog(locale = DEFAULT_LOCALE) {
   ]));
 }
 
-export function buildStationStakeholderData(stationId, locale = DEFAULT_LOCALE) {
+export function buildStationStakeholderData(stationId, locale = DEFAULT_LOCALE, cycleId = DEFAULT_CYCLE_ID) {
   const stakeholderCatalog = buildStakeholderCatalog(locale);
   const stakeholderLabels = getLocalizedLabels(locale, "stakeholders");
-  const stationStakeholderMap = getStationStakeholderMap();
+  const stationStakeholderMap = getStationStakeholderMapForCycle(cycleId);
   const entries = stationStakeholderMap[stationId];
 
   if (!entries) {
-    throw new Error(`Unknown station stakeholder mapping: ${stationId}`);
+    throw new Error(`Unknown station stakeholder mapping: ${stationId} in ${cycleId || DEFAULT_CYCLE_ID}`);
   }
 
   return entries.map((entry) => {
@@ -341,14 +417,20 @@ export function buildStationStakeholderData(stationId, locale = DEFAULT_LOCALE)
     return {
       ...stakeholder,
       involvement: entry.involvement,
-      involvementLabel: translate(`stakeholder.involvement.${entry.involvement}`, stakeholderLabels)
+      involvementLabel: translate(`stakeholder.involvement.${entry.involvement}`, stakeholderLabels),
+      responsibilities: entry.responsibilities || []
     };
   });
 }
 
-export function buildStartData(locale = DEFAULT_LOCALE) {
-  const stations = getCoreStations();
+export function buildStartData(locale = DEFAULT_LOCALE, cycleId = DEFAULT_CYCLE_ID) {
+  const cycle = resolveCycle(cycleId);
+  const stationById = new Map(getCoreStations().map((station) => [station.id, station]));
+  const stations = (cycle.stations || [])
+    .map((stationId) => stationById.get(stationId))
+    .filter(Boolean);
   const stationLabels = getLocalizedLabels(locale, "stations");
+  const cycleLabels = getLocalizedLabels(locale, "cycles");
   const criteriaLabels = getLocalizedLabels(locale, "criteria");
   const stationCriteriaMap = getStationCriteriaMap();
 
@@ -356,10 +438,15 @@ export function buildStartData(locale = DEFAULT_LOCALE) {
     id: station.id,
     order: station.order,
     slug: station.slug,
-    title: translate(station.title, stationLabels),
-    description: translate(station.description, stationLabels),
+    cycleId: cycle.id,
+    title: cycle.stationLabels?.[station.id]
+      ? translateFromLabelSets(cycle.stationLabels[station.id], stationLabels, cycleLabels)
+      : translate(station.title, stationLabels),
+    description: cycle.stationDescriptions?.[station.id]
+      ? translateFromLabelSets(cycle.stationDescriptions[station.id], stationLabels, cycleLabels)
+      : translate(station.description, stationLabels),
     suggestedForNewApi: index === 0,
-    stakeholders: buildStationStakeholderData(station.id, locale),
+    stakeholders: buildStationStakeholderData(station.id, locale, cycle.id),
     criteria: (stationCriteriaMap[station.id] || []).map((criterionId) => ({
       id: criterionId,
       label: translate(`criterion.${criterionId}`, criteriaLabels)
@@ -593,27 +680,39 @@ export function shouldIncludeResourceForStyle(resourceId, stationId, style) {
   return !["restCanvas", "eventCanvas", "graphqlCanvas"].includes(normalizedResourceId);
 }
 
-export function buildStationResourceData(stationId, locale = DEFAULT_LOCALE, style = DEFAULT_STYLE) {
-  const stations = getStations();
-  const resources = getResources();
-  const stationLabels = getLocalizedLabels(locale, "stations");
-  const resourceLabels = getLocalizedLabels(locale, "resources");
-  const station = stations.find((entry) => entry.id === stationId);
-
-  if (!station) {
-    throw new Error(`Unknown station id: ${stationId}`);
-  }
+function getCycleStepLabelKey(cycleId, stationId, index) {
+  const baseKey = `cycle.${cycleId}.station.${stationId}.how_it_works`;
+  return index === 0 ? baseKey : `${baseKey}.${index}`;
+}
 
-  const steps = getStationSteps(station)
-    .filter((step) => step.resource)
-    .filter((step) => shouldIncludeResourceForStyle(step.resource, stationId, style))
-    .map((step, index) => {
-      const normalizedResourceId = normalizeResourceId(step.resource);
+function buildStationResourceSteps(station, stationId, cycle, style, resources, stationLabels, cycleLabels, resourceLabels) {
+  const stationSteps = getStationSteps(station);
+  const stationStepsByResource = new Map(
+    stationSteps
+      .filter((step) => step.resource)
+      .map((step) => [normalizeResourceId(step.resource), step])
+  );
+  const resourceIds = cycle.recommendedResources?.[stationId] || stationSteps.map((step) => step.resource).filter(Boolean);
+
+  return resourceIds
+    .filter((resourceId) => shouldIncludeResourceForStyle(resourceId, stationId, style))
+    .map((resourceId, index) => {
+      const normalizedResourceId = normalizeResourceId(resourceId);
       const resource = resources.find((entry) => entry.id === normalizedResourceId);
+      const stationStep = stationStepsByResource.get(normalizedResourceId);
+      const resourceTitle = resource ? translate(resource.title, resourceLabels) : normalizedResourceId;
+      const cycleStepLabelKey = getCycleStepLabelKey(cycle.id, stationId, index);
+      const hasCycleStepLabel = cycleLabels[cycleStepLabelKey] || stationLabels[cycleStepLabelKey];
+      const stepText = hasCycleStepLabel
+        ? translateFromLabelSets(cycleStepLabelKey, cycleLabels, stationLabels)
+        : (stationStep
+          ? translate(stationStep.step, stationLabels)
+          : `Use ${resourceTitle}.`);
+
       if (!resource) {
         return {
           order: index + 1,
-          step: translate(step.step, stationLabels),
+          step: stepText,
           resourceId: normalizedResourceId,
           missing: true
         };
@@ -621,9 +720,9 @@ export function buildStationResourceData(stationId, locale = DEFAULT_LOCALE, sty
 
       return {
         order: index + 1,
-        step: translate(step.step, stationLabels),
+        step: stepText,
         resourceId: resource.id,
-        resourceTitle: translate(resource.title, resourceLabels),
+        resourceTitle,
         resourceDescription: translate(resource.description, resourceLabels),
         category: resource.category || "",
         canvasId: resource.canvas || null,
@@ -631,12 +730,37 @@ export function buildStationResourceData(stationId, locale = DEFAULT_LOCALE, sty
         slug: resource.slug
       };
     });
+}
+
+export function buildStationResourceData(stationId, locale = DEFAULT_LOCALE, style = DEFAULT_STYLE, cycleId = DEFAULT_CYCLE_ID) {
+  const stations = getStations();
+  const resources = getResources();
+  const stationLabels = getLocalizedLabels(locale, "stations");
+  const cycleLabels = getLocalizedLabels(locale, "cycles");
+  const resourceLabels = getLocalizedLabels(locale, "resources");
+  const cycle = resolveCycle(cycleId);
+  const station = stations.find((entry) => entry.id === stationId);
+
+  if (!station) {
+    throw new Error(`Unknown station id: ${stationId}`);
+  }
+
+  if (!(cycle.stations || []).includes(stationId)) {
+    throw new Error(`Station ${stationId} is not part of cycle ${cycle.id}`);
+  }
+
+  const steps = buildStationResourceSteps(station, stationId, cycle, style, resources, stationLabels, cycleLabels, resourceLabels);
 
   return {
     stationId: station.id,
-    stationTitle: translate(station.title, stationLabels),
-    stationDescription: translate(station.description, stationLabels),
-    stakeholders: buildStationStakeholderData(station.id, locale),
+    cycleId: cycle.id,
+    stationTitle: cycle.stationLabels?.[station.id]
+      ? translateFromLabelSets(cycle.stationLabels[station.id], stationLabels, cycleLabels)
+      : translate(station.title, stationLabels),
+    stationDescription: cycle.stationDescriptions?.[station.id]
+      ? translateFromLabelSets(cycle.stationDescriptions[station.id], stationLabels, cycleLabels)
+      : translate(station.description, stationLabels),
+    stakeholders: buildStationStakeholderData(station.id, locale, cycle.id),
     style,
     steps
   };
@@ -707,6 +831,168 @@ export function getCanvasCreatorUrl(canvasId, locale = DEFAULT_LOCALE) {
   return `${CANVAS_CREATOR_BASE_URL}?canvas=${encodeURIComponent(canvasId)}&locale=${encodeURIComponent(locale)}`;
 }
 
+function formatMarkdownCell(value) {
+  return String(value || "")
+    .replace(/\r?\n/g, " ")
+    .trim();
+}
+
+function formatGuidanceList(values) {
+  return values
+    .map((value) => formatMarkdownCell(value).replace(/[.;:]+$/g, ""))
+    .filter(Boolean)
+    .join("; ");
+}
+
+function isPlaceholderExampleNote(content) {
+  const normalized = String(content || "").trim().replace(/\s+/g, " ");
+  return !normalized ||
+    /^placeholder$/i.test(normalized) ||
+    /^double-click on text to edit\. click and select color$/i.test(normalized);
+}
+
+function formatExampleNotes(notes) {
+  return (notes || [])
+    .map((note) => String(note.content || "").trim())
+    .filter((content) => !isPlaceholderExampleNote(content))
+    .join("; ");
+}
+
+function formatExampleAnswer(value) {
+  const text = formatMarkdownCell(value);
+  return text ? `_Example: ${text}_` : "";
+}
+
+function renderConfluencePasteTableRow(values) {
+  return `| ${values.map((value) => formatMarkdownCell(value)).join(" | ")} |`;
+}
+
+function renderConfluenceWikiHeaderRow(values) {
+  return `|| ${values.map((value) => formatMarkdownCell(value)).join(" || ")} ||`;
+}
+
+function renderConfluenceWikiRow(values) {
+  return `| ${values.map((value) => formatMarkdownCell(value)).join(" | ")} |`;
+}
+
+function buildStationCanvasGroups(canvasRows) {
+  const groups = [];
+  const groupsByStation = new Map();
+
+  for (const row of canvasRows) {
+    const stationKey = row.stationTitle || "Requirements";
+    let group = groupsByStation.get(stationKey);
+    if (!group) {
+      group = {
+        stationTitle: stationKey,
+        stationDescription: row.stationDescription || "",
+        stationWhyItMatters: row.stationWhyItMatters || "",
+        canvasRows: []
+      };
+      groupsByStation.set(stationKey, group);
+      groups.push(group);
+    }
+
+    group.canvasRows.push(row);
+  }
+
+  return groups;
+}
+
+function findCanvasResource(canvasId) {
+  return getResources().find((resource) => resource.canvas === canvasId) || null;
+}
+
+function findCanvasStationContext(canvasId, resourceId, stationPath, stationOverlays) {
+  const overlay = stationOverlays.find((entry) => {
+    const reuse = entry.reuse || [];
+    const alternatives = entry.alternativeResources || [];
+    return reuse.includes(canvasId) ||
+      reuse.includes(resourceId) ||
+      alternatives.includes(canvasId) ||
+      alternatives.includes(resourceId);
+  });
+
+  if (!overlay) {
+    return null;
+  }
+
+  return stationPath.find((station) => station.id === overlay.station) || null;
+}
+
+function getDocumentCanvasStationContext(canvasId, resourceId, extension, stationPath) {
+  const explicitStationId = extension.documentCanvasStations?.[canvasId] || extension.documentCanvasStations?.[resourceId];
+  if (explicitStationId) {
+    return stationPath.find((station) => station.id === explicitStationId) || null;
+  }
+
+  return findCanvasStationContext(canvasId, resourceId, stationPath, extension.stationOverlays || []);
+}
+
+function findStationInstruction(stationId, resourceId, locale) {
+  if (!stationId || !resourceId) {
+    return "";
+  }
+
+  const stationLabels = getLocalizedLabels(locale, "stations");
+  const station = getStations().find((entry) => entry.id === stationId);
+  const step = getStationSteps(station || {}).find((entry) => normalizeResourceId(entry.resource) === resourceId);
+  return step ? translate(step.step, stationLabels) : "";
+}
+
+function normalizeDocumentText(value) {
+  return String(value || "");
+}
+
+function getCanvasExampleAnswers(canvasId) {
+  const templatesDir = resolveCanvasFile("import-export-templates");
+  if (!fs.existsSync(templatesDir)) {
+    return new Map();
+  }
+
+  const examplesBySection = new Map();
+  const files = fs.readdirSync(templatesDir)
+    .filter((fileName) => fileName.endsWith(".json"))
+    .map((fileName) => path.join(templatesDir, fileName));
+
+  for (const filePath of files) {
+    const template = readJson(filePath);
+    if (template.templateId !== canvasId) {
+      continue;
+    }
+
+    for (const section of template.sections || []) {
+      const exampleAnswer = formatExampleNotes(section.stickyNotes);
+      if (!exampleAnswer) {
+        continue;
+      }
+
+      const existing = examplesBySection.get(section.sectionId);
+      examplesBySection.set(
+        section.sectionId,
+        existing ? `${existing}; ${exampleAnswer}` : exampleAnswer
+      );
+    }
+  }
+
+  return examplesBySection;
+}
+
+function buildCriteriaMetadata(criteriaIds, locale) {
+  const criteriaLabels = getLocalizedLabels(locale, "criteria");
+  const criteriaById = new Map(getCriteria().map((criterion) => [criterion.id, criterion]));
+  return (criteriaIds || [])
+    .map((criterionId) => {
+      const criterion = criteriaById.get(criterionId);
+      return criterion ? {
+        id: criterion.id,
+        title: translate(`criterion.${criterion.id}`, criteriaLabels),
+        description: criterion.description
+      } : null;
+    })
+    .filter(Boolean);
+}
+
 export function resolveStationIds(options = {}) {
   if (options.station) {
     return [options.station];
@@ -720,7 +1006,8 @@ export function resolveStationIds(options = {}) {
   }
 
   if (!options.preset || options.preset === "new-api") {
-    return NEW_API_STATIONS;
+    const cycle = resolveCycle(options.cycle || DEFAULT_CYCLE_ID);
+    return NEW_API_STATIONS.filter((stationId) => (cycle.stations || []).includes(stationId));
   }
 
   throw new Error(`Unknown preset: ${options.preset}`);
@@ -729,6 +1016,7 @@ export function resolveStationIds(options = {}) {
 export function generateCanvases(options = {}) {
   const locale = options.locale || DEFAULT_LOCALE;
   const style = normalizeStyle(options.style || DEFAULT_STYLE);
+  const cycle = resolveCycle(options.cycle || DEFAULT_CYCLE_ID);
   const outputRoot = path.resolve(process.cwd(), options.output || DEFAULT_OUTPUT_DIR);
   const resources = getResources();
   const generated = [];
@@ -736,7 +1024,7 @@ export function generateCanvases(options = {}) {
   const seenResourceIds = new Set();
 
   for (const stationId of resolveStationIds(options)) {
-    const stationResources = buildStationResourceData(stationId, locale, style);
+    const stationResources = buildStationResourceData(stationId, locale, style, cycle.id);
     const canvasResources = stationResources.steps
       .map((step) => resources.find((resource) => resource.id === step.resourceId))
       .filter((resource) => resource && resource.category === "canvas");
@@ -774,6 +1062,7 @@ export function generateCanvases(options = {}) {
   return {
     locale,
     style,
+    cycleId: cycle.id,
     outputRoot,
     generated,
     skipped
diff --git a/src/schemas/cycles.schema.json b/src/schemas/cycles.schema.json
new file mode 100644
index 0000000..e100a90
--- /dev/null
+++ b/src/schemas/cycles.schema.json
@@ -0,0 +1,84 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "required": ["cycles"],
+  "additionalProperties": false,
+  "properties": {
+    "cycles": {
+      "type": "object",
+      "required": ["title", "slug", "order", "description", "items"],
+      "additionalProperties": false,
+      "properties": {
+        "title": { "type": "string" },
+        "slug": { "type": "string" },
+        "order": { "type": "number" },
+        "description": { "type": "string" },
+        "items": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "$ref": "#/definitions/cycle" }
+        }
+      }
+    }
+  },
+  "definitions": {
+    "cycle": {
+      "type": "object",
+      "required": ["id", "title", "slug", "description", "purpose", "stations"],
+      "additionalProperties": false,
+      "properties": {
+        "id": { "type": "string" },
+        "title": { "type": "string" },
+        "slug": { "type": "string" },
+        "description": { "type": "string" },
+        "audiences": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "type": "string" }
+        },
+        "purpose": { "type": "string" },
+        "stations": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "type": "string" }
+        },
+        "stationLabels": {
+          "type": "object",
+          "additionalProperties": { "type": "string" }
+        },
+        "stationDescriptions": {
+          "type": "object",
+          "additionalProperties": { "type": "string" }
+        },
+        "recommendedResources": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "array",
+            "items": { "type": "string" }
+          }
+        },
+        "overlays": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["station", "assistance", "humanValidation"],
+            "additionalProperties": false,
+            "properties": {
+              "station": { "type": "string" },
+              "assistance": { "type": "string" },
+              "humanValidation": { "type": "string" }
+            }
+          }
+        },
+        "entryCriteria": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "exitCriteria": {
+          "type": "array",
+          "items": { "type": "string" }
+        }
+      }
+    }
+  }
+}
diff --git a/src/schemas/station-stakeholders.schema.json b/src/schemas/station-stakeholders.schema.json
index 8965b63..b70c3f0 100644
--- a/src/schemas/station-stakeholders.schema.json
+++ b/src/schemas/station-stakeholders.schema.json
@@ -1,17 +1,39 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "type": "object",
-  "additionalProperties": {
-    "type": "array",
-    "items": {
+  "required": ["stationStakeholdersByCycle"],
+  "additionalProperties": false,
+  "properties": {
+    "stationStakeholdersByCycle": {
       "type": "object",
-      "required": ["stakeholder", "involvement"],
-      "additionalProperties": false,
-      "properties": {
-        "stakeholder": {"type": "string"},
-        "involvement": {
-          "type": "string",
-          "enum": ["lead", "core", "consulted"]
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["stakeholder", "involvement"],
+            "additionalProperties": false,
+            "properties": {
+              "stakeholder": { "type": "string" },
+              "involvement": {
+                "type": "string",
+                "enum": ["lead", "core", "consulted"]
+              },
+              "responsibilities": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "required": ["resource", "role"],
+                  "additionalProperties": false,
+                  "properties": {
+                    "resource": { "type": "string" },
+                    "role": { "type": "string" }
+                  }
+                }
+              }
+            }
+          }
         }
       }
     }
diff --git a/src/schemas/stations.schema.json b/src/schemas/stations.schema.json
index 4859a78..626a9f8 100644
--- a/src/schemas/stations.schema.json
+++ b/src/schemas/stations.schema.json
@@ -40,6 +40,30 @@
                 "type": "array",
                 "items": {"type": "string"}
               },
+              "type": {"type": "string"},
+              "applicableCycles": {
+                "type": "array",
+                "items": {"type": "string"}
+              },
+              "defaultForCycles": {
+                "type": "array",
+                "items": {"type": "string"}
+              },
+              "cycleSpecificLabels": {
+                "type": "object",
+                "additionalProperties": {"type": "string"}
+              },
+              "cycleSpecificDescriptions": {
+                "type": "object",
+                "additionalProperties": {"type": "string"}
+              },
+              "cycleSpecificResources": {
+                "type": "object",
+                "additionalProperties": {
+                  "type": "array",
+                  "items": {"type": "string"}
+                }
+              },
               "how_it_works": {
                 "type": "array",
                 "items": {
@@ -60,6 +84,14 @@
       }
     },
     "sub-stations": {
+      "$ref": "#/definitions/stationGroup"
+    },
+    "integration-stations": {
+      "$ref": "#/definitions/stationGroup"
+    }
+  },
+  "definitions": {
+    "stationGroup": {
       "type": "object",
       "required": ["title", "slug", "order", "description", "items"],
       "additionalProperties": false,
@@ -95,6 +127,30 @@
                 "type": "array",
                 "items": {"type": "string"}
               },
+              "type": {"type": "string"},
+              "applicableCycles": {
+                "type": "array",
+                "items": {"type": "string"}
+              },
+              "defaultForCycles": {
+                "type": "array",
+                "items": {"type": "string"}
+              },
+              "cycleSpecificLabels": {
+                "type": "object",
+                "additionalProperties": {"type": "string"}
+              },
+              "cycleSpecificDescriptions": {
+                "type": "object",
+                "additionalProperties": {"type": "string"}
+              },
+              "cycleSpecificResources": {
+                "type": "object",
+                "additionalProperties": {
+                  "type": "array",
+                  "items": {"type": "string"}
+                }
+              },
               "how_it_works": {
                 "type": "array",
                 "items": {