(function() {
  var extra = [
      {
          "type": "single",
          "domain": {
              "en": "Configure Processes and Communications",
              "de": "Prozesse und Kommunikation konfigurieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Several product teams work in one Azure DevOps project, but each team needs its own board and backlog ownership.",
              "de": "Mehrere Produktteams arbeiten in einem Azure-DevOps-Projekt, aber jedes Team benötigt ein eigenes Board und eigenes Backlog-Ownership."
          },
          "question": {
              "en": "Which Azure Boards setting should you use to separate team ownership inside one project?",
              "de": "Welche Azure-Boards-Einstellung sollten Sie verwenden, um Teamverantwortung innerhalb eines Projekts zu trennen?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Area paths",
                      "de": "Area Paths"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Iteration paths",
                      "de": "Iterationspfade"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Agent pools",
                      "de": "Agent-Pools"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Service connections",
                      "de": "Serviceverbindungen"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Area paths separate team ownership and backlog views while keeping work in one Azure DevOps project.",
              "de": "Area Paths trennen Teamverantwortung und Backlog-Ansichten, während die Arbeit in einem Azure-DevOps-Projekt bleibt."
          },
          "hint": {
              "en": "Focus on separating ownership, not sprint timing.",
              "de": "Achten Sie auf die Trennung von Verantwortlichkeiten, nicht auf Sprint-Zeitpläne."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/organizations/settings/set-area-paths?view=azure-devops",
          "id": "az400-207"
      },
      {
          "type": "single",
          "domain": {
              "en": "Configure Processes and Communications",
              "de": "Prozesse und Kommunikation konfigurieren"
          },
          "difficulty": "easy",
          "scenario": {
              "en": "One team runs two-week sprints and another runs monthly sprints in the same project.",
              "de": "Ein Team arbeitet in zweiwöchigen Sprints und ein anderes in monatlichen Sprints im selben Projekt."
          },
          "question": {
              "en": "What should you configure so each team can plan against its own sprint cadence?",
              "de": "Was sollten Sie konfigurieren, damit jedes Team gegen seinen eigenen Sprint-Rhythmus planen kann?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Iteration paths",
                      "de": "Iterationspfade"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Area paths",
                      "de": "Area Paths"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Branch policies",
                      "de": "Branchrichtlinien"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Dashboards",
                      "de": "Dashboards"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Iteration paths define sprint calendars and can be assigned differently per team.",
              "de": "Iterationspfade definieren Sprint-Kalender und können pro Team unterschiedlich zugeordnet werden."
          },
          "hint": {
              "en": "This requirement is about cadence and sprint dates.",
              "de": "Diese Anforderung betrifft Taktung und Sprint-Termine."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/organizations/settings/set-iteration-paths-sprints?view=azure-devops",
          "id": "az400-208"
      },
      {
          "type": "single",
          "domain": {
              "en": "Configure Processes and Communications",
              "de": "Prozesse und Kommunikation konfigurieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Release managers want a timeline that shows milestones and dependencies across several Azure Boards teams.",
              "de": "Release-Manager möchten eine Zeitachse, die Meilensteine und Abhängigkeiten über mehrere Azure-Boards-Teams hinweg zeigt."
          },
          "question": {
              "en": "Which feature should you use?",
              "de": "Welche Funktion sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Delivery Plans",
                      "de": "Delivery Plans"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Test Plans",
                      "de": "Test Plans"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Deployment groups",
                      "de": "Bereitstellungsgruppen"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Variable groups",
                      "de": "Variablengruppen"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Delivery Plans provides a cross-team roadmap view for work, dependencies, and milestones.",
              "de": "Delivery Plans bietet eine teamübergreifende Roadmap-Ansicht für Arbeit, Abhängigkeiten und Meilensteine."
          },
          "hint": {
              "en": "Choose the planning view that spans more than one backlog.",
              "de": "Wählen Sie die Planungsansicht, die mehr als ein Backlog umfasst."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/boards/plans/review-team-plans?view=azure-devops",
          "id": "az400-209"
      },
      {
          "type": "single",
          "domain": {
              "en": "Configure Processes and Communications",
              "de": "Prozesse und Kommunikation konfigurieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Program managers need one board that tracks work from many repositories and uses custom fields such as roadmap and business unit.",
              "de": "Programmmanager benötigen ein Board, das Arbeit aus vielen Repositorys verfolgt und benutzerdefinierte Felder wie Roadmap und Geschäftseinheit verwendet."
          },
          "question": {
              "en": "Which GitHub capability fits best?",
              "de": "Welche GitHub-Funktion passt am besten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "GitHub Projects",
                      "de": "GitHub Projects"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "GitHub Packages",
                      "de": "GitHub Packages"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Git tags",
                      "de": "Git-Tags"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "GitHub Releases",
                      "de": "GitHub Releases"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "GitHub Projects supports cross-repository planning, custom fields, and board or table views.",
              "de": "GitHub Projects unterstützt repositoryübergreifende Planung, benutzerdefinierte Felder sowie Board- oder Tabellenansichten."
          },
          "hint": {
              "en": "Look for planning across multiple repositories.",
              "de": "Suchen Sie nach Planung über mehrere Repositorys hinweg."
          },
          "reference": "https://docs.github.com/en/issues/planning-and-tracking-with-projects/learning-about-projects/about-projects",
          "id": "az400-210"
      },
      {
          "type": "single",
          "domain": {
              "en": "Configure Processes and Communications",
              "de": "Prozesse und Kommunikation konfigurieren"
          },
          "difficulty": "easy",
          "scenario": {
              "en": "A Kanban team has too many items sitting in In Progress and Code Review at the same time.",
              "de": "Ein Kanban-Team hat zu viele Elemente gleichzeitig in In Progress und Code Review."
          },
          "question": {
              "en": "What should the team configure on its board?",
              "de": "Was sollte das Team auf seinem Board konfigurieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "WIP limits",
                      "de": "WIP-Limits"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Branch policies",
                      "de": "Branchrichtlinien"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Release gates",
                      "de": "Release-Gates"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Deployment jobs",
                      "de": "Deployment-Jobs"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "WIP limits cap active items per column and help expose bottlenecks early.",
              "de": "WIP-Limits begrenzen aktive Elemente pro Spalte und machen Engpässe früh sichtbar."
          },
          "hint": {
              "en": "The problem is too much parallel work on the board.",
              "de": "Das Problem ist zu viel parallele Arbeit auf dem Board."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/boards/boards/kanban-basics?view=azure-devops",
          "id": "az400-211"
      },
      {
          "type": "single",
          "domain": {
              "en": "Configure Processes and Communications",
              "de": "Prozesse und Kommunikation konfigurieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Stakeholders want Azure Boards events sent automatically to Microsoft Teams or another webhook endpoint.",
              "de": "Stakeholder möchten, dass Azure-Boards-Ereignisse automatisch an Microsoft Teams oder einen anderen Webhook-Endpunkt gesendet werden."
          },
          "question": {
              "en": "What should you configure?",
              "de": "Was sollten Sie konfigurieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Service hooks",
                      "de": "Service Hooks"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Agent queues",
                      "de": "Agent-Warteschlangen"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Deployment groups",
                      "de": "Bereitstellungsgruppen"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Stage templates",
                      "de": "Stage-Templates"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Service hooks publish Azure DevOps events to external systems such as Teams, webhooks, and ticketing tools.",
              "de": "Service Hooks veröffentlichen Azure-DevOps-Ereignisse an externe Systeme wie Teams, Webhooks und Ticketing-Tools."
          },
          "hint": {
              "en": "This requirement is about event-driven notifications.",
              "de": "Diese Anforderung betrifft ereignisgesteuerte Benachrichtigungen."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/service-hooks/overview?view=azure-devops",
          "id": "az400-212"
      },
      {
          "type": "single",
          "domain": {
              "en": "Configure Processes and Communications",
              "de": "Prozesse und Kommunikation konfigurieren"
          },
          "difficulty": "easy",
          "scenario": {
              "en": "Every new bug should start with the same default fields, checklist, and owner hints.",
              "de": "Jeder neue Bug soll mit denselben Standardfeldern, derselben Checkliste und denselben Besitzer-Hinweisen starten."
          },
          "question": {
              "en": "Which Azure Boards feature helps most?",
              "de": "Welche Azure-Boards-Funktion hilft am meisten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Work item templates",
                      "de": "Work-Item-Templates"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Delivery Plans",
                      "de": "Delivery Plans"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Agent capabilities",
                      "de": "Agent-Fähigkeiten"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Pull request comments",
                      "de": "Pull-Request-Kommentare"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Work item templates prepopulate common fields and reduce manual setup when creating items.",
              "de": "Work-Item-Templates füllen gemeinsame Felder vorab aus und verringern den manuellen Aufwand beim Erstellen von Elementen."
          },
          "hint": {
              "en": "The goal is consistent item creation.",
              "de": "Das Ziel ist eine konsistente Erstellung von Arbeitselementen."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/boards/backlogs/work-item-template?view=azure-devops",
          "id": "az400-213"
      },
      {
          "type": "single",
          "domain": {
              "en": "Configure Processes and Communications",
              "de": "Prozesse und Kommunikation konfigurieren"
          },
          "difficulty": "easy",
          "scenario": null,
          "question": {
              "en": "Which Azure Boards feature is best for lightweight cross-cutting classification such as labeling items with audit, customer, or urgent?",
              "de": "Welche Azure-Boards-Funktion eignet sich am besten für eine leichte, bereichsübergreifende Klassifizierung wie Audit, Kunde oder dringend?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Tags",
                      "de": "Tags"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Area paths",
                      "de": "Area Paths"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Iteration paths",
                      "de": "Iterationspfade"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Agent pools",
                      "de": "Agent-Pools"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Tags add flexible labels without changing hierarchy or team ownership.",
              "de": "Tags fügen flexible Kennzeichnungen hinzu, ohne Hierarchie oder Teamverantwortung zu ändern."
          },
          "hint": {
              "en": "Choose the option for ad hoc labeling.",
              "de": "Wählen Sie die Option für ad hoc Kennzeichnungen."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/boards/queries/add-tags-to-work-items?view=azure-devops",
          "id": "az400-214"
      },
      {
          "type": "single",
          "domain": {
              "en": "Configure Processes and Communications",
              "de": "Prozesse und Kommunikation konfigurieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Leadership wants to build a Power BI report from Azure Boards data without querying the operational store directly.",
              "de": "Die Leitung möchte einen Power-BI-Bericht aus Azure-Boards-Daten erstellen, ohne den operativen Datenspeicher direkt abzufragen."
          },
          "question": {
              "en": "What should you use?",
              "de": "Was sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Analytics views",
                      "de": "Analytics Views"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Deployment groups",
                      "de": "Bereitstellungsgruppen"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Secure files",
                      "de": "Secure Files"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Service connections",
                      "de": "Serviceverbindungen"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Analytics views provide reporting-friendly data for Power BI and analytics scenarios.",
              "de": "Analytics Views liefern berichtsfreundliche Daten für Power BI und Analytik-Szenarien."
          },
          "hint": {
              "en": "This requirement is about reporting, not delivery.",
              "de": "Diese Anforderung betrifft Reporting, nicht Bereitstellung."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/report/powerbi/overview?view=azure-devops",
          "id": "az400-215"
      },
      {
          "type": "single",
          "domain": {
              "en": "Configure Processes and Communications",
              "de": "Prozesse und Kommunikation konfigurieren"
          },
          "difficulty": "medium",
          "scenario": null,
          "question": {
              "en": "You want to plan initiatives at epic and feature level above the product backlog. Which Azure Boards capability should you use?",
              "de": "Sie möchten Initiativen auf Epic- und Feature-Ebene oberhalb des Produkt-Backlogs planen. Welche Azure-Boards-Funktion sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Portfolio backlogs",
                      "de": "Portfolio-Backlogs"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Variable groups",
                      "de": "Variablengruppen"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Service hooks",
                      "de": "Service Hooks"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Release gates",
                      "de": "Release-Gates"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Portfolio backlogs add higher planning levels such as epics and features above user stories or backlog items.",
              "de": "Portfolio-Backlogs fügen höhere Planungsebenen wie Epics und Features über User Stories oder Backlog-Elementen hinzu."
          },
          "hint": {
              "en": "The requirement is hierarchical planning.",
              "de": "Die Anforderung betrifft hierarchische Planung."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/boards/backlogs/define-features-epics?view=azure-devops",
          "id": "az400-216"
      },
      {
          "type": "single",
          "domain": {
              "en": "Configure Processes and Communications",
              "de": "Prozesse und Kommunikation konfigurieren"
          },
          "difficulty": "easy",
          "scenario": {
              "en": "Engineers want documentation stored with code and changed by pull requests.",
              "de": "Ingenieure möchten Dokumentation zusammen mit dem Code speichern und über Pull Requests ändern."
          },
          "question": {
              "en": "What should you publish in Azure DevOps?",
              "de": "Was sollten Sie in Azure DevOps veröffentlichen?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "A code wiki from a Git repository",
                      "de": "Ein Code-Wiki aus einem Git-Repository"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A deployment group",
                      "de": "Eine Bereitstellungsgruppe"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A classic release only",
                      "de": "Nur ein klassisches Release"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "An agent queue",
                      "de": "Eine Agent-Warteschlange"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A code wiki keeps markdown in Git and lets teams review documentation changes through normal PR workflows.",
              "de": "Ein Code-Wiki hält Markdown in Git und lässt Teams Dokumentationsänderungen über normale PR-Workflows prüfen."
          },
          "hint": {
              "en": "The key idea is versioned docs with PR review.",
              "de": "Die Kernidee ist versionierte Dokumentation mit PR-Review."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/project/wiki/publish-repo-to-wiki?view=azure-devops",
          "id": "az400-217"
      },
      {
          "type": "multiple",
          "domain": {
              "en": "Configure Processes and Communications",
              "de": "Prozesse und Kommunikation konfigurieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Developers use GitHub for code and Azure Boards for tracking. Product owners want automatic traceability from commits and pull requests to work items.",
              "de": "Entwickler verwenden GitHub für Code und Azure Boards für die Nachverfolgung. Product Owner möchten automatische Rückverfolgbarkeit von Commits und Pull Requests zu Arbeitselementen."
          },
          "question": {
              "en": "Which two actions should you take?",
              "de": "Welche zwei Maßnahmen sollten Sie ergreifen?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Connect the GitHub repository to Azure Boards",
                      "de": "Das GitHub-Repository mit Azure Boards verbinden"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Mention work item IDs such as AB#123 in commits and pull requests",
                      "de": "Work-Item-IDs wie AB#123 in Commits und Pull Requests angeben"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Disable development links",
                      "de": "Entwicklungslinks deaktivieren"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Use deployment groups",
                      "de": "Bereitstellungsgruppen verwenden"
                  }
              }
          ],
          "correct": [
              "A",
              "B"
          ],
          "explanation": {
              "en": "The GitHub-Azure Boards integration plus AB# linking creates the traceability chain from code changes to work items.",
              "de": "Die GitHub-Azure-Boards-Integration zusammen mit AB#-Verknüpfungen erzeugt die Rückverfolgbarkeitskette von Codeänderungen zu Arbeitselementen."
          },
          "hint": {
              "en": "One choice connects the systems and the other creates the link from change to item.",
              "de": "Eine Auswahl verbindet die Systeme, die andere erstellt die Verknüpfung von Änderung zu Arbeitselement."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/boards/github/?view=azure-devops",
          "id": "az400-218"
      },
      {
          "type": "single",
          "domain": {
              "en": "Configure Processes and Communications",
              "de": "Prozesse und Kommunikation konfigurieren"
          },
          "difficulty": "easy",
          "scenario": {
              "en": "A manager wants an email whenever work items assigned to her are updated.",
              "de": "Eine Managerin möchte eine E-Mail erhalten, wann immer ihr zugewiesene Arbeitselemente aktualisiert werden."
          },
          "question": {
              "en": "Which Azure DevOps capability should she use?",
              "de": "Welche Azure-DevOps-Funktion sollte sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Notifications and subscriptions",
                      "de": "Benachrichtigungen und Abonnements"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Deployment jobs",
                      "de": "Deployment-Jobs"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Branch policies",
                      "de": "Branchrichtlinien"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Agent demands",
                      "de": "Agent-Anforderungen"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Notifications and subscriptions send rule-based emails or alerts when selected events occur.",
              "de": "Benachrichtigungen und Abonnements senden regelbasierte E-Mails oder Warnungen, wenn ausgewählte Ereignisse eintreten."
          },
          "hint": {
              "en": "The requirement is personal event notification.",
              "de": "Die Anforderung betrifft persönliche Ereignisbenachrichtigungen."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/organizations/notifications/about-notifications?view=azure-devops",
          "id": "az400-219"
      },
      {
          "type": "single",
          "domain": {
              "en": "Configure Processes and Communications",
              "de": "Prozesse und Kommunikation konfigurieren"
          },
          "difficulty": "medium",
          "scenario": null,
          "question": {
              "en": "Which Azure Boards chart is most useful for forecasting capacity from how much work a team typically completes each sprint?",
              "de": "Welches Azure-Boards-Diagramm ist am nützlichsten, um Kapazität aus der Menge an Arbeit vorherzusagen, die ein Team typischerweise pro Sprint abschließt?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Velocity chart",
                      "de": "Velocity-Diagramm"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Deployment chart",
                      "de": "Deployment-Diagramm"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Approval history",
                      "de": "Genehmigungsverlauf"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Agent utilization",
                      "de": "Agent-Auslastung"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A velocity chart shows completed work per iteration and supports sprint forecasting.",
              "de": "Ein Velocity-Diagramm zeigt abgeschlossene Arbeit pro Iteration und unterstützt die Sprint-Prognose."
          },
          "hint": {
              "en": "Think about throughput per sprint.",
              "de": "Denken Sie an Durchsatz pro Sprint."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/report/dashboards/team-velocity?view=azure-devops",
          "id": "az400-220"
      },
      {
          "type": "single",
          "domain": {
              "en": "Configure Processes and Communications",
              "de": "Prozesse und Kommunikation konfigurieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Two teams own different services, and one backlog item cannot start until another team finishes a prerequisite item.",
              "de": "Zwei Teams verantworten unterschiedliche Services, und ein Backlog-Element kann erst starten, wenn ein anderes Team ein vorausgehendes Element abgeschlossen hat."
          },
          "question": {
              "en": "What should you add between the work items?",
              "de": "Was sollten Sie zwischen den Arbeitselementen hinzufügen?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Predecessor and successor links",
                      "de": "Vorgänger- und Nachfolger-Links"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Agent capabilities",
                      "de": "Agent-Fähigkeiten"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Variable groups",
                      "de": "Variablengruppen"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Package feeds",
                      "de": "Paket-Feeds"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Predecessor and successor links model delivery dependencies directly between work items.",
              "de": "Vorgänger- und Nachfolger-Links modellieren Lieferabhängigkeiten direkt zwischen Arbeitselementen."
          },
          "hint": {
              "en": "This is about dependency tracking between items.",
              "de": "Dies betrifft die Nachverfolgung von Abhängigkeiten zwischen Elementen."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/boards/backlogs/add-link?view=azure-devops",
          "id": "az400-221"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "easy",
          "scenario": null,
          "question": {
              "en": "A team deploys to production many times per day and wants minimal merge overhead. Which branching model is the best fit?",
              "de": "Ein Team stellt mehrmals pro Tag in Produktion bereit und möchte minimalen Merge-Aufwand. Welches Branching-Modell passt am besten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Trunk-based development with short-lived branches",
                      "de": "Trunk-Based Development mit kurzlebigen Branches"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Long-lived GitFlow branches for all work",
                      "de": "Langlebige GitFlow-Branches für alle Arbeiten"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "One branch per developer for months",
                      "de": "Ein Branch pro Entwickler für Monate"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "No shared branch at all",
                      "de": "Überhaupt kein gemeinsamer Branch"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Trunk-based development keeps integration frequent and reduces branch divergence.",
              "de": "Trunk-Based Development hält die Integration häufig und reduziert die Abweichung zwischen Branches."
          },
          "hint": {
              "en": "Choose the model optimized for continuous integration.",
              "de": "Wählen Sie das Modell, das für Continuous Integration optimiert ist."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/repos/git/git-branching-guidance?view=azure-devops",
          "id": "az400-222"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Every change to main must have peer review and a successful build before it can merge.",
              "de": "Jede Änderung an main muss vor dem Merge Peer Review und einen erfolgreichen Build haben."
          },
          "question": {
              "en": "What should you configure?",
              "de": "Was sollten Sie konfigurieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Branch policies with required reviewers and build validation",
                      "de": "Branchrichtlinien mit verpflichtenden Reviewern und Buildvalidierung"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A local pre-commit hook",
                      "de": "Einen lokalen Pre-Commit-Hook"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A weekly scheduled pipeline",
                      "de": "Eine wöchentliche geplante Pipeline"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Force pushes for maintainers",
                      "de": "Force Pushes für Maintainer"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Branch policies enforce review and build checks centrally on the protected branch.",
              "de": "Branchrichtlinien erzwingen Review- und Build-Prüfungen zentral auf dem geschützten Branch."
          },
          "hint": {
              "en": "The control must be enforced on the branch, not on each laptop.",
              "de": "Die Kontrolle muss auf dem Branch erzwungen werden, nicht auf jedem Laptop."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/repos/git/branch-policies?view=azure-devops",
          "id": "az400-223"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Files under /infra must always request review from the platform engineering team.",
              "de": "Dateien unter /infra sollen immer eine Review-Anfrage an das Platform-Engineering-Team auslösen."
          },
          "question": {
              "en": "Which GitHub feature should you use?",
              "de": "Welche GitHub-Funktion sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "CODEOWNERS",
                      "de": "CODEOWNERS"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Git tags",
                      "de": "Git-Tags"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Release notes",
                      "de": "Release Notes"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Project fields",
                      "de": "Projektfelder"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "CODEOWNERS maps paths to reviewers and can automatically request reviews on pull requests.",
              "de": "CODEOWNERS ordnet Pfade Reviewern zu und kann in Pull Requests automatisch Reviews anfordern."
          },
          "hint": {
              "en": "The requirement is path-based ownership.",
              "de": "Die Anforderung betrifft pfadbasierte Verantwortlichkeit."
          },
          "reference": "https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners",
          "id": "az400-224"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "easy",
          "scenario": null,
          "question": {
              "en": "Which merge option creates one clean commit for the whole pull request and keeps the main branch history compact?",
              "de": "Welche Merge-Option erstellt einen sauberen Commit für den gesamten Pull Request und hält die Historie von main kompakt?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Squash and merge",
                      "de": "Squash and Merge"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Merge commit",
                      "de": "Merge Commit"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Cherry-pick",
                      "de": "Cherry-Pick"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Force push",
                      "de": "Force Push"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Squash and merge condenses a PR into one commit and keeps history easier to read.",
              "de": "Squash and Merge verdichtet einen PR zu einem Commit und hält die Historie leichter lesbar."
          },
          "hint": {
              "en": "Look for one commit per pull request.",
              "de": "Suchen Sie nach genau einem Commit pro Pull Request."
          },
          "reference": "https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/incorporating-changes-from-a-pull-request/about-merge-methods-on-github",
          "id": "az400-225"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": null,
          "question": {
              "en": "In GitHub, which branch protection setting helps keep main on a linear history without merge commits?",
              "de": "Welche Branch-Protection-Einstellung in GitHub hilft, main mit linearer Historie ohne Merge Commits zu halten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Require linear history",
                      "de": "Lineare Historie verlangen"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Allow force pushes",
                      "de": "Force Pushes erlauben"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Disable pull requests",
                      "de": "Pull Requests deaktivieren"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Ignore status checks",
                      "de": "Status Checks ignorieren"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Require linear history blocks merge commits and preserves a cleaner sequence of commits.",
              "de": "Lineare Historie verlangen blockiert Merge Commits und bewahrt eine sauberere Commit-Folge."
          },
          "hint": {
              "en": "The requirement explicitly mentions linear history.",
              "de": "Die Anforderung nennt ausdrücklich lineare Historie."
          },
          "reference": "https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/about-protected-branches",
          "id": "az400-226"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Main must reject direct pushes and force pushes from most users.",
              "de": "Main muss direkte Pushes und Force Pushes für die meisten Benutzer ablehnen."
          },
          "question": {
              "en": "What should you configure?",
              "de": "Was sollten Sie konfigurieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Protected branch rules",
                      "de": "Geschützte Branch-Regeln"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Draft pull requests",
                      "de": "Draft Pull Requests"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Annotated tags",
                      "de": "Annotierte Tags"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Sparse checkout",
                      "de": "Sparse Checkout"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Protected branch rules centralize controls such as blocking direct pushes and force pushes.",
              "de": "Geschützte Branch-Regeln zentralisieren Kontrollen wie das Blockieren direkter Pushes und Force Pushes."
          },
          "hint": {
              "en": "This is branch-level protection, not a local workflow preference.",
              "de": "Dies ist Branch-Schutz auf zentraler Ebene, keine lokale Workflow-Präferenz."
          },
          "reference": "https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/about-protected-branches",
          "id": "az400-227"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A hotfix already exists on main, and you need only that one fix on the current release branch.",
              "de": "Ein Hotfix existiert bereits auf main, und Sie benötigen nur diesen einen Fix auf dem aktuellen Release-Branch."
          },
          "question": {
              "en": "Which Git operation should you use?",
              "de": "Welche Git-Operation sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Cherry-pick",
                      "de": "Cherry-Pick"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Reset --hard",
                      "de": "Reset --hard"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Rebase --onto everything",
                      "de": "Rebase --onto für alles"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Delete the branch",
                      "de": "Den Branch löschen"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Cherry-pick applies a specific commit onto another branch without merging all other changes.",
              "de": "Cherry-Pick wendet einen bestimmten Commit auf einen anderen Branch an, ohne alle anderen Änderungen zu mergen."
          },
          "hint": {
              "en": "Only one existing commit is needed.",
              "de": "Es wird nur ein einzelner vorhandener Commit benötigt."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/repos/git/git-branching-guidance?view=azure-devops",
          "id": "az400-228"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "External contributors should propose changes without receiving write access to the main repository.",
              "de": "Externe Mitwirkende sollen Änderungen vorschlagen können, ohne Schreibzugriff auf das Haupt-Repository zu erhalten."
          },
          "question": {
              "en": "Which workflow is best?",
              "de": "Welcher Workflow ist am besten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Fork and pull request workflow",
                      "de": "Fork-und-Pull-Request-Workflow"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Direct pushes to main",
                      "de": "Direkte Pushes auf main"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Shared admin accounts",
                      "de": "Geteilte Admin-Konten"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Force pushes to release",
                      "de": "Force Pushes auf release"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A fork-based workflow isolates contributor permissions while still allowing pull request review.",
              "de": "Ein Fork-basierter Workflow isoliert Berechtigungen von Mitwirkenden und erlaubt dennoch Pull-Request-Reviews."
          },
          "hint": {
              "en": "The requirement is contribution without write access.",
              "de": "Die Anforderung ist Mitarbeit ohne Schreibzugriff."
          },
          "reference": "https://docs.github.com/en/get-started/quickstart/contributing-to-projects",
          "id": "az400-229"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Several microservices and shared libraries must be changed together in one atomic pull request.",
              "de": "Mehrere Microservices und gemeinsame Bibliotheken müssen gemeinsam in einem atomaren Pull Request geändert werden."
          },
          "question": {
              "en": "Which repository strategy best supports that requirement?",
              "de": "Welche Repository-Strategie unterstützt diese Anforderung am besten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Monorepo",
                      "de": "Monorepo"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Separate repository for every file",
                      "de": "Ein separates Repository für jede Datei"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Binary-only releases",
                      "de": "Nur Binär-Releases"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A wiki instead of source control",
                      "de": "Ein Wiki statt Versionskontrolle"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A monorepo enables atomic cross-service changes and one pull request for related updates.",
              "de": "Ein Monorepo ermöglicht atomare serviceübergreifende Änderungen und einen Pull Request für zusammengehörige Updates."
          },
          "hint": {
              "en": "Look for atomic changes across components.",
              "de": "Suchen Sie nach atomaren Änderungen über Komponenten hinweg."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/repos/git/git-branching-guidance?view=azure-devops",
          "id": "az400-230"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Each product team needs its own permissions, release cadence, and repository lifecycle.",
              "de": "Jedes Produktteam benötigt eigene Berechtigungen, einen eigenen Release-Rhythmus und einen eigenen Repository-Lebenszyklus."
          },
          "question": {
              "en": "Which repository strategy is the better fit?",
              "de": "Welche Repository-Strategie ist besser geeignet?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Multi-repo",
                      "de": "Multi-Repo"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Monorepo",
                      "de": "Monorepo"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "One branch per team in one repo",
                      "de": "Ein Branch pro Team in einem Repository"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A single ZIP file",
                      "de": "Eine einzelne ZIP-Datei"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A multi-repo model separates permissions and release lifecycles for independently owned products.",
              "de": "Ein Multi-Repo-Modell trennt Berechtigungen und Release-Lebenszyklen für unabhängig verantwortete Produkte."
          },
          "hint": {
              "en": "The key requirement is independence.",
              "de": "Die Schlüsselanforderung ist Unabhängigkeit."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/repos/git/git-branching-guidance?view=azure-devops",
          "id": "az400-231"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "hard",
          "scenario": {
              "en": "An application repository must consume a shared library repository at a fixed tested commit and update it intentionally.",
              "de": "Ein Anwendungs-Repository muss ein gemeinsames Bibliotheks-Repository an einem festen getesteten Commit verwenden und gezielt aktualisieren."
          },
          "question": {
              "en": "Which Git feature is most appropriate?",
              "de": "Welche Git-Funktion ist am geeignetsten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Submodule",
                      "de": "Submodul"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Annotated tag",
                      "de": "Annotierter Tag"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Protected branch",
                      "de": "Geschützter Branch"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Draft pull request",
                      "de": "Draft Pull Request"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A submodule records an exact commit of another repository and supports deliberate updates.",
              "de": "Ein Submodul speichert einen exakten Commit eines anderen Repositorys und unterstützt gezielte Updates."
          },
          "hint": {
              "en": "The dependency must stay pinned to a known commit.",
              "de": "Die Abhängigkeit muss auf einen bekannten Commit festgelegt bleiben."
          },
          "reference": "https://git-scm.com/book/en/v2/Git-Tools-Submodules",
          "id": "az400-232"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A huge monorepo slows developers who only work in one service folder.",
              "de": "Ein sehr großes Monorepo verlangsamt Entwickler, die nur an einem Service-Ordner arbeiten."
          },
          "question": {
              "en": "Which Git capability helps them check out only the relevant paths?",
              "de": "Welche Git-Funktion hilft ihnen, nur die relevanten Pfade auszuchecken?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Sparse checkout",
                      "de": "Sparse Checkout"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "GitFlow",
                      "de": "GitFlow"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Cherry-pick",
                      "de": "Cherry-Pick"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Release tag",
                      "de": "Release-Tag"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Sparse checkout limits the working tree to selected directories in a large repository.",
              "de": "Sparse Checkout beschränkt den Arbeitsbaum in einem großen Repository auf ausgewählte Verzeichnisse."
          },
          "hint": {
              "en": "The goal is a smaller working tree.",
              "de": "Das Ziel ist ein kleinerer Arbeitsbaum."
          },
          "reference": "https://git-scm.com/docs/git-sparse-checkout",
          "id": "az400-233"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Developers propose using local Git hooks to enforce reviews and build checks before main changes are accepted.",
              "de": "Entwickler schlagen vor, lokale Git-Hooks zu verwenden, um Reviews und Build-Prüfungen zu erzwingen, bevor Änderungen an main akzeptiert werden."
          },
          "question": {
              "en": "What is the better centralized control?",
              "de": "Was ist die bessere zentralisierte Kontrolle?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Branch policies or protected branch rules",
                      "de": "Branchrichtlinien oder geschützte Branch-Regeln"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Client-side hooks on every laptop",
                      "de": "Clientseitige Hooks auf jedem Laptop"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Manual reminders in chat",
                      "de": "Manuelle Erinnerungen im Chat"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Local aliases",
                      "de": "Lokale Aliasse"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Central branch protection is enforceable for everyone, unlike local hooks that users can skip or misconfigure.",
              "de": "Zentraler Branch-Schutz ist für alle erzwingbar, im Gegensatz zu lokalen Hooks, die Benutzer überspringen oder falsch konfigurieren können."
          },
          "hint": {
              "en": "Pick the control enforced on the server side.",
              "de": "Wählen Sie die Kontrolle, die serverseitig erzwungen wird."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/repos/git/branch-policies?view=azure-devops",
          "id": "az400-234"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A faulty commit was already pushed to main, and the team wants to undo it without rewriting shared history.",
              "de": "Ein fehlerhafter Commit wurde bereits auf main gepusht, und das Team möchte ihn rückgängig machen, ohne die gemeinsame Historie umzuschreiben."
          },
          "question": {
              "en": "Which command should you use?",
              "de": "Welchen Befehl sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "git revert",
                      "de": "git revert"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "git reset --hard and force push",
                      "de": "git reset --hard und Force Push"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Delete the repository",
                      "de": "Das Repository löschen"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "git clean -fd",
                      "de": "git clean -fd"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "git revert creates a new commit that reverses the bad change while preserving history.",
              "de": "git revert erstellt einen neuen Commit, der die fehlerhafte Änderung rückgängig macht und dabei die Historie bewahrt."
          },
          "hint": {
              "en": "The requirement forbids rewriting shared history.",
              "de": "Die Anforderung verbietet das Umschreiben gemeinsamer Historie."
          },
          "reference": "https://git-scm.com/docs/git-revert",
          "id": "az400-235"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "easy",
          "scenario": null,
          "question": {
              "en": "What is the best Git mechanism for marking immutable release points such as v2.4.0?",
              "de": "Was ist der beste Git-Mechanismus, um unveränderliche Release-Punkte wie v2.4.0 zu markieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Annotated tags",
                      "de": "Annotierte Tags"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Stashes",
                      "de": "Stashes"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Worktrees",
                      "de": "Worktrees"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Sparse checkout",
                      "de": "Sparse Checkout"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Annotated tags label specific commits as release versions and carry metadata.",
              "de": "Annotierte Tags kennzeichnen bestimmte Commits als Release-Versionen und tragen Metadaten."
          },
          "hint": {
              "en": "This is about immutable version labels.",
              "de": "Dies betrifft unveränderliche Versionsmarkierungen."
          },
          "reference": "https://git-scm.com/book/en/v2/Git-Basics-Tagging",
          "id": "az400-236"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "easy",
          "scenario": {
              "en": "A contributor wants feedback early, but the pull request is not yet ready to merge.",
              "de": "Ein Mitwirkender möchte früh Feedback erhalten, aber der Pull Request ist noch nicht bereit für den Merge."
          },
          "question": {
              "en": "Which pull request state should be used?",
              "de": "Welcher Pull-Request-Status sollte verwendet werden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Draft pull request",
                      "de": "Draft Pull Request"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Closed pull request",
                      "de": "Geschlossener Pull Request"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Merged pull request",
                      "de": "Gemergter Pull Request"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Deleted branch",
                      "de": "Gelöschter Branch"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A draft pull request invites review discussion without signaling merge readiness.",
              "de": "Ein Draft Pull Request ermöglicht Review-Diskussionen, ohne Merge-Bereitschaft zu signalisieren."
          },
          "hint": {
              "en": "The team wants feedback before final readiness.",
              "de": "Das Team möchte Feedback vor der endgültigen Bereitschaft."
          },
          "reference": "https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests",
          "id": "az400-237"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "easy",
          "scenario": {
              "en": "A team wants formatting and lint checks to run automatically before a developer creates a local commit.",
              "de": "Ein Team möchte, dass Formatierungs- und Lint-Prüfungen automatisch laufen, bevor ein Entwickler lokal einen Commit erstellt."
          },
          "question": {
              "en": "Which Git mechanism fits this local workflow requirement?",
              "de": "Welcher Git-Mechanismus passt zu dieser lokalen Workflow-Anforderung?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Pre-commit hook",
                      "de": "Pre-Commit-Hook"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Protected branch",
                      "de": "Geschützter Branch"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Delivery Plan",
                      "de": "Delivery Plan"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Service connection",
                      "de": "Serviceverbindung"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A pre-commit hook runs locally before the commit is created and is useful for developer convenience checks.",
              "de": "Ein Pre-Commit-Hook läuft lokal, bevor der Commit erstellt wird, und eignet sich für komfortable Entwicklerprüfungen."
          },
          "hint": {
              "en": "This question is about local automation on the workstation.",
              "de": "Diese Frage betrifft lokale Automatisierung auf der Workstation."
          },
          "reference": "https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks",
          "id": "az400-238"
      },
      {
          "type": "multiple",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A repository needs path-based ownership and mandatory review enforcement before merge.",
              "de": "Ein Repository benötigt pfadbasierte Verantwortlichkeit und die verpflichtende Erzwingung von Reviews vor dem Merge."
          },
          "question": {
              "en": "Which two features should you combine?",
              "de": "Welche zwei Funktionen sollten Sie kombinieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "CODEOWNERS",
                      "de": "CODEOWNERS"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Protected branch required reviews",
                      "de": "Geschützte Branch-Regeln mit verpflichtenden Reviews"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Stash",
                      "de": "Stash"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Git notes",
                      "de": "Git Notes"
                  }
              }
          ],
          "correct": [
              "A",
              "B"
          ],
          "explanation": {
              "en": "CODEOWNERS selects the right reviewers, and protected branch review requirements enforce that the review happens before merge.",
              "de": "CODEOWNERS wählt die richtigen Reviewer aus, und verpflichtende Reviews auf geschützten Branches erzwingen, dass das Review vor dem Merge stattfindet."
          },
          "hint": {
              "en": "One feature assigns ownership and the other enforces approval.",
              "de": "Eine Funktion weist Verantwortlichkeit zu, die andere erzwingt Freigabe."
          },
          "reference": "https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners",
          "id": "az400-239"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "hard",
          "scenario": {
              "en": "A mobile app has release hardening periods and occasional hotfixes while new feature work continues.",
              "de": "Eine mobile App hat Release-Stabilisierungsphasen und gelegentliche Hotfixes, während neue Features weiterentwickelt werden."
          },
          "question": {
              "en": "Which branching strategy is the best fit?",
              "de": "Welche Branching-Strategie passt am besten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "GitFlow",
                      "de": "GitFlow"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Trunk-based only",
                      "de": "Nur Trunk-Based"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "No branches",
                      "de": "Keine Branches"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Tags only",
                      "de": "Nur Tags"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "GitFlow supports dedicated release and hotfix branches while feature work continues on separate lines.",
              "de": "GitFlow unterstützt dedizierte Release- und Hotfix-Branches, während Feature-Arbeit auf getrennten Linien weiterläuft."
          },
          "hint": {
              "en": "Choose the model designed for formal release hardening.",
              "de": "Wählen Sie das Modell, das für formale Release-Stabilisierung entwickelt wurde."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/repos/git/git-branching-guidance?view=azure-devops",
          "id": "az400-240"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Source Control",
              "de": "Quellcodeverwaltung entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": null,
          "question": {
              "en": "Which integration method reapplies feature branch commits onto the latest target branch to keep a linear history before merge?",
              "de": "Welche Integrationsmethode wendet Feature-Branch-Commits erneut auf den neuesten Ziel-Branch an, um vor dem Merge eine lineare Historie zu behalten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Rebase",
                      "de": "Rebase"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Cherry-pick tag",
                      "de": "Tag cherry-picken"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Force push only",
                      "de": "Nur Force Push"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Delete and recreate",
                      "de": "Löschen und neu erstellen"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Rebase reapplies commits on top of the target branch tip and avoids an extra merge commit in the feature branch history.",
              "de": "Rebase wendet Commits erneut auf der Spitze des Ziel-Branches an und vermeidet einen zusätzlichen Merge Commit in der Historie des Feature-Branches."
          },
          "hint": {
              "en": "The goal is a linear sequence of commits.",
              "de": "Das Ziel ist eine lineare Abfolge von Commits."
          },
          "reference": "https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/incorporating-changes-from-a-pull-request/about-merge-methods-on-github",
          "id": "az400-241"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A team wants one YAML definition that builds, tests, and then deploys through dev, test, and production stages.",
              "de": "Ein Team möchte eine YAML-Definition, die baut, testet und dann über die Stufen dev, test und production bereitstellt."
          },
          "question": {
              "en": "Which pipeline model should you use in Azure DevOps?",
              "de": "Welches Pipeline-Modell sollten Sie in Azure DevOps verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Multi-stage YAML pipeline",
                      "de": "Mehrstufige YAML-Pipeline"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A wiki page",
                      "de": "Eine Wiki-Seite"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A local batch file",
                      "de": "Eine lokale Batch-Datei"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Manual ZIP copy",
                      "de": "Manuelles ZIP-Kopieren"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A multi-stage YAML pipeline defines build, test, and deploy stages as one versioned workflow.",
              "de": "Eine mehrstufige YAML-Pipeline definiert Build-, Test- und Deploy-Stufen als einen versionierten Workflow."
          },
          "hint": {
              "en": "The requirement spans multiple delivery stages in code.",
              "de": "Die Anforderung umfasst mehrere Delivery-Stufen als Code."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/process/stages?view=azure-devops",
          "id": "az400-242"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Thirty services use nearly identical build logic and the platform team wants one place to maintain it.",
              "de": "Dreißig Services verwenden nahezu identische Build-Logik, und das Platform-Team möchte sie an einer Stelle pflegen."
          },
          "question": {
              "en": "What should you use in Azure Pipelines?",
              "de": "Was sollten Sie in Azure Pipelines verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "YAML templates",
                      "de": "YAML-Templates"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Separate copy-pasted pipelines",
                      "de": "Separat kopierte Pipelines"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Manual release notes",
                      "de": "Manuelle Release Notes"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Deployment groups",
                      "de": "Bereitstellungsgruppen"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "YAML templates centralize reusable pipeline logic and reduce duplication across repositories.",
              "de": "YAML-Templates zentralisieren wiederverwendbare Pipeline-Logik und reduzieren Duplikate über Repositorys hinweg."
          },
          "hint": {
              "en": "Choose the option for reusable pipeline code.",
              "de": "Wählen Sie die Option für wiederverwendbaren Pipeline-Code."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/process/templates?view=azure-devops",
          "id": "az400-243"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "The same pipeline should deploy to dev, test, and prod with different environment-specific values such as URLs and non-secret settings.",
              "de": "Dieselbe Pipeline soll nach dev, test und prod mit unterschiedlichen umgebungsspezifischen Werten wie URLs und nicht geheimen Einstellungen bereitstellen."
          },
          "question": {
              "en": "Which Azure Pipelines feature is most appropriate?",
              "de": "Welche Azure-Pipelines-Funktion ist am geeignetsten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Variable groups",
                      "de": "Variablengruppen"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Git tags",
                      "de": "Git-Tags"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Draft PRs",
                      "de": "Draft PRs"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Stashes",
                      "de": "Stashes"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Variable groups store shared values per environment and keep YAML cleaner.",
              "de": "Variablengruppen speichern gemeinsame Werte pro Umgebung und halten YAML übersichtlicher."
          },
          "hint": {
              "en": "This is about environment-specific configuration reuse.",
              "de": "Dies betrifft die Wiederverwendung umgebungsspezifischer Konfiguration."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/library/variable-groups?view=azure-devops",
          "id": "az400-244"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "hard",
          "scenario": {
              "en": "Auditors require a recorded approval before any production deployment starts in Azure DevOps.",
              "de": "Auditoren verlangen eine protokollierte Genehmigung, bevor eine Produktionsbereitstellung in Azure DevOps startet."
          },
          "question": {
              "en": "What should you configure?",
              "de": "Was sollten Sie konfigurieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Approvals and checks on the production environment",
                      "de": "Genehmigungen und Prüfungen auf der Produktionsumgebung"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A README file",
                      "de": "Eine README-Datei"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A local Git hook",
                      "de": "Einen lokalen Git-Hook"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "More backlog tags",
                      "de": "Mehr Backlog-Tags"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Environment approvals and checks gate production deployment and create an audit trail.",
              "de": "Umgebungs-Genehmigungen und Prüfungen blockieren Produktionsbereitstellungen und erzeugen einen Audit-Trail."
          },
          "hint": {
              "en": "The requirement is governed deployment approval.",
              "de": "Die Anforderung ist eine gesteuerte Bereitstellungsgenehmigung."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/process/approvals?view=azure-devops",
          "id": "az400-245"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "You need the deploy stage to use exactly the same build output that passed tests earlier in the pipeline.",
              "de": "Die Deploy-Stufe soll genau denselben Build-Output verwenden, der zuvor in der Pipeline die Tests bestanden hat."
          },
          "question": {
              "en": "What should you publish and consume?",
              "de": "Was sollten Sie veröffentlichen und verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Pipeline artifacts",
                      "de": "Pipeline-Artefakte"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Random local folders",
                      "de": "Zufällige lokale Ordner"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A wiki attachment",
                      "de": "Einen Wiki-Anhang"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A force push",
                      "de": "Einen Force Push"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Pipeline artifacts preserve the tested output and let later stages deploy the same package.",
              "de": "Pipeline-Artefakte bewahren den getesteten Output und lassen spätere Stufen genau dasselbe Paket bereitstellen."
          },
          "hint": {
              "en": "The key is reusing the tested build output.",
              "de": "Entscheidend ist die Wiederverwendung des getesteten Build-Outputs."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/artifacts/pipeline-artifacts?view=azure-devops",
          "id": "az400-246"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A GitHub Actions workflow in a monorepo should run only when files under services/payments change.",
              "de": "Ein GitHub-Actions-Workflow in einem Monorepo soll nur laufen, wenn sich Dateien unter services/payments ändern."
          },
          "question": {
              "en": "What should you configure?",
              "de": "Was sollten Sie konfigurieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Path filters",
                      "de": "Pfadfilter"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Draft pull requests",
                      "de": "Draft Pull Requests"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Branch tags only",
                      "de": "Nur Branch-Tags"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Code owners comments",
                      "de": "Codeowner-Kommentare"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Path filters limit workflow execution to changes under specified directories.",
              "de": "Pfadfilter beschränken die Workflow-Ausführung auf Änderungen unter angegebenen Verzeichnissen."
          },
          "hint": {
              "en": "The trigger should depend on changed paths.",
              "de": "Der Trigger soll von geänderten Pfaden abhängen."
          },
          "reference": "https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions",
          "id": "az400-247"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "easy",
          "scenario": {
              "en": "You must test a library on Ubuntu, Windows, and macOS with several language versions in GitHub Actions.",
              "de": "Sie müssen eine Bibliothek unter Ubuntu, Windows und macOS mit mehreren Sprachversionen in GitHub Actions testen."
          },
          "question": {
              "en": "Which workflow feature should you use?",
              "de": "Welche Workflow-Funktion sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Matrix strategy",
                      "de": "Matrix-Strategie"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Protected branches",
                      "de": "Geschützte Branches"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Service hooks",
                      "de": "Service Hooks"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Delivery Plans",
                      "de": "Delivery Plans"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A matrix strategy expands one job definition across operating systems or version combinations.",
              "de": "Eine Matrix-Strategie erweitert eine Job-Definition über Betriebssysteme oder Versionskombinationen hinweg."
          },
          "hint": {
              "en": "The same job must run in many combinations.",
              "de": "Derselbe Job muss in vielen Kombinationen laufen."
          },
          "reference": "https://docs.github.com/en/actions/using-jobs/using-a-matrix-for-your-jobs",
          "id": "az400-248"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Build agents must access private network resources that GitHub-hosted runners cannot reach.",
              "de": "Build-Agenten müssen auf private Netzwerkressourcen zugreifen, die GitHub-hosted Runner nicht erreichen können."
          },
          "question": {
              "en": "What should you use?",
              "de": "Was sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Self-hosted runners",
                      "de": "Self-hosted Runner"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "GitHub Pages",
                      "de": "GitHub Pages"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Issue forms",
                      "de": "Issue-Formulare"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Release discussions",
                      "de": "Release-Diskussionen"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Self-hosted runners run inside your network and can reach internal dependencies securely.",
              "de": "Self-hosted Runner laufen innerhalb Ihres Netzwerks und können interne Abhängigkeiten sicher erreichen."
          },
          "hint": {
              "en": "The runner must live where the private resources are.",
              "de": "Der Runner muss dort laufen, wo sich die privaten Ressourcen befinden."
          },
          "reference": "https://docs.github.com/en/actions/hosting-your-own-runners/about-self-hosted-runners",
          "id": "az400-249"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "An Azure DevOps pipeline must authenticate to an Azure subscription to deploy infrastructure.",
              "de": "Eine Azure-DevOps-Pipeline muss sich gegenüber einem Azure-Abonnement authentifizieren, um Infrastruktur bereitzustellen."
          },
          "question": {
              "en": "Which object should the pipeline use?",
              "de": "Welches Objekt sollte die Pipeline verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Service connection",
                      "de": "Serviceverbindung"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Area path",
                      "de": "Area Path"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Draft pull request",
                      "de": "Draft Pull Request"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Delivery plan",
                      "de": "Delivery Plan"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A service connection stores the authenticated connection that Azure Pipelines tasks use for deployment.",
              "de": "Eine Serviceverbindung speichert die authentifizierte Verbindung, die Azure-Pipelines-Tasks für Bereitstellungen verwenden."
          },
          "hint": {
              "en": "The requirement is pipeline-to-Azure authentication.",
              "de": "Die Anforderung ist Pipeline-zu-Azure-Authentifizierung."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/library/service-endpoints?view=azure-devops",
          "id": "az400-250"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "hard",
          "scenario": {
              "en": "An application runs on a set of VMs and must be updated in small batches while health is checked between batches.",
              "de": "Eine Anwendung läuft auf einer Gruppe von VMs und muss in kleinen Batches aktualisiert werden, während zwischen den Batches die Gesundheit geprüft wird."
          },
          "question": {
              "en": "Which deployment strategy best fits?",
              "de": "Welche Bereitstellungsstrategie passt am besten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Rolling deployment",
                      "de": "Rolling Deployment"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Big bang deployment",
                      "de": "Big-Bang-Bereitstellung"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Direct database edit",
                      "de": "Direkte Datenbankänderung"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Stash pop",
                      "de": "Stash pop"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A rolling strategy updates targets incrementally and limits blast radius during VM deployments.",
              "de": "Eine Rolling-Strategie aktualisiert Ziele schrittweise und begrenzt den Blast Radius bei VM-Bereitstellungen."
          },
          "hint": {
              "en": "Choose the batch-based rollout model.",
              "de": "Wählen Sie das batchbasierte Rollout-Modell."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/process/deployment-jobs?view=azure-devops",
          "id": "az400-251"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "hard",
          "scenario": {
              "en": "A new AKS release should go first to a small percentage of users while telemetry is monitored.",
              "de": "Ein neues AKS-Release soll zuerst an einen kleinen Prozentsatz von Benutzern gehen, während Telemetrie überwacht wird."
          },
          "question": {
              "en": "Which deployment strategy is most appropriate?",
              "de": "Welche Bereitstellungsstrategie ist am geeignetsten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Canary deployment",
                      "de": "Canary-Deployment"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Big bang deployment",
                      "de": "Big-Bang-Bereitstellung"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Manual FTP copy",
                      "de": "Manueller FTP-Kopiervorgang"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Force push",
                      "de": "Force Push"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Canary deployment exposes the new version gradually to reduce risk and observe real traffic health.",
              "de": "Ein Canary-Deployment stellt die neue Version schrittweise bereit, um Risiko zu reduzieren und die Gesundheit unter realem Traffic zu beobachten."
          },
          "hint": {
              "en": "The rollout starts with only a small cohort.",
              "de": "Der Rollout beginnt nur mit einer kleinen Benutzergruppe."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/process/deployment-jobs?view=azure-devops",
          "id": "az400-252"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "hard",
          "scenario": {
              "en": "Operations needs instant traffic cutover between old and new environments and a fast rollback path.",
              "de": "Der Betrieb benötigt einen sofortigen Traffic-Umschaltpunkt zwischen alter und neuer Umgebung sowie einen schnellen Rollback-Pfad."
          },
          "question": {
              "en": "Which strategy is the best fit?",
              "de": "Welche Strategie passt am besten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Blue-green deployment",
                      "de": "Blue-Green-Deployment"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Rolling deployment",
                      "de": "Rolling Deployment"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Single-environment overwrite",
                      "de": "Überschreiben einer Einzelumgebung"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Manual copy",
                      "de": "Manuelles Kopieren"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Blue-green deployment maintains two complete environments and switches traffic between them.",
              "de": "Blue-Green-Deployment hält zwei vollständige Umgebungen bereit und schaltet den Traffic zwischen ihnen um."
          },
          "hint": {
              "en": "Think about instant switch and quick rollback.",
              "de": "Denken Sie an sofortiges Umschalten und schnelles Rollback."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/process/deployment-jobs?view=azure-devops",
          "id": "az400-253"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A team deploys containerized workloads to AKS and needs versioned charts plus environment-specific values files.",
              "de": "Ein Team stellt containerisierte Workloads nach AKS bereit und benötigt versionierte Charts sowie umgebungsspezifische Values-Dateien."
          },
          "question": {
              "en": "What should it use?",
              "de": "Was sollte es verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Helm charts",
                      "de": "Helm-Charts"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A ZIP of kubectl output",
                      "de": "Eine ZIP mit kubectl-Ausgabe"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Git notes",
                      "de": "Git Notes"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Excel macros",
                      "de": "Excel-Makros"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Helm packages Kubernetes manifests and supports per-environment values during deployment.",
              "de": "Helm paketiert Kubernetes-Manifeste und unterstützt umgebungsspezifische Werte während der Bereitstellung."
          },
          "hint": {
              "en": "The solution needs parameterized Kubernetes packaging.",
              "de": "Die Lösung benötigt parametrisierte Kubernetes-Paketierung."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/aks/kubernetes-helm",
          "id": "az400-254"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "easy",
          "scenario": null,
          "question": {
              "en": "Which Azure service is designed to store and version container images for CI/CD pipelines?",
              "de": "Welcher Azure-Dienst ist dafür ausgelegt, Container-Images für CI/CD-Pipelines zu speichern und zu versionieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Azure Container Registry",
                      "de": "Azure Container Registry"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Azure Boards",
                      "de": "Azure Boards"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Azure Key Vault",
                      "de": "Azure Key Vault"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Azure Policy",
                      "de": "Azure Policy"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Azure Container Registry is the managed registry for storing and distributing container images.",
              "de": "Azure Container Registry ist die verwaltete Registry zum Speichern und Verteilen von Container-Images."
          },
          "hint": {
              "en": "Look for the container image registry service.",
              "de": "Suchen Sie nach dem Dienst für Container-Image-Registries."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/container-registry/container-registry-get-started-portal",
          "id": "az400-255"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A deployment pipeline must use the application repository and a separate repository that contains shared templates.",
              "de": "Eine Bereitstellungspipeline muss das Anwendungs-Repository und ein separates Repository mit gemeinsamen Templates verwenden."
          },
          "question": {
              "en": "Which Azure Pipelines feature should you use?",
              "de": "Welche Azure-Pipelines-Funktion sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Multi-repo checkout",
                      "de": "Multi-Repo-Checkout"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Draft pull request",
                      "de": "Draft Pull Request"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Protected tags",
                      "de": "Geschützte Tags"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Delivery Plans",
                      "de": "Delivery Plans"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Multi-repo checkout brings multiple repositories into one pipeline workspace.",
              "de": "Multi-Repo-Checkout bringt mehrere Repositorys in einen Pipeline-Arbeitsbereich."
          },
          "hint": {
              "en": "The job needs files from more than one repository.",
              "de": "Der Job benötigt Dateien aus mehr als einem Repository."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/repos/multi-repo-checkout?view=azure-devops",
          "id": "az400-256"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "hard",
          "scenario": {
              "en": "A consumer pipeline should start automatically when an upstream library pipeline finishes successfully and publishes an artifact.",
              "de": "Eine Consumer-Pipeline soll automatisch starten, wenn eine Upstream-Bibliothekspipeline erfolgreich endet und ein Artefakt veröffentlicht."
          },
          "question": {
              "en": "What should you configure in Azure Pipelines?",
              "de": "Was sollten Sie in Azure Pipelines konfigurieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "A pipeline resource with a completion trigger",
                      "de": "Eine Pipeline-Ressource mit Completion-Trigger"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A work item tag",
                      "de": "Ein Work-Item-Tag"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A wiki page",
                      "de": "Eine Wiki-Seite"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A stash",
                      "de": "Einen Stash"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Pipeline resources model upstream pipelines and can trigger downstream runs after successful completion.",
              "de": "Pipeline-Ressourcen modellieren Upstream-Pipelines und können Downstream-Läufe nach erfolgreichem Abschluss auslösen."
          },
          "hint": {
              "en": "This requirement links one pipeline to another.",
              "de": "Diese Anforderung verknüpft eine Pipeline mit einer anderen."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/process/resources?view=azure-devops",
          "id": "az400-257"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Dependency restoration takes most of the build time, and the lock file changes rarely.",
              "de": "Die Wiederherstellung von Abhängigkeiten dauert den Großteil der Build-Zeit, und die Lock-Datei ändert sich selten."
          },
          "question": {
              "en": "Which feature should you add to the pipeline?",
              "de": "Welche Funktion sollten Sie der Pipeline hinzufügen?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Dependency caching",
                      "de": "Abhängigkeits-Caching"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Branch deletion",
                      "de": "Branch-Löschung"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Manual approvals",
                      "de": "Manuelle Genehmigungen"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Portfolio backlogs",
                      "de": "Portfolio-Backlogs"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Caching reuses previously downloaded dependencies and speeds repeated builds when the cache key is stable.",
              "de": "Caching verwendet zuvor heruntergeladene Abhängigkeiten wieder und beschleunigt wiederholte Builds, wenn der Cache-Schlüssel stabil ist."
          },
          "hint": {
              "en": "The target is faster builds, not different governance.",
              "de": "Das Ziel sind schnellere Builds, nicht andere Governance."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/release/caching?view=azure-devops",
          "id": "az400-258"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A mobile signing certificate must be used during the pipeline but should not live in the repository.",
              "de": "Ein mobiles Signaturzertifikat muss in der Pipeline verwendet werden, soll aber nicht im Repository liegen."
          },
          "question": {
              "en": "Which Azure DevOps library feature should you use?",
              "de": "Welche Azure-DevOps-Library-Funktion sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Secure files",
                      "de": "Secure Files"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Area paths",
                      "de": "Area Paths"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Service hooks",
                      "de": "Service Hooks"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Delivery plans",
                      "de": "Delivery Plans"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Secure files store sensitive build files such as certificates for controlled pipeline use.",
              "de": "Secure Files speichern sensible Build-Dateien wie Zertifikate für die kontrollierte Nutzung in Pipelines."
          },
          "hint": {
              "en": "The item is a sensitive file, not a text secret.",
              "de": "Es handelt sich um eine sensible Datei, nicht um ein Text-Secret."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/library/secure-files?view=azure-devops",
          "id": "az400-259"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "easy",
          "scenario": null,
          "question": {
              "en": "Which Azure Pipelines feature lets a user choose values such as target region when manually starting a run?",
              "de": "Welche Azure-Pipelines-Funktion erlaubt es einem Benutzer, Werte wie Zielregion beim manuellen Start auszuwählen?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Runtime parameters",
                      "de": "Runtime-Parameter"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Git tags",
                      "de": "Git-Tags"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Agent capabilities",
                      "de": "Agent-Fähigkeiten"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Release annotations",
                      "de": "Release-Anmerkungen"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Runtime parameters expose controlled input values when the pipeline is queued.",
              "de": "Runtime-Parameter stellen kontrollierte Eingabewerte bereit, wenn die Pipeline in die Warteschlange gestellt wird."
          },
          "hint": {
              "en": "The choice is made at queue time.",
              "de": "Die Auswahl wird beim Start der Pipeline getroffen."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/process/runtime-parameters?view=azure-devops",
          "id": "az400-260"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Pull request builds should compile and test code but must never deploy to any environment.",
              "de": "Pull-Request-Builds sollen den Code kompilieren und testen, dürfen aber niemals in eine Umgebung bereitstellen."
          },
          "question": {
              "en": "What should you configure on the deployment stage?",
              "de": "Was sollten Sie auf der Deploy-Stufe konfigurieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "A condition that excludes PR runs",
                      "de": "Eine Bedingung, die PR-Läufe ausschließt"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "More branches",
                      "de": "Mehr Branches"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "An extra README",
                      "de": "Eine zusätzliche README"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A tag on the repo",
                      "de": "Ein Tag auf dem Repository"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A stage condition can prevent deployment when the pipeline reason is a pull request.",
              "de": "Eine Stage-Bedingung kann die Bereitstellung verhindern, wenn der Pipeline-Grund ein Pull Request ist."
          },
          "hint": {
              "en": "The solution is stage execution logic.",
              "de": "Die Lösung liegt in der Stage-Ausführungslogik."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/process/conditions?view=azure-devops",
          "id": "az400-261"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "An Azure Repos PR to main must trigger a validation pipeline automatically before completion.",
              "de": "Ein Azure-Repos-PR nach main muss vor dem Abschluss automatisch eine Validierungspipeline auslösen."
          },
          "question": {
              "en": "What should you configure?",
              "de": "Was sollten Sie konfigurieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Build validation in branch policies",
                      "de": "Buildvalidierung in Branchrichtlinien"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A local post-commit hook",
                      "de": "Einen lokalen Post-Commit-Hook"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A wiki approval",
                      "de": "Eine Wiki-Genehmigung"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A manual checklist only",
                      "de": "Nur eine manuelle Checkliste"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Build validation in branch policies makes PR completion depend on the validation pipeline.",
              "de": "Buildvalidierung in Branchrichtlinien macht den Abschluss des PR von der Validierungspipeline abhängig."
          },
          "hint": {
              "en": "The pipeline must be part of merge governance.",
              "de": "Die Pipeline muss Teil der Merge-Governance sein."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/repos/git/branch-policies?view=azure-devops",
          "id": "az400-262"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Many repositories use the same GitHub Actions deployment logic and the platform team wants callers to pass only a few inputs.",
              "de": "Viele Repositorys verwenden dieselbe GitHub-Actions-Deploy-Logik, und das Platform-Team möchte, dass Aufrufer nur wenige Eingaben übergeben."
          },
          "question": {
              "en": "Which feature should the platform team create?",
              "de": "Welche Funktion sollte das Platform-Team erstellen?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "A reusable workflow",
                      "de": "Einen wiederverwendbaren Workflow"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A project board",
                      "de": "Ein Projekt-Board"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A CODEOWNERS file",
                      "de": "Eine CODEOWNERS-Datei"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A stash alias",
                      "de": "Ein Stash-Alias"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Reusable workflows centralize multi-job workflow logic and accept inputs from calling workflows.",
              "de": "Wiederverwendbare Workflows zentralisieren mehrstufige Workflow-Logik und akzeptieren Eingaben von aufrufenden Workflows."
          },
          "hint": {
              "en": "The reuse is across repositories and workflow files.",
              "de": "Die Wiederverwendung erfolgt über Repositorys und Workflow-Dateien hinweg."
          },
          "reference": "https://docs.github.com/en/actions/using-workflows/reusing-workflows",
          "id": "az400-263"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Within one GitHub Actions job, several repositories repeat the same short sequence of shell steps.",
              "de": "Innerhalb eines GitHub-Actions-Jobs wiederholen mehrere Repositorys dieselbe kurze Folge von Shell-Schritten."
          },
          "question": {
              "en": "What is the lightest reusable option?",
              "de": "Was ist die leichteste wiederverwendbare Option?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "A composite action",
                      "de": "Eine Composite Action"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A protected branch",
                      "de": "Ein geschützter Branch"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A deployment slot",
                      "de": "Ein Deployment Slot"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A work item template",
                      "de": "Ein Work-Item-Template"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Composite actions package repeated step sequences for reuse inside jobs.",
              "de": "Composite Actions paketieren wiederholte Schrittfolgen zur Wiederverwendung innerhalb von Jobs."
          },
          "hint": {
              "en": "This is step reuse, not full workflow reuse.",
              "de": "Dies betrifft die Wiederverwendung von Schritten, nicht eines vollständigen Workflows."
          },
          "reference": "https://docs.github.com/en/actions/creating-actions/creating-a-composite-action",
          "id": "az400-264"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "easy",
          "scenario": {
              "en": "Pull requests in GitHub must not merge until the CI workflow reports success.",
              "de": "Pull Requests in GitHub dürfen nicht gemergt werden, bevor der CI-Workflow Erfolg meldet."
          },
          "question": {
              "en": "What should you configure on the branch?",
              "de": "Was sollten Sie auf dem Branch konfigurieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Required status checks",
                      "de": "Verpflichtende Status Checks"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Issue labels",
                      "de": "Issue-Labels"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Pages build",
                      "de": "Pages-Build"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Milestones",
                      "de": "Meilensteine"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Required status checks force selected checks to pass before merge is allowed.",
              "de": "Verpflichtende Status Checks erzwingen, dass ausgewählte Prüfungen erfolgreich sind, bevor ein Merge erlaubt ist."
          },
          "hint": {
              "en": "The branch should wait on CI results.",
              "de": "Der Branch soll auf CI-Ergebnisse warten."
          },
          "reference": "https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/about-protected-branches",
          "id": "az400-265"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Only the production deployment job should see production credentials in GitHub Actions.",
              "de": "Nur der Produktions-Deploy-Job soll Produktionszugangsdaten in GitHub Actions sehen."
          },
          "question": {
              "en": "What should you use?",
              "de": "Was sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Environment secrets",
                      "de": "Environment-Secrets"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Repository labels",
                      "de": "Repository-Labels"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Draft pull requests",
                      "de": "Draft Pull Requests"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "CODEOWNERS only",
                      "de": "Nur CODEOWNERS"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Environment secrets scope sensitive values to jobs that target a specific environment.",
              "de": "Environment-Secrets begrenzen sensible Werte auf Jobs, die eine bestimmte Umgebung ansprechen."
          },
          "hint": {
              "en": "The secret scope should match the deployment environment.",
              "de": "Der Secret-Umfang sollte zur Bereitstellungsumgebung passen."
          },
          "reference": "https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment",
          "id": "az400-266"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Two workflow runs sometimes try to deploy to production at the same time.",
              "de": "Zwei Workflow-Läufe versuchen manchmal gleichzeitig, nach production bereitzustellen."
          },
          "question": {
              "en": "Which GitHub Actions feature helps serialize them?",
              "de": "Welche GitHub-Actions-Funktion hilft, sie zu serialisieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Concurrency groups",
                      "de": "Concurrency-Gruppen"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Issue forms",
                      "de": "Issue-Formulare"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Codespaces",
                      "de": "Codespaces"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Discussions",
                      "de": "Discussions"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Concurrency groups limit overlapping runs that share the same concurrency key.",
              "de": "Concurrency-Gruppen begrenzen überlappende Läufe, die denselben Concurrency-Schlüssel teilen."
          },
          "hint": {
              "en": "The problem is overlapping deployments.",
              "de": "Das Problem sind überlappende Bereitstellungen."
          },
          "reference": "https://docs.github.com/en/actions/using-jobs/using-concurrency",
          "id": "az400-267"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A GitHub Actions production deployment must pause until an authorized approver reviews it.",
              "de": "Eine Produktionsbereitstellung in GitHub Actions muss pausieren, bis ein autorisierter Genehmiger sie prüft."
          },
          "question": {
              "en": "What should you configure?",
              "de": "Was sollten Sie konfigurieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "An environment with required reviewers",
                      "de": "Eine Umgebung mit verpflichtenden Reviewern"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A project board field",
                      "de": "Ein Projektboard-Feld"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A branch rename",
                      "de": "Eine Branch-Umbenennung"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A local pre-push hook",
                      "de": "Einen lokalen Pre-Push-Hook"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "GitHub environments can require reviewers before deployment jobs proceed.",
              "de": "GitHub-Umgebungen können Reviewer verlangen, bevor Deploy-Jobs fortgesetzt werden."
          },
          "hint": {
              "en": "The gate is on deployment to an environment.",
              "de": "Das Gate liegt auf der Bereitstellung in eine Umgebung."
          },
          "reference": "https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment",
          "id": "az400-268"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Builds break because different agents have different installed tool versions.",
              "de": "Builds schlagen fehl, weil verschiedene Agenten unterschiedliche installierte Tool-Versionen haben."
          },
          "question": {
              "en": "Which Azure Pipelines approach helps standardize the build environment?",
              "de": "Welcher Azure-Pipelines-Ansatz hilft, die Build-Umgebung zu standardisieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Container jobs",
                      "de": "Container-Jobs"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Delivery Plans",
                      "de": "Delivery Plans"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Area paths",
                      "de": "Area Paths"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Wiki pages",
                      "de": "Wiki-Seiten"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Container jobs run steps inside a defined image so tool versions stay consistent across agents.",
              "de": "Container-Jobs führen Schritte in einem definierten Image aus, sodass Tool-Versionen über Agenten hinweg konsistent bleiben."
          },
          "hint": {
              "en": "The requirement is a consistent toolchain.",
              "de": "Die Anforderung ist eine konsistente Toolchain."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/process/container-phases?view=azure-devops",
          "id": "az400-269"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Integration tests need a temporary Redis or PostgreSQL instance next to the test job in GitHub Actions.",
              "de": "Integrationstests benötigen eine temporäre Redis- oder PostgreSQL-Instanz neben dem Test-Job in GitHub Actions."
          },
          "question": {
              "en": "Which feature should you use?",
              "de": "Welche Funktion sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Service containers",
                      "de": "Service-Container"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Project fields",
                      "de": "Projektfelder"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Merge queue",
                      "de": "Merge Queue"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Git notes",
                      "de": "Git Notes"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Service containers provide dependent services such as databases for the duration of a workflow job.",
              "de": "Service-Container stellen abhängige Dienste wie Datenbanken für die Dauer eines Workflow-Jobs bereit."
          },
          "hint": {
              "en": "The test job needs an ephemeral dependency service.",
              "de": "Der Test-Job benötigt einen temporären abhängigen Dienst."
          },
          "reference": "https://docs.github.com/en/actions/using-containerized-services/about-service-containers",
          "id": "az400-270"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "An Azure App Service deployment should be validated before users receive traffic, and rollback should be quick.",
              "de": "Eine Azure-App-Service-Bereitstellung soll validiert werden, bevor Benutzer Traffic erhalten, und Rollback soll schnell möglich sein."
          },
          "question": {
              "en": "What should you use?",
              "de": "Was sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Deployment slots with swap",
                      "de": "Deployment Slots mit Swap"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Direct production overwrite",
                      "de": "Direktes Überschreiben von production"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Git stash",
                      "de": "Git Stash"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Area paths",
                      "de": "Area Paths"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Deployment slots let you warm up and validate a version before swapping it into production.",
              "de": "Deployment Slots erlauben es, eine Version aufzuwärmen und zu validieren, bevor sie in production getauscht wird."
          },
          "hint": {
              "en": "The goal is validation before cutover.",
              "de": "Das Ziel ist Validierung vor dem Umschalten."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/app-service/deploy-staging-slots",
          "id": "az400-271"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Infrastructure should be defined in source control and deployed repeatably through the pipeline.",
              "de": "Infrastruktur soll im Quellcode definiert und wiederholbar durch die Pipeline bereitgestellt werden."
          },
          "question": {
              "en": "Which approach fits best?",
              "de": "Welcher Ansatz passt am besten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Bicep or other infrastructure as code templates",
                      "de": "Bicep oder andere Infrastructure-as-Code-Templates"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Manual portal changes",
                      "de": "Manuelle Portaländerungen"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A spreadsheet of resources",
                      "de": "Eine Tabelle mit Ressourcen"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Chat instructions",
                      "de": "Chat-Anweisungen"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Infrastructure as code makes infrastructure changes versioned, reviewable, and repeatable.",
              "de": "Infrastructure as Code macht Infrastrukturänderungen versioniert, überprüfbar und wiederholbar."
          },
          "hint": {
              "en": "The infrastructure definition must live in code.",
              "de": "Die Infrastrukturdefinition muss im Code leben."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/deploy-pipelines",
          "id": "az400-272"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Before applying an Azure infrastructure change, operators want a preview of what resources will be created, changed, or deleted.",
              "de": "Bevor eine Azure-Infrastrukturänderung angewendet wird, möchten Betreiber eine Vorschau darauf, welche Ressourcen erstellt, geändert oder gelöscht werden."
          },
          "question": {
              "en": "What should the pipeline run?",
              "de": "Was sollte die Pipeline ausführen?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "A what-if deployment",
                      "de": "Eine What-If-Bereitstellung"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A git revert",
                      "de": "Ein git revert"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A draft pull request",
                      "de": "Einen Draft Pull Request"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A release note export",
                      "de": "Einen Export der Release Notes"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "What-if shows the predicted infrastructure delta before the deployment is executed.",
              "de": "What-If zeigt die vorhergesagte Infrastrukturänderung, bevor die Bereitstellung ausgeführt wird."
          },
          "hint": {
              "en": "This requirement is about pre-deployment preview.",
              "de": "Diese Anforderung betrifft eine Vorschau vor der Bereitstellung."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/deploy-what-if",
          "id": "az400-273"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "hard",
          "scenario": {
              "en": "Terraform runs on different agents, and state must be shared safely with locking and persistence.",
              "de": "Terraform-Läufe erfolgen auf unterschiedlichen Agenten, und der State muss sicher mit Sperrung und Persistenz geteilt werden."
          },
          "question": {
              "en": "How should you store the Terraform state?",
              "de": "Wie sollten Sie den Terraform-State speichern?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Use a remote backend such as Azure Storage",
                      "de": "Einen Remote-Backend wie Azure Storage verwenden"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Keep state on each agent disk",
                      "de": "State auf jeder Agent-Festplatte behalten"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Store state in the repository",
                      "de": "State im Repository speichern"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Email the state file",
                      "de": "Die State-Datei per E-Mail senden"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A remote backend centralizes Terraform state for safe shared use across agents and runs.",
              "de": "Ein Remote-Backend zentralisiert den Terraform-State für die sichere gemeinsame Nutzung über Agenten und Läufe hinweg."
          },
          "hint": {
              "en": "State must not live only on one build machine.",
              "de": "State darf nicht nur auf einer Build-Maschine liegen."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/developer/terraform/get-started/store-state-in-azure-storage",
          "id": "az400-274"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "easy",
          "scenario": {
              "en": "A pipeline must build a classic .NET Framework application that requires Visual Studio build tools.",
              "de": "Eine Pipeline muss eine klassische .NET-Framework-Anwendung bauen, die Visual-Studio-Build-Tools benötigt."
          },
          "question": {
              "en": "Which agent type is the safer choice?",
              "de": "Welcher Agent-Typ ist die sicherere Wahl?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "A Windows agent pool",
                      "de": "Ein Windows-Agent-Pool"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A Linux agent pool",
                      "de": "Ein Linux-Agent-Pool"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "No agent at all",
                      "de": "Überhaupt kein Agent"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A delivery plan",
                      "de": "Ein Delivery Plan"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A Windows agent pool is needed for Windows-only build toolchains such as classic .NET Framework builds.",
              "de": "Ein Windows-Agent-Pool wird für Windows-exklusive Build-Toolchains wie klassische .NET-Framework-Builds benötigt."
          },
          "hint": {
              "en": "The toolchain is Windows-specific.",
              "de": "Die Toolchain ist Windows-spezifisch."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/agents/pools-queues?view=azure-devops",
          "id": "az400-275"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A job must run only on self-hosted agents that have Docker installed and a specific custom capability.",
              "de": "Ein Job darf nur auf Self-hosted-Agenten laufen, auf denen Docker installiert ist und die eine bestimmte benutzerdefinierte Fähigkeit besitzen."
          },
          "question": {
              "en": "What should you configure?",
              "de": "Was sollten Sie konfigurieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Demands and capabilities",
                      "de": "Anforderungen und Fähigkeiten"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Work item tags",
                      "de": "Work-Item-Tags"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A wiki template",
                      "de": "Ein Wiki-Template"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Branch names",
                      "de": "Branch-Namen"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Demands match jobs to agents whose capabilities satisfy the required tools or labels.",
              "de": "Anforderungen ordnen Jobs Agenten zu, deren Fähigkeiten die benötigten Tools oder Kennzeichnungen erfüllen."
          },
          "hint": {
              "en": "The goal is selecting the right agents automatically.",
              "de": "Das Ziel ist die automatische Auswahl der richtigen Agenten."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/agents/agents?view=azure-devops",
          "id": "az400-276"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "easy",
          "scenario": {
              "en": "A full security and dependency scan should run every night even if no developer pushed code that day.",
              "de": "Ein vollständiger Sicherheits- und Abhängigkeitenscan soll jede Nacht laufen, auch wenn an diesem Tag kein Entwickler Code gepusht hat."
          },
          "question": {
              "en": "Which trigger should you use?",
              "de": "Welchen Trigger sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Scheduled trigger",
                      "de": "Geplanter Trigger"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Path filter only",
                      "de": "Nur Pfadfilter"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Draft pull request",
                      "de": "Draft Pull Request"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Manual merge",
                      "de": "Manueller Merge"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A scheduled trigger starts pipeline runs on a defined timetable independent of code pushes.",
              "de": "Ein geplanter Trigger startet Pipeline-Läufe nach einem festgelegten Zeitplan unabhängig von Code-Pushes."
          },
          "hint": {
              "en": "The run must happen on a clock, not on a commit.",
              "de": "Der Lauf muss zeitgesteuert erfolgen, nicht durch einen Commit."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/build/triggers?view=azure-devops",
          "id": "az400-277"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "hard",
          "scenario": {
              "en": "The platform team wants all service pipelines to inherit required security steps from a centrally controlled base definition.",
              "de": "Das Platform-Team möchte, dass alle Service-Pipelines verpflichtende Sicherheitsschritte aus einer zentral kontrollierten Basisdefinition erben."
          },
          "question": {
              "en": "Which template approach best fits?",
              "de": "Welcher Template-Ansatz passt am besten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Extends templates",
                      "de": "Extends-Templates"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Copy and paste YAML",
                      "de": "YAML kopieren und einfügen"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Manual checklist",
                      "de": "Manuelle Checkliste"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Git stashes",
                      "de": "Git-Stashes"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "An extends template lets the platform team define a base pipeline structure with enforced logic.",
              "de": "Ein Extends-Template lässt das Platform-Team eine Basis-Pipeline-Struktur mit erzwungener Logik definieren."
          },
          "hint": {
              "en": "The key is inheriting a governed base pipeline.",
              "de": "Entscheidend ist das Erben einer gesteuerten Basis-Pipeline."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/process/templates?view=azure-devops#extend-from-a-template",
          "id": "az400-278"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "In an Azure Pipelines monorepo, the payments pipeline should run only when files under src/payments change.",
              "de": "In einem Azure-Pipelines-Monorepo soll die Payments-Pipeline nur laufen, wenn sich Dateien unter src/payments ändern."
          },
          "question": {
              "en": "What should you configure?",
              "de": "Was sollten Sie konfigurieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Path filters on the trigger",
                      "de": "Pfadfilter auf dem Trigger"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A release note template",
                      "de": "Ein Release-Note-Template"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A work item query",
                      "de": "Eine Work-Item-Abfrage"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A delivery board",
                      "de": "Ein Delivery-Board"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Path filters reduce unnecessary pipeline runs by watching only the relevant directories.",
              "de": "Pfadfilter reduzieren unnötige Pipeline-Läufe, indem nur relevante Verzeichnisse überwacht werden."
          },
          "hint": {
              "en": "This is trigger scoping by directory.",
              "de": "Dies ist Trigger-Einschränkung nach Verzeichnis."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/build/triggers?view=azure-devops",
          "id": "az400-279"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Multiple teams need a managed internal feed for NuGet, npm, or Maven packages produced by CI.",
              "de": "Mehrere Teams benötigen einen verwalteten internen Feed für NuGet-, npm- oder Maven-Pakete, die von CI erzeugt werden."
          },
          "question": {
              "en": "Which Azure DevOps service should you use?",
              "de": "Welchen Azure-DevOps-Dienst sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Azure Artifacts",
                      "de": "Azure Artifacts"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Azure Boards",
                      "de": "Azure Boards"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Service hooks",
                      "de": "Service Hooks"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Delivery Plans",
                      "de": "Delivery Plans"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Azure Artifacts hosts internal package feeds for common package types and integrates with pipelines.",
              "de": "Azure Artifacts hostet interne Paket-Feeds für gängige Pakettypen und integriert sich in Pipelines."
          },
          "hint": {
              "en": "The requirement is package distribution, not deployment.",
              "de": "Die Anforderung betrifft Paketverteilung, nicht Bereitstellung."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/artifacts/start-using-azure-artifacts?view=azure-devops",
          "id": "az400-280"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A release introduces a regression, and operations wants the fastest low-risk rollback using an already verified build output.",
              "de": "Ein Release führt eine Regression ein, und der Betrieb möchte das schnellste risikoarme Rollback mit einem bereits verifizierten Build-Output."
          },
          "question": {
              "en": "What should the team redeploy?",
              "de": "Was sollte das Team erneut bereitstellen?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "The previously known-good artifact or image tag",
                      "de": "Das zuvor bekannte gute Artefakt oder Image-Tag"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Whatever is on a developer laptop",
                      "de": "Was auch immer auf dem Laptop eines Entwicklers liegt"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "An unreviewed local branch",
                      "de": "Einen ungeprüften lokalen Branch"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A wiki export",
                      "de": "Einen Wiki-Export"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Redeploying the last known-good artifact preserves the tested package and reduces rollback risk.",
              "de": "Die erneute Bereitstellung des zuletzt bekannten guten Artefakts bewahrt das getestete Paket und reduziert das Rollback-Risiko."
          },
          "hint": {
              "en": "Rollback should use a previously validated deliverable.",
              "de": "Rollback sollte ein zuvor validiertes Lieferobjekt verwenden."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/artifacts/pipeline-artifacts?view=azure-devops",
          "id": "az400-281"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A pipeline needs secrets from Azure without storing them directly in YAML or in the repository.",
              "de": "Eine Pipeline benötigt Secrets aus Azure, ohne sie direkt in YAML oder im Repository zu speichern."
          },
          "question": {
              "en": "Which solution is best?",
              "de": "Welche Lösung ist am besten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Retrieve secrets from Azure Key Vault at runtime",
                      "de": "Secrets zur Laufzeit aus Azure Key Vault abrufen"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Hard-code them in variables",
                      "de": "Sie hart in Variablen kodieren"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Store them in README",
                      "de": "Sie in README speichern"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Commit them to a secure branch",
                      "de": "Sie in einen sicheren Branch committen"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Azure Key Vault keeps secrets outside source control and pipelines can fetch them just in time.",
              "de": "Azure Key Vault hält Secrets außerhalb der Versionskontrolle, und Pipelines können sie bei Bedarf abrufen."
          },
          "hint": {
              "en": "The secret source should be external and managed.",
              "de": "Die Secret-Quelle sollte extern und verwaltet sein."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/release/azure-key-vault?view=azure-devops",
          "id": "az400-282"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "hard",
          "scenario": {
              "en": "Production deployments are allowed only during defined support windows in the evening.",
              "de": "Produktionsbereitstellungen sind nur während definierter Support-Zeitfenster am Abend erlaubt."
          },
          "question": {
              "en": "Which Azure Pipelines check helps enforce that rule?",
              "de": "Welche Azure-Pipelines-Prüfung hilft, diese Regel durchzusetzen?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Business hours check",
                      "de": "Business-Hours-Check"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Git stash",
                      "de": "Git Stash"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Branch rename",
                      "de": "Branch-Umbenennung"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Area path",
                      "de": "Area Path"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "A business hours check gates deployments so they run only during approved time windows.",
              "de": "Ein Business-Hours-Check blockiert Bereitstellungen, sodass sie nur während genehmigter Zeitfenster laufen."
          },
          "hint": {
              "en": "This is a time-based environment gate.",
              "de": "Dies ist ein zeitbasierter Umgebungs-Gate."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/process/approvals?view=azure-devops",
          "id": "az400-283"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "The deploy stage must wait for both the build stage and the security scan stage to finish successfully.",
              "de": "Die Deploy-Stufe muss warten, bis sowohl die Build-Stufe als auch die Security-Scan-Stufe erfolgreich beendet sind."
          },
          "question": {
              "en": "Which YAML concept should you use?",
              "de": "Welches YAML-Konzept sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "dependsOn",
                      "de": "dependsOn"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "git notes",
                      "de": "git notes"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "stashes",
                      "de": "stashes"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "code owners",
                      "de": "Code Owner"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "dependsOn defines explicit stage or job dependencies before downstream execution begins.",
              "de": "dependsOn definiert explizite Stage- oder Job-Abhängigkeiten, bevor die nachgelagerte Ausführung beginnt."
          },
          "hint": {
              "en": "The need is execution ordering between stages.",
              "de": "Die Anforderung ist die Ausführungsreihenfolge zwischen Stufen."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/process/stages?view=azure-devops",
          "id": "az400-284"
      },
      {
          "type": "single",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Teams want a deployment history by target environment so they can see what run changed AKS production last week.",
              "de": "Teams möchten eine Bereitstellungshistorie nach Zielumgebung, damit sie sehen können, welcher Lauf letzte Woche AKS production geändert hat."
          },
          "question": {
              "en": "What should you model in Azure Pipelines?",
              "de": "Was sollten Sie in Azure Pipelines modellieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "An environment resource with deployment jobs",
                      "de": "Eine Umgebungsressource mit Deployment-Jobs"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Only a build job",
                      "de": "Nur einen Build-Job"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A wiki page",
                      "de": "Eine Wiki-Seite"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A stash policy",
                      "de": "Eine Stash-Richtlinie"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Environments plus deployment jobs record deployment history against the target environment.",
              "de": "Umgebungen plus Deployment-Jobs protokollieren die Bereitstellungshistorie an der Zielumgebung."
          },
          "hint": {
              "en": "The requirement is environment-level deployment traceability.",
              "de": "Die Anforderung ist Umgebungs-bezogene Bereitstellungsnachverfolgung."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/process/deployment-jobs?view=azure-devops",
          "id": "az400-285"
      },
      {
          "type": "multiple",
          "domain": {
              "en": "Design and Implement Build and Release Pipelines",
              "de": "Build- und Release-Pipelines entwerfen und implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A GitHub Actions workflow produces a test report in one job and a later job must publish that same report.",
              "de": "Ein GitHub-Actions-Workflow erzeugt in einem Job einen Testbericht, und ein späterer Job muss genau diesen Bericht veröffentlichen."
          },
          "question": {
              "en": "Which two actions are typically used?",
              "de": "Welche zwei Actions werden typischerweise verwendet?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "upload-artifact",
                      "de": "upload-artifact"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "download-artifact",
                      "de": "download-artifact"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "delete-branch",
                      "de": "delete-branch"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "labeler",
                      "de": "labeler"
                  }
              }
          ],
          "correct": [
              "A",
              "B"
          ],
          "explanation": {
              "en": "One job uploads the artifact and the later job downloads the same artifact for reuse or publishing.",
              "de": "Ein Job lädt das Artefakt hoch, und der spätere Job lädt dasselbe Artefakt zur Wiederverwendung oder Veröffentlichung herunter."
          },
          "hint": {
              "en": "One action stores job output and the other retrieves it.",
              "de": "Eine Action speichert Job-Ausgaben, die andere ruft sie wieder ab."
          },
          "reference": "https://docs.github.com/en/actions/using-workflows/storing-workflow-data-as-artifacts",
          "id": "az400-286"
      },
      {
          "type": "single",
          "domain": {
              "en": "Develop a Security and Compliance Plan",
              "de": "Sicherheits- und Compliance-Plan entwickeln"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Security leaders want repository-integrated static analysis that runs on pull requests and highlights code vulnerabilities in GitHub.",
              "de": "Sicherheitsverantwortliche möchten repositoryintegrierte statische Analyse, die in Pull Requests läuft und Code-Schwachstellen in GitHub hervorhebt."
          },
          "question": {
              "en": "Which capability should you enable?",
              "de": "Welche Funktion sollten Sie aktivieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "GitHub Advanced Security code scanning with CodeQL",
                      "de": "GitHub Advanced Security Code Scanning mit CodeQL"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "GitHub Pages",
                      "de": "GitHub Pages"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Git tags",
                      "de": "Git-Tags"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Projects roadmap",
                      "de": "Projects-Roadmap"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Code scanning with CodeQL finds code vulnerabilities during development and surfaces them in GitHub.",
              "de": "Code Scanning mit CodeQL findet Code-Schwachstellen während der Entwicklung und zeigt sie in GitHub an."
          },
          "hint": {
              "en": "This is static analysis inside the repository workflow.",
              "de": "Dies ist statische Analyse innerhalb des Repository-Workflows."
          },
          "reference": "https://docs.github.com/en/code-security/code-scanning/introduction-to-code-scanning/about-code-scanning",
          "id": "az400-287"
      },
      {
          "type": "single",
          "domain": {
              "en": "Develop a Security and Compliance Plan",
              "de": "Sicherheits- und Compliance-Plan entwickeln"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "The organization wants to stop developers from pushing tokens and keys to GitHub in the first place.",
              "de": "Die Organisation möchte verhindern, dass Entwickler Tokens und Schlüssel überhaupt nach GitHub pushen."
          },
          "question": {
              "en": "Which feature is the best fit?",
              "de": "Welche Funktion passt am besten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Secret scanning push protection",
                      "de": "Secret-Scanning Push Protection"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Release notes",
                      "de": "Release Notes"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Milestones",
                      "de": "Meilensteine"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Draft PRs",
                      "de": "Draft PRs"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Push protection can block pushes that contain detected secrets before the secret lands in the repository.",
              "de": "Push Protection kann Pushes blockieren, die erkannte Secrets enthalten, bevor das Secret im Repository landet."
          },
          "hint": {
              "en": "The control should act before the push completes.",
              "de": "Die Kontrolle soll eingreifen, bevor der Push abgeschlossen ist."
          },
          "reference": "https://docs.github.com/en/code-security/secret-scanning/introduction/about-secret-scanning",
          "id": "az400-288"
      },
      {
          "type": "single",
          "domain": {
              "en": "Develop a Security and Compliance Plan",
              "de": "Sicherheits- und Compliance-Plan entwickeln"
          },
          "difficulty": "easy",
          "scenario": {
              "en": "Teams want automatic alerts and update pull requests when vulnerable package versions are discovered.",
              "de": "Teams möchten automatische Warnungen und Update-Pull-Requests, wenn verwundbare Paketversionen entdeckt werden."
          },
          "question": {
              "en": "Which GitHub feature should they use?",
              "de": "Welche GitHub-Funktion sollten sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Dependabot alerts and security updates",
                      "de": "Dependabot-Warnungen und Sicherheitsupdates"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "GitHub Pages",
                      "de": "GitHub Pages"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Issue templates",
                      "de": "Issue-Templates"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Protected tags",
                      "de": "Geschützte Tags"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Dependabot detects vulnerable dependencies and can open remediation pull requests automatically.",
              "de": "Dependabot erkennt verwundbare Abhängigkeiten und kann automatisch Pull Requests zur Behebung öffnen."
          },
          "hint": {
              "en": "This is dependency vulnerability management.",
              "de": "Dies ist Management von Abhängigkeits-Schwachstellen."
          },
          "reference": "https://docs.github.com/en/code-security/dependabot/dependabot-alerts/about-dependabot-alerts",
          "id": "az400-289"
      },
      {
          "type": "single",
          "domain": {
              "en": "Develop a Security and Compliance Plan",
              "de": "Sicherheits- und Compliance-Plan entwickeln"
          },
          "difficulty": "hard",
          "scenario": {
              "en": "A GitHub Actions workflow must deploy to Azure, but the security team does not want long-lived client secrets stored in GitHub.",
              "de": "Ein GitHub-Actions-Workflow muss nach Azure bereitstellen, aber das Sicherheitsteam möchte keine langlebigen Client-Secrets in GitHub speichern."
          },
          "question": {
              "en": "What should you implement?",
              "de": "Was sollten Sie implementieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "OIDC federation between GitHub and Azure",
                      "de": "OIDC-Föderation zwischen GitHub und Azure"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A hard-coded service principal secret",
                      "de": "Ein hart codiertes Service-Principal-Secret"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A shared admin account",
                      "de": "Ein geteiltes Admin-Konto"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A PAT in the repository",
                      "de": "Ein PAT im Repository"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "OIDC federation issues short-lived tokens at runtime and removes the need for a stored client secret.",
              "de": "OIDC-Föderation stellt zur Laufzeit kurzlebige Tokens aus und beseitigt die Notwendigkeit eines gespeicherten Client-Secrets."
          },
          "hint": {
              "en": "The goal is secretless cloud authentication.",
              "de": "Das Ziel ist cloudseitige Authentifizierung ohne gespeicherte Secrets."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/developer/github/connect-from-azure-openid-connect",
          "id": "az400-290"
      },
      {
          "type": "single",
          "domain": {
              "en": "Develop a Security and Compliance Plan",
              "de": "Sicherheits- und Compliance-Plan entwickeln"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "An Azure-hosted workload needs to read secrets from Key Vault without embedding credentials in code or configuration.",
              "de": "Ein in Azure gehosteter Workload muss Secrets aus Key Vault lesen, ohne Anmeldeinformationen in Code oder Konfiguration einzubetten."
          },
          "question": {
              "en": "Which identity model should you use?",
              "de": "Welches Identitätsmodell sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Managed identity",
                      "de": "Managed Identity"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A shared service account password",
                      "de": "Ein gemeinsames Servicekonto-Passwort"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A local admin account",
                      "de": "Ein lokales Admin-Konto"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A wiki token",
                      "de": "Ein Wiki-Token"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Managed identities let Azure resources authenticate to other Azure services without stored secrets.",
              "de": "Managed Identities erlauben Azure-Ressourcen die Authentifizierung gegenüber anderen Azure-Diensten ohne gespeicherte Secrets."
          },
          "hint": {
              "en": "The workload itself needs Azure-native identity.",
              "de": "Der Workload selbst benötigt eine Azure-native Identität."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/active-directory/managed-identities-azure-resources/overview",
          "id": "az400-291"
      },
      {
          "type": "single",
          "domain": {
              "en": "Develop a Security and Compliance Plan",
              "de": "Sicherheits- und Compliance-Plan entwickeln"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A service connection can currently deploy to the entire subscription, but the pipeline should touch only one resource group.",
              "de": "Eine Serviceverbindung kann derzeit in das gesamte Abonnement bereitstellen, aber die Pipeline soll nur eine Ressourcengruppe berühren."
          },
          "question": {
              "en": "What security principle should you apply?",
              "de": "Welches Sicherheitsprinzip sollten Sie anwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Least privilege by scoping permissions to the resource group",
                      "de": "Least Privilege durch Einschränkung der Berechtigungen auf die Ressourcengruppe"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "More global contributor roles",
                      "de": "Mehr globale Contributor-Rollen"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Shared owner access",
                      "de": "Geteilter Owner-Zugriff"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "No RBAC",
                      "de": "Kein RBAC"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Scoping the service connection to only required resources reduces blast radius and follows least privilege.",
              "de": "Die Einschränkung der Serviceverbindung auf nur benötigte Ressourcen reduziert den Blast Radius und folgt dem Prinzip Least Privilege."
          },
          "hint": {
              "en": "The pipeline needs less access, not more.",
              "de": "Die Pipeline benötigt weniger Zugriff, nicht mehr."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/library/service-endpoints?view=azure-devops",
          "id": "az400-292"
      },
      {
          "type": "single",
          "domain": {
              "en": "Develop a Security and Compliance Plan",
              "de": "Sicherheits- und Compliance-Plan entwickeln"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Release managers want stronger provenance for code merged to main and prefer verifiable authorship on commits.",
              "de": "Release-Manager möchten stärkere Provenienz für in main gemergten Code und bevorzugen überprüfbare Autorschaft bei Commits."
          },
          "question": {
              "en": "Which protected-branch setting helps?",
              "de": "Welche Protected-Branch-Einstellung hilft?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Require signed commits",
                      "de": "Signierte Commits verlangen"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Allow force pushes",
                      "de": "Force Pushes erlauben"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Disable status checks",
                      "de": "Status Checks deaktivieren"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Turn off pull requests",
                      "de": "Pull Requests ausschalten"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Requiring signed commits increases trust in commit authenticity and provenance.",
              "de": "Das Verlangen signierter Commits erhöht das Vertrauen in Echtheit und Provenienz von Commits."
          },
          "hint": {
              "en": "The requirement is verifiable commit authorship.",
              "de": "Die Anforderung ist überprüfbare Commit-Autorschaft."
          },
          "reference": "https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/about-protected-branches",
          "id": "az400-293"
      },
      {
          "type": "single",
          "domain": {
              "en": "Develop a Security and Compliance Plan",
              "de": "Sicherheits- und Compliance-Plan entwickeln"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Compliance requires each build artifact to include a machine-readable inventory of included software components.",
              "de": "Compliance verlangt, dass jedes Build-Artefakt ein maschinenlesbares Inventar der enthaltenen Software-Komponenten enthält."
          },
          "question": {
              "en": "What should the pipeline generate?",
              "de": "Was sollte die Pipeline erzeugen?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "An SBOM",
                      "de": "Ein SBOM"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A sprint backlog",
                      "de": "Ein Sprint-Backlog"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A force push",
                      "de": "Einen Force Push"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A wiki home page",
                      "de": "Eine Wiki-Startseite"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "An SBOM documents the software components in the artifact and supports supply chain transparency.",
              "de": "Ein SBOM dokumentiert die Software-Komponenten im Artefakt und unterstützt Transparenz in der Lieferkette."
          },
          "hint": {
              "en": "This is about software component inventory.",
              "de": "Dies betrifft ein Inventar der Software-Komponenten."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/security/fundamentals/supply-chain-security",
          "id": "az400-294"
      },
      {
          "type": "single",
          "domain": {
              "en": "Develop a Security and Compliance Plan",
              "de": "Sicherheits- und Compliance-Plan entwickeln"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Container images pushed to ACR should be assessed for known vulnerabilities before deployment approval.",
              "de": "Container-Images, die nach ACR gepusht werden, sollen vor der Bereitstellung auf bekannte Schwachstellen geprüft werden."
          },
          "question": {
              "en": "Which Azure capability helps here?",
              "de": "Welche Azure-Funktion hilft hier?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Microsoft Defender scanning for container registries",
                      "de": "Microsoft-Defender-Scanning für Container-Registries"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Area paths",
                      "de": "Area Paths"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Velocity chart",
                      "de": "Velocity-Diagramm"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Git notes",
                      "de": "Git Notes"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Defender for container registries can surface vulnerability findings for images stored in ACR.",
              "de": "Defender für Container-Registries kann Schwachstellenbefunde für in ACR gespeicherte Images anzeigen."
          },
          "hint": {
              "en": "The control is image vulnerability assessment.",
              "de": "Die Kontrolle ist eine Schwachstellenbewertung von Images."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/defender-for-cloud/defender-for-container-registries-introduction",
          "id": "az400-295"
      },
      {
          "type": "single",
          "domain": {
              "en": "Develop a Security and Compliance Plan",
              "de": "Sicherheits- und Compliance-Plan entwickeln"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Operations wants one central place to store secrets and rotate them without editing many pipelines.",
              "de": "Der Betrieb möchte einen zentralen Ort zum Speichern und Rotieren von Secrets, ohne viele Pipelines bearbeiten zu müssen."
          },
          "question": {
              "en": "Which service should you use?",
              "de": "Welchen Dienst sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Azure Key Vault",
                      "de": "Azure Key Vault"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Azure Boards",
                      "de": "Azure Boards"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Delivery Plans",
                      "de": "Delivery Plans"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Git tags",
                      "de": "Git-Tags"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Azure Key Vault centralizes secrets and supports controlled access and rotation outside pipeline code.",
              "de": "Azure Key Vault zentralisiert Secrets und unterstützt kontrollierten Zugriff sowie Rotation außerhalb des Pipeline-Codes."
          },
          "hint": {
              "en": "The requirement is centralized secret management.",
              "de": "Die Anforderung ist zentrales Secret-Management."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/devops/pipelines/release/azure-key-vault?view=azure-devops",
          "id": "az400-296"
      },
      {
          "type": "single",
          "domain": {
              "en": "Implement an Instrumentation Strategy",
              "de": "Instrumentierungsstrategie implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A user request passes through several microservices, and engineers want to see one correlated end-to-end trace.",
              "de": "Eine Benutzeranfrage läuft durch mehrere Microservices, und Ingenieure möchten eine korrelierte End-to-End-Trace sehen."
          },
          "question": {
              "en": "What should you implement?",
              "de": "Was sollten Sie implementieren?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Application Insights distributed tracing and correlation",
                      "de": "Application-Insights-Distributed-Tracing und Korrelation"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "More Git tags",
                      "de": "Mehr Git-Tags"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A deployment group",
                      "de": "Eine Bereitstellungsgruppe"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A wiki page",
                      "de": "Eine Wiki-Seite"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Distributed tracing correlates telemetry across services so one request can be followed through the whole system.",
              "de": "Distributed Tracing korreliert Telemetrie über Services hinweg, sodass eine Anfrage durch das gesamte System verfolgt werden kann."
          },
          "hint": {
              "en": "The goal is end-to-end request correlation.",
              "de": "Das Ziel ist End-to-End-Korrelation von Anfragen."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/azure-monitor/app/distributed-tracing-telemetry-correlation",
          "id": "az400-297"
      },
      {
          "type": "single",
          "domain": {
              "en": "Implement an Instrumentation Strategy",
              "de": "Instrumentierungsstrategie implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A public API should be probed from outside the system every few minutes so the team learns about outages before customers do.",
              "de": "Eine öffentliche API soll alle paar Minuten von außerhalb des Systems getestet werden, damit das Team Ausfälle vor den Kunden bemerkt."
          },
          "question": {
              "en": "Which Azure Monitor feature is most appropriate?",
              "de": "Welche Azure-Monitor-Funktion ist am geeignetsten?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Availability tests",
                      "de": "Verfügbarkeitstests"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Branch policies",
                      "de": "Branchrichtlinien"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Area paths",
                      "de": "Area Paths"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Package feeds",
                      "de": "Paket-Feeds"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Availability tests provide synthetic monitoring from outside the application path.",
              "de": "Verfügbarkeitstests bieten synthetisches Monitoring von außerhalb des Anwendungspfads."
          },
          "hint": {
              "en": "The requirement is proactive synthetic monitoring.",
              "de": "Die Anforderung ist proaktives synthetisches Monitoring."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/azure-monitor/app/availability-overview",
          "id": "az400-298"
      },
      {
          "type": "single",
          "domain": {
              "en": "Implement an Instrumentation Strategy",
              "de": "Instrumentierungsstrategie implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Operations wants one dashboard that combines telemetry from several Azure resources and subscriptions.",
              "de": "Der Betrieb möchte ein Dashboard, das Telemetrie aus mehreren Azure-Ressourcen und Abonnements kombiniert."
          },
          "question": {
              "en": "Which Azure Monitor capability should you use?",
              "de": "Welche Azure-Monitor-Funktion sollten Sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Workbooks",
                      "de": "Workbooks"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "Git hooks",
                      "de": "Git-Hooks"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Release branches",
                      "de": "Release-Branches"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Variable groups",
                      "de": "Variablengruppen"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Workbooks create interactive dashboards and can combine data from many monitored resources.",
              "de": "Workbooks erstellen interaktive Dashboards und können Daten aus vielen überwachten Ressourcen kombinieren."
          },
          "hint": {
              "en": "This is a shared observability dashboard use case.",
              "de": "Dies ist ein Anwendungsfall für ein gemeinsames Observability-Dashboard."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/azure-monitor/visualize/workbooks-overview",
          "id": "az400-299"
      },
      {
          "type": "single",
          "domain": {
              "en": "Implement an Instrumentation Strategy",
              "de": "Instrumentierungsstrategie implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "Engineers need to compare API failures for the 30 minutes before and after a deployment using log data.",
              "de": "Ingenieure müssen API-Fehler in den 30 Minuten vor und nach einer Bereitstellung mithilfe von Log-Daten vergleichen."
          },
          "question": {
              "en": "What should they use?",
              "de": "Was sollten sie verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "A KQL query in Log Analytics",
                      "de": "Eine KQL-Abfrage in Log Analytics"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A git rebase",
                      "de": "Ein git rebase"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A release branch",
                      "de": "Einen Release-Branch"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A pull request draft",
                      "de": "Einen Draft Pull Request"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "KQL queries in Log Analytics let teams slice and compare telemetry over specific time windows.",
              "de": "KQL-Abfragen in Log Analytics lassen Teams Telemetrie über bestimmte Zeitfenster aufteilen und vergleichen."
          },
          "hint": {
              "en": "The requirement is log analysis over time windows.",
              "de": "Die Anforderung ist Log-Analyse über Zeitfenster."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/azure-monitor/logs/log-query-overview",
          "id": "az400-300"
      },
      {
          "type": "single",
          "domain": {
              "en": "Implement an Instrumentation Strategy",
              "de": "Instrumentierungsstrategie implementieren"
          },
          "difficulty": "medium",
          "scenario": null,
          "question": {
              "en": "What is an SLI in site reliability engineering?",
              "de": "Was ist ein SLI im Site Reliability Engineering?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "A measured indicator of service behavior such as latency or success rate",
                      "de": "Ein gemessener Indikator des Serviceverhaltens wie Latenz oder Erfolgsquote"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A customer contract",
                      "de": "Ein Kundenvertrag"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A release strategy",
                      "de": "Eine Release-Strategie"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A Git branching model",
                      "de": "Ein Git-Branching-Modell"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "An SLI is the actual measured reliability indicator used to evaluate service health.",
              "de": "Ein SLI ist der tatsächlich gemessene Zuverlässigkeitsindikator zur Bewertung der Service-Gesundheit."
          },
          "hint": {
              "en": "Think measurement, not target or contract.",
              "de": "Denken Sie an Messung, nicht an Ziel oder Vertrag."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/well-architected/operational-excellence/metrics-monitoring",
          "id": "az400-301"
      },
      {
          "type": "single",
          "domain": {
              "en": "Implement an Instrumentation Strategy",
              "de": "Instrumentierungsstrategie implementieren"
          },
          "difficulty": "easy",
          "scenario": null,
          "question": {
              "en": "What is an SLO?",
              "de": "Was ist ein SLO?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "A target value for an SLI over a period",
                      "de": "Ein Zielwert für ein SLI über einen Zeitraum"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A GitHub secret",
                      "de": "Ein GitHub-Secret"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A package feed",
                      "de": "Ein Paket-Feed"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A rollback script",
                      "de": "Ein Rollback-Skript"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "An SLO defines the reliability objective the team aims to meet for the measured indicator.",
              "de": "Ein SLO definiert das Zuverlässigkeitsziel, das das Team für den gemessenen Indikator erreichen will."
          },
          "hint": {
              "en": "The SLO is the target, not the measurement itself.",
              "de": "Das SLO ist das Ziel, nicht die Messung selbst."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/well-architected/operational-excellence/metrics-monitoring",
          "id": "az400-302"
      },
      {
          "type": "single",
          "domain": {
              "en": "Implement an Instrumentation Strategy",
              "de": "Instrumentierungsstrategie implementieren"
          },
          "difficulty": "medium",
          "scenario": null,
          "question": {
              "en": "What does an error budget represent?",
              "de": "Was stellt ein Error Budget dar?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "The remaining allowed unreliability before the SLO is missed",
                      "de": "Die verbleibende erlaubte Unzuverlässigkeit, bevor das SLO verfehlt wird"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "The Azure subscription budget",
                      "de": "Das Budget des Azure-Abonnements"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "The build agent quota",
                      "de": "Die Quote des Build-Agenten"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "The number of open bugs",
                      "de": "Die Anzahl offener Bugs"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "An error budget quantifies how much unreliability the service can still tolerate within the SLO window.",
              "de": "Ein Error Budget quantifiziert, wie viel Unzuverlässigkeit der Service innerhalb des SLO-Zeitraums noch tolerieren kann."
          },
          "hint": {
              "en": "It connects release speed to reliability tolerance.",
              "de": "Es verbindet Release-Geschwindigkeit mit Zuverlässigkeitstoleranz."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/well-architected/operational-excellence/metrics-monitoring",
          "id": "az400-303"
      },
      {
          "type": "single",
          "domain": {
              "en": "Implement an Instrumentation Strategy",
              "de": "Instrumentierungsstrategie implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "A team wants to expose a new feature only to internal users first and enable it broadly later without redeploying.",
              "de": "Ein Team möchte ein neues Feature zunächst nur internen Benutzern bereitstellen und es später ohne erneute Bereitstellung breit aktivieren."
          },
          "question": {
              "en": "What should it use?",
              "de": "Was sollte es verwenden?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Feature flags with targeting",
                      "de": "Feature Flags mit Targeting"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A release branch per user",
                      "de": "Einen Release-Branch pro Benutzer"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Manual code edits in production",
                      "de": "Manuelle Codeänderungen in production"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A wiki toggle",
                      "de": "Einen Wiki-Schalter"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Feature flags decouple release from exposure and can target selected user groups first.",
              "de": "Feature Flags entkoppeln Release von Freischaltung und können zunächst ausgewählte Benutzergruppen ansprechen."
          },
          "hint": {
              "en": "The key is gradual exposure without redeployment.",
              "de": "Entscheidend ist schrittweise Freischaltung ohne erneute Bereitstellung."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/azure-app-configuration/manage-feature-flags",
          "id": "az400-304"
      },
      {
          "type": "single",
          "domain": {
              "en": "Implement an Instrumentation Strategy",
              "de": "Instrumentierungsstrategie implementieren"
          },
          "difficulty": "medium",
          "scenario": {
              "en": "The team wants a marker in Application Insights whenever a deployment happens so incident spikes can be correlated with releases.",
              "de": "Das Team möchte eine Markierung in Application Insights, wenn eine Bereitstellung erfolgt, damit Incident-Spitzen mit Releases korreliert werden können."
          },
          "question": {
              "en": "What should it add?",
              "de": "Was sollte es hinzufügen?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Release annotations",
                      "de": "Release-Anmerkungen"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "More Git tags",
                      "de": "Mehr Git-Tags"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "Extra area paths",
                      "de": "Zusätzliche Area Paths"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "Sprint templates",
                      "de": "Sprint-Templates"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Release annotations place deployment markers on telemetry timelines for easier correlation during investigations.",
              "de": "Release-Anmerkungen setzen Bereitstellungsmarkierungen auf Telemetrie-Zeitachsen für eine leichtere Korrelation bei Untersuchungen."
          },
          "hint": {
              "en": "The team needs deployment markers in observability data.",
              "de": "Das Team benötigt Bereitstellungsmarkierungen in Observability-Daten."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/azure-monitor/app/annotations",
          "id": "az400-305"
      },
      {
          "type": "single",
          "domain": {
              "en": "Implement an Instrumentation Strategy",
              "de": "Instrumentierungsstrategie implementieren"
          },
          "difficulty": "hard",
          "scenario": {
              "en": "A canary rollout sends telemetry from both stable and new versions, and engineers want to compare them directly in dashboards and queries.",
              "de": "Ein Canary-Rollout sendet Telemetrie von stabilen und neuen Versionen, und Ingenieure möchten beide direkt in Dashboards und Abfragen vergleichen."
          },
          "question": {
              "en": "What should the application add to telemetry?",
              "de": "Was sollte die Anwendung zur Telemetrie hinzufügen?"
          },
          "options": [
              {
                  "id": "A",
                  "text": {
                      "en": "Custom dimensions such as deployment ring or version",
                      "de": "Benutzerdefinierte Dimensionen wie Deployment-Ring oder Version"
                  }
              },
              {
                  "id": "B",
                  "text": {
                      "en": "A force push",
                      "de": "Einen Force Push"
                  }
              },
              {
                  "id": "C",
                  "text": {
                      "en": "A second wiki",
                      "de": "Ein zweites Wiki"
                  }
              },
              {
                  "id": "D",
                  "text": {
                      "en": "A merge queue",
                      "de": "Eine Merge Queue"
                  }
              }
          ],
          "correct": [
              "A"
          ],
          "explanation": {
              "en": "Custom dimensions let teams filter and compare telemetry by version, ring, or release cohort during rollout analysis.",
              "de": "Benutzerdefinierte Dimensionen erlauben Teams, Telemetrie während der Rollout-Analyse nach Version, Ring oder Release-Kohorte zu filtern und zu vergleichen."
          },
          "hint": {
              "en": "The telemetry needs a label that distinguishes old from new.",
              "de": "Die Telemetrie benötigt eine Kennzeichnung, die Alt von Neu unterscheidet."
          },
          "reference": "https://learn.microsoft.com/en-us/azure/azure-monitor/app/api-custom-events-metrics",
          "id": "az400-306"
      }
  ];
  if (window.ExamData && window.ExamData['az-400']) {
    window.ExamData['az-400'].questions = window.ExamData['az-400'].questions.concat(extra);
  }
})();
