> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devinenterprise.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Incident-Postmortems automatisch generieren

export const UseCaseHero = ({title, description, prompt, category, features, devinUrl, agent, intent, playbookId, type}) => {
  const encodedPrompt = encodeURIComponent(prompt || '');
  const tag = 'docs-use-case-gallery';
  const utm = 'utm_source=docs&utm_medium=use-case-gallery&utm_campaign=hero-cta';
  const agentParams = (agent ? '&agent=' + agent : '') + (intent ? '&intent=' + intent : '') + (playbookId ? '&playbookId=' + playbookId : '');
  const devinHref = type === 'schedule' ? 'https://app.devin.ai/settings/schedules/create?' + utm + agentParams + (prompt ? '&prompt=' + encodedPrompt : '') : type === 'review' ? 'https://app.devin.ai/review?' + utm : agent === 'ada' ? 'https://app.devin.ai/search?' + utm + '&noSubmit=true' + (prompt ? '&prompt=' + encodedPrompt : '') : devinUrl ? devinUrl.includes('?') ? devinUrl + '&' + utm + agentParams : devinUrl + '?' + utm + agentParams : prompt ? 'https://app.devin.ai/?tags=' + tag + '&' + utm + agentParams + '&prompt=' + encodedPrompt : 'https://app.devin.ai/?' + utm + agentParams;
  const buttonLabel = type === 'schedule' ? 'Schedule in Devin ↗' : type === 'review' ? 'Set Up Devin Review ↗' : agent === 'advanced' ? 'Try in Devin ↗' : agent === 'dana' ? 'Try in Dana ↗' : agent === 'ada' ? 'Try in Ask Devin ↗' : 'Try in Devin ↗';
  const featureList = features ? features.split(',').map(f => f.trim()) : [];
  return <div className="uc-hero">
      <div className="uc-hero-inner">
        <div className="uc-hero-left">
          <h1 className="uc-hero-title">{title}</h1>
          <p className="uc-hero-desc">{description}</p>
          <div>
            <a href={devinHref} target="_blank" rel="noopener noreferrer" className="try-in-devin-btn">
              {buttonLabel}
            </a>
          </div>
        </div>
        <div className="uc-hero-meta">
          <div className="uc-meta-item">
            <span className="uc-meta-label">Author</span>
            <span className="uc-meta-value">Cognition</span>
          </div>
          <div className="uc-meta-item">
            <span className="uc-meta-label">Category</span>
            <span className="uc-meta-value">{category}</span>
          </div>
          {featureList.length > 0 && <div className="uc-meta-item">
              <span className="uc-meta-label">Features</span>
              <span className="uc-meta-value">{featureList.join(', ')}</span>
            </div>}
        </div>
      </div>
    </div>;
};

export const PromptBlock = ({children, type, agent, intent, playbookId}) => {
  var utm = 'utm_source=docs&utm_medium=use-case-gallery&utm_campaign=prompt-block';
  var tag = 'docs-use-case-gallery';
  var agentParams = (agent ? '&agent=' + agent : '') + (intent ? '&intent=' + intent : '') + (playbookId ? '&playbookId=' + playbookId : '');
  var label = type === 'schedule' ? 'Schedule in Devin' : type === 'playbook' ? 'Create Playbook' : type === 'knowledge' ? 'Add to Knowledge' : agent === 'advanced' ? 'Try in Devin' : agent === 'dana' ? 'Try in Dana' : agent === 'ada' ? 'Try in Ask Devin' : 'Try in Devin';
  var buildUrl = function (text) {
    var encoded = encodeURIComponent(text);
    if (type === 'schedule') return 'https://app.devin.ai/settings/schedules/create?' + utm + agentParams + '&prompt=' + encoded;
    if (type === 'playbook') return 'https://app.devin.ai/settings/playbooks/create?' + utm + '&body=' + encoded;
    if (type === 'knowledge') return 'https://app.devin.ai/knowledge?' + utm + '&body=' + encoded;
    if (agent === 'ada') return 'https://app.devin.ai/search?' + utm + '&noSubmit=true&prompt=' + encoded;
    return 'https://app.devin.ai/?tags=' + tag + '&' + utm + agentParams + '&prompt=' + encoded;
  };
  const ref = React.useRef(null);
  const [href, setHref] = React.useState('#');
  React.useEffect(() => {
    if (!ref.current) return;
    var codeEl = ref.current.querySelector('pre code');
    if (codeEl) {
      var text = codeEl.textContent.trim();
      if (text) setHref(buildUrl(text));
    }
    var header = ref.current.querySelector('[data-component-part="code-block-header"]');
    if (header && !header.querySelector('.prompt-block-devin-link')) {
      var link = document.createElement('a');
      link.href = href;
      link.target = '_blank';
      link.rel = 'noopener noreferrer';
      link.className = 'prompt-block-devin-link';
      link.style.cssText = 'display:inline-flex;align-items:center;gap:6px;text-decoration:none;color:#fff;font-size:11px;font-weight:500;padding:4px 10px;border-radius:6px;white-space:nowrap;background:#317CFF;transition:background 0.2s;margin-left:8px;';
      link.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"/><polyline points="15 3 21 3 21 9"/><line x1="10" y1="14" x2="21" y2="3"/></svg> ' + label;
      link.onmouseenter = function () {
        link.style.background = '#2968D9';
      };
      link.onmouseleave = function () {
        link.style.background = '#317CFF';
      };
      header.appendChild(link);
    }
    var existingLink = ref.current.querySelector('.prompt-block-devin-link');
    if (existingLink && href !== '#') existingLink.href = href;
  });
  return <div className="prompt-block" ref={ref}>{children}</div>;
};

<UseCaseHero title="Incident-Postmortems automatisch erstellen" description="Wenn ein PagerDuty-Vorfall behoben wird, erstellt Devin einen strukturierten Postmortem-Entwurf mit Zeitleiste, Root-Cause-Analyse und Maßnahmen." prompt="Hilf mir, eine Postmortem-Pipeline von PagerDuty zu Devin einzurichten. Folge der Anleitung unter https://docs.devin.ai/use-cases/gallery/api-pagerduty-postmortem und führe mich Schritt für Schritt durch: die Webhook-Bridge bereitzustellen, PagerDuty zu konfigurieren und Observability-MCPs zu verbinden." category="Incident Response" features="API, MCP" />

<div className="uc-detail-wrapper">
  <Tip>Für eine ausführlichere Anleitung zur PagerDuty-Integration [klicken Sie hier](/de/enterprise/integrations/pagerduty).</Tip>

  <Steps>
    <Step title="Webhook-Bridge bereitstellen">
      Erstellen Sie einen kleinen Dienst, der auf PagerDuty-`incident.resolved`-Ereignisse reagiert und eine Devin-Sitzung startet, um das Postmortem zu verfassen. Stellen Sie ihn als serverlose Funktion (AWS Lambda, Cloudflare Worker) oder als schlanken Container bereit:

      ```javascript theme={null}
      const express = require('express');
      const crypto = require('crypto');
      const app = express();
      app.use(express.json());

      function verifySignature(req) {
        const secret = Buffer.from(req.headers['x-webhook-secret'] || '');
        const expected = Buffer.from(process.env.WEBHOOK_SECRET || '');
        if (!expected.length) throw new Error('WEBHOOK_SECRET environment variable is not set');
        if (secret.length !== expected.length) return false;
        return crypto.timingSafeEqual(secret, expected);
      }

      app.post('/pagerduty-resolved', async (req, res) => {
        if (!verifySignature(req)) return res.status(401).send('Bad signature');

        const event = req.body?.event;
        if (!event || event.event_type !== 'incident.resolved') {
          return res.sendStatus(200);
        }

        const incident = event.data;
        const title = incident.title || 'Unknown incident';
        const service = incident.service?.summary || 'unknown-service';
        const urgency = incident.urgency || 'high';
        const incidentUrl = incident.html_url || '';
        const createdAt = incident.created_at || '';
        const resolvedAt = incident.resolved_at || new Date().toISOString();

        const orgId = process.env.DEVIN_ORG_ID;
        const response = await fetch(
          `https://api.devin.ai/v3/organizations/${orgId}/sessions`, {
          method: 'POST',
          headers: {
            'Authorization': `Bearer ${process.env.DEVIN_API_KEY}`,
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({
            prompt: [
              `A PagerDuty incident has been resolved. Draft a postmortem.`,
              ``,
              `Incident: "${title}"`,
              `Service: ${service}`,
              `Urgency: ${urgency}`,
              `Created: ${createdAt}`,
              `Resolved: ${resolvedAt}`,
              `Incident URL: ${incidentUrl}`,
              ``,
              `Write a structured postmortem:`,
              `1. Use the Datadog MCP to pull logs and metrics for ${service} during the incident window`,
              `2. Identify the root cause — check for deploys, config changes, or upstream failures`,
              `3. Build a detailed timeline from first alert to resolution`,
              `4. List action items to prevent recurrence`,
              `5. Post the postmortem as a PR to our docs/postmortems/ directory`,
            ].join('\n'),
            tags: ['pagerduty-postmortem', `service:${service}`],
          }),
        });

        const { session_id } = await response.json();
        console.log(`Started postmortem session ${session_id} for: ${title}`);
        res.sendStatus(200);
      });

      app.listen(3000);
      ```

      Erstellen Sie in **Settings > Service Users** unter [app.devin.ai](https://app.devin.ai/?utm_source=docs\&utm_medium=use-case-gallery) einen [Service-Benutzer](/de/api-reference/v3/overview) mit der Berechtigung `ManageOrgSessions`. Kopieren Sie das nach dem Erstellen angezeigte API-Token und speichern Sie es auf Ihrem Bridge-Service als `DEVIN_API_KEY`. Setzen Sie `DEVIN_ORG_ID` auf die ID Ihrer Organisation — Sie erhalten sie, indem Sie mit Ihrem Token `GET https://api.devin.ai/v3/enterprise/organizations` aufrufen. Setzen Sie `WEBHOOK_SECRET` auf ein gemeinsames Secret, das Sie auch in PagerDuty konfigurieren.
    </Step>

    <Step title="PagerDuty konfigurieren">
      1. Gehen Sie in PagerDuty zu **Services > \[your service] > Integrations**
      2. Klicken Sie auf **Add Integration** und wählen Sie **Generic Webhooks (v3)** aus
      3. Setzen Sie die **Webhook URL** auf Ihren Bridge-Endpunkt (z. B. `https://your-bridge.example.com/pagerduty-resolved`)
      4. Fügen Sie unter **Custom Headers** `X-Webhook-Secret` mit demselben Wert hinzu, den Sie als `WEBHOOK_SECRET` gespeichert haben
      5. Filtern Sie unter **Event Subscription** nach dem Ereignistyp `incident.resolved`, damit das Postmortem erst ausgelöst wird, wenn der Vorfall geschlossen ist

      <Note>
        Sie können auch `incident.acknowledged` abonnieren, wenn Devin bereits während des laufenden Vorfalls mit dem Sammeln von Daten beginnen und das Postmortem dann nach der Behebung abschließen soll.
      </Note>
    </Step>

    <Step title="Observability-MCPs anbinden (optional)">
      Devin schreibt bessere Postmortems, wenn es auf Ihre Telemetriedaten zugreifen kann. Aktivieren Sie einen oder mehrere MCPs, damit Devin echte Daten für den Zeitraum des Vorfalls abrufen kann:

      **Datadog MCP** — Gehen Sie zu **Settings > Connections > MCP servers**, suchen Sie **Datadog**, klicken Sie auf **Enable** und geben Sie Ihre API- und Application-Schlüssel ein. Devin fragt Logs, Metriken, Deployment-Ereignisse und den Monitor-Verlauf ab.

      **Sentry MCP** — Suchen Sie **Sentry** im MCP Marketplace, klicken Sie auf **Enable** und schließen Sie den OAuth-Vorgang ab. Devin ruft Fehlerdetails, Stacktraces und Release-Tags ab.

      Sobald die Verbindung hergestellt ist, korreliert Devin Telemetriedaten automatisch mit der Zeitachse des Vorfalls, um ein evidenzbasiertes Postmortem zu erstellen. Erfahren Sie mehr über das [Verbinden von MCP-Servern](/de/work-with-devin/mcp).
    </Step>

    <Step title="Was Devin erstellt">
      Wenn sich ein PagerDuty-Vorfall bezieht, analysiert Devin den Zeitraum des Vorfalls und erstellt ein strukturiertes Postmortem:

      <PromptBlock>
        ```txt Postmortem für Vorfall erstellen theme={null}
        Ein PagerDuty-Vorfall wurde bezogen. Erstelle ein Postmortem.

        Vorfall: „Erschöpfung des Datenbank-Verbindungspools in orders-service“
        Service: orders-service
        Erstellt: 2026-02-10T14:32:00Z
        Bezogen: 2026-02-10T15:18:00Z

        Mit Datadog- und Sentry-MCPs:
        1. Logs und Metriken für orders-service zwischen 14:00 und 15:30 UTC abrufen
        2. Auf Deployments, Konfigurationsänderungen oder Ausfälle vorgelagerter Services in diesem Zeitraum prüfen
        3. Eine detaillierte Zeitleiste vom ersten Alarm bis zur Behebung erstellen
        4. Mitwirkende Faktoren und die Grundursache identifizieren
        5. Aktions-Einträge entwerfen, um ein erneutes Auftreten zu verhindern
        6. Das Postmortem als Markdown-Datei in docs/postmortems/ committen
        ```
      </PromptBlock>

      Beispiel für ein Postmortem, das Devin erstellt:

      ```markdown theme={null}
      # Postmortem: Database Connection Pool Exhaustion — orders-service
      **Date:** 2026-02-10 | **Duration:** 46 minutes | **Severity:** P1

      ## Summary
      orders-service experienced connection pool exhaustion between
      14:32 and 15:18 UTC, causing 502 errors for ~12% of order
      placement requests.

      ## Timeline
      - 14:15 UTC — Deploy #387 released (commit e4f29a1)
      - 14:28 UTC — Connection pool usage climbed from 60% to 92%
      - 14:32 UTC — Pool exhausted; PagerDuty incident triggered
      - 14:38 UTC — On-call engineer acknowledged
      - 14:45 UTC — Identified Deploy #387 added a new inventory
                    check that opens a DB connection per line item
                    without releasing it in the finally block
      - 15:02 UTC — Rollback to Deploy #386 initiated
      - 15:18 UTC — Connection pool recovered; incident resolved

      ## Root Cause
      Deploy #387 introduced `checkInventoryAvailability()` in
      `src/services/orders.ts:142`. The function opens a new DB
      connection for each line item in an order but only releases
      it on the success path. When inventory checks fail (timeout
      or stock unavailable), connections leak.

      Orders with 5+ line items reliably exhausted the pool within
      15 minutes of the deploy.

      ## Action Items
      - [ ] Fix connection leak: add `finally` block to release
            connection (PR #388 opened)
      - [ ] Add connection pool usage monitor with alert at 80%
      - [ ] Add integration test for multi-item orders with
            simulated inventory failures
      - [ ] Review other DB access patterns for similar leak risks
      ```
    </Step>

    <Step title="Postmortem anpassen">
      Passen Sie die Pipeline an den Postmortem-Prozess Ihres Teams an:

      **Verwenden Sie ein [Playbook](/de/product-guides/creating-playbooks),** um Ihre Postmortem-Vorlage festzulegen — Abschnitte, Schweregradklassifizierung, Pflichtfelder und den Speicherort für die Ausgabe. Übergeben Sie in der API-Anfrage eine `playbook_id`, um jedes Postmortem zu standardisieren.

      **Nach Schweregrad weiterleiten.** Fügen Sie in Ihrer Bridge Logik hinzu, um Postmortems nur für Vorfälle der Schweregrade P1/P2 zu erstellen. Vorfälle mit niedrigerem Schweregrad erfordern möglicherweise keine vollständige Ausarbeitung.

      **Fügen Sie [Knowledge](/de/product-guides/knowledge)** zu Ihrer Architektur, Service-Verantwortung und früheren Vorfällen hinzu, damit Devin Zusammenhänge erkennen kann — z. B. "orders-service hängt von inventory-service ab, das unter Last bekanntermaßen Timeout-Probleme hat."

      **In Ihrem Wiki veröffentlichen.** Statt in ein Repo zu committen, lassen Sie Devin das Postmortem über den Sitzungs-Prompt in Confluence, Notion oder Ihrem internen Wiki veröffentlichen.
    </Step>
  </Steps>
</div>