chore: report template content (#1801)

* chore: report template content

* fix: metadata base path

apps/web/src/app/(landing)/blog/[slug]/page.tsx

···
     return;
   }
 
-  const metadata = getPageMetadata(post);
+  const metadata = getPageMetadata(post, "blog");
 
   return metadata;
 }
···
     notFound();
   }
 
-  const jsonLDBlog: WithContext<BlogPosting> = getJsonLDBlogPosting(post);
+  const jsonLDBlog: WithContext<BlogPosting> = getJsonLDBlogPosting(
+    post,
+    "blog",
+  );
 
   return (
     <section className="prose dark:prose-invert max-w-none">

apps/web/src/app/(landing)/blog/category/[slug]/page.tsx

···
 import type { Metadata } from "next";
 
 const TITLE = "Blog Category";
-const DESCRIPTION = "All the latest articles and news from OpenStatus.";
+const DESCRIPTION = "All the latest articles and news from openstatus.";
 
 export const metadata: Metadata = {
   ...defaultMetadata,

apps/web/src/app/(landing)/blog/page.tsx

···
 import { ContentList } from "../content-list";
 
 const TITLE = "Blog";
-const DESCRIPTION = "All the latest articles and news from OpenStatus.";
+const DESCRIPTION = "All the latest articles and news from openstatus.";
 
 export const metadata: Metadata = {
   ...defaultMetadata,

apps/web/src/app/(landing)/changelog/[slug]/page.tsx

···
-import { getPageMetadata } from "@/app/shared-metadata";
+import { getJsonLDBlogPosting, getPageMetadata } from "@/app/shared-metadata";
 import { CustomMDX } from "@/content/mdx";
 import { formatDate, getChangelogPosts } from "@/content/utils";
 import type { Metadata } from "next";
 import Image from "next/image";
 import { notFound } from "next/navigation";
+import type { BlogPosting, WithContext } from "schema-dts";
 import { ContentPagination } from "../../content-pagination";
-
-const baseUrl = "http://localhost:3000";
 
 export const dynamicParams = false;
 
···
     return;
   }
 
-  const metadata = getPageMetadata(post);
+  const metadata = getPageMetadata(post, "changelog");
 
   return metadata;
 }
···
     notFound();
   }
 
+  const jsonLDBlog: WithContext<BlogPosting> = getJsonLDBlogPosting(
+    post,
+    "changelog",
+  );
+
   return (
     <section className="prose dark:prose-invert max-w-none">
       <script
···
         suppressHydrationWarning
         // biome-ignore lint/security/noDangerouslySetInnerHtml: <explanation>
         dangerouslySetInnerHTML={{
-          __html: JSON.stringify({
-            "@context": "https://schema.org",
-            "@type": "BlogPosting",
-            headline: post.metadata.title,
-            datePublished: post.metadata.publishedAt,
-            dateModified: post.metadata.publishedAt,
-            description: post.metadata.description,
-            image: post.metadata.image
-              ? `${baseUrl}${post.metadata.image}`
-              : `/api/og?title=${encodeURIComponent(
-                  post.metadata.title,
-                )}&description=${encodeURIComponent(
-                  post.metadata.description,
-                )}&category=${encodeURIComponent(post.metadata.category)}`,
-            url: `${baseUrl}/changelog/${post.slug}`,
-            author: {
-              "@type": "Person",
-              name: post.metadata.author,
-            },
-          }),
+          __html: JSON.stringify(jsonLDBlog).replace(/</g, "\\u003c"),
         }}
       />
       <h1>{post.metadata.title}</h1>

apps/web/src/app/(landing)/changelog/category/[slug]/page.tsx

···
 import type { Metadata } from "next";
 
 const TITLE = "Changelog Category";
-const DESCRIPTION = "All the latest changes and updates to OpenStatus.";
+const DESCRIPTION = "All the latest changes and updates to openstatus.";
 
 export const metadata: Metadata = {
   ...defaultMetadata,

apps/web/src/app/(landing)/changelog/page.tsx

···
 import { ContentList } from "../content-list";
 
 const TITLE = "Changelog";
-const DESCRIPTION = "All the latest changes and updates to OpenStatus.";
+const DESCRIPTION = "All the latest changes and updates to openstatus.";
 
 export const metadata: Metadata = {
   ...defaultMetadata,

apps/web/src/app/(landing)/report-template/[slug]/page.tsx

···
+import { getJsonLDBlogPosting, getPageMetadata } from "@/app/shared-metadata";
+import { CustomMDX } from "@/content/mdx";
+import { formatDate, getReportTemplates } from "@/content/utils";
+import { getAuthor } from "@/data/author";
+import type { Metadata } from "next";
+import Image from "next/image";
+import { notFound } from "next/navigation";
+import type { BlogPosting, WithContext } from "schema-dts";
+import { ContentPagination } from "../../content-pagination";
+
+export const dynamicParams = false;
+
+export async function generateStaticParams() {
+  const posts = getReportTemplates();
+
+  return posts.map((post) => ({
+    slug: post.slug,
+  }));
+}
+
+export async function generateMetadata({
+  params,
+}: {
+  params: Promise<{ slug: string }>;
+}): Promise<Metadata | undefined> {
+  const { slug } = await params;
+  const post = getReportTemplates().find((post) => post.slug === slug);
+  if (!post) {
+    return;
+  }
+
+  const metadata = getPageMetadata(post, "report-template");
+
+  return metadata;
+}
+
+export default async function ReportTemplate({
+  params,
+}: {
+  params: Promise<{ slug: string }>;
+}) {
+  const { slug } = await params;
+  const posts = getReportTemplates().sort(
+    (a, b) =>
+      b.metadata.publishedAt.getTime() - a.metadata.publishedAt.getTime(),
+  );
+  const postIndex = posts.findIndex((post) => post.slug === slug);
+  const post = posts[postIndex];
+  const previousPost = posts[postIndex - 1];
+  const nextPost = posts[postIndex + 1];
+
+  if (!post) {
+    notFound();
+  }
+
+  const jsonLDBlog: WithContext<BlogPosting> = getJsonLDBlogPosting(
+    post,
+    "report-template",
+  );
+
+  return (
+    <section className="prose dark:prose-invert max-w-none">
+      <script
+        type="application/ld+json"
+        suppressHydrationWarning
+        // biome-ignore lint/security/noDangerouslySetInnerHtml: <explanation>
+        dangerouslySetInnerHTML={{
+          __html: JSON.stringify(jsonLDBlog).replace(/</g, "\\u003c"),
+        }}
+      />
+      <h1>{post.metadata.title}</h1>
+      <p className="flex items-center gap-2.5 divide-x divide-border text-muted-foreground">
+        {formatDate(post.metadata.publishedAt)} | by{" "}
+        <Author author={post.metadata.author} /> | [{post.metadata.category}]
+      </p>
+      {post.metadata.image ? (
+        <div className="relative aspect-video w-full overflow-hidden border border-border">
+          <Image
+            src={post.metadata.image}
+            alt={post.metadata.title}
+            fill
+            className="object-contain"
+          />
+        </div>
+      ) : null}
+      <CustomMDX source={post.content} />
+      <ContentPagination
+        previousPost={previousPost}
+        nextPost={nextPost}
+        prefix="/report-template"
+      />
+    </section>
+  );
+}
+
+function Author({ author }: { author: string }) {
+  const authorData = getAuthor(author);
+  if (typeof authorData === "string") {
+    return author;
+  }
+
+  return (
+    <a href={authorData.url} target="_blank" rel="noopener noreferrer">
+      {authorData.name}
+    </a>
+  );
+}

apps/web/src/app/(landing)/report-template/category/[slug]/page.tsx

···
+import { ContentCategory } from "@/app/(landing)/content-category";
+import { ContentList } from "@/app/(landing)/content-list";
+import {
+  defaultMetadata,
+  ogMetadata,
+  twitterMetadata,
+} from "@/app/shared-metadata";
+import { getReportTemplates } from "@/content/utils";
+import type { Metadata } from "next";
+
+const TITLE = "Report Template Category";
+const DESCRIPTION = "All the latest templates from openstatus.";
+
+export const metadata: Metadata = {
+  ...defaultMetadata,
+  title: TITLE,
+  description: DESCRIPTION,
+  openGraph: {
+    ...ogMetadata,
+    title: TITLE,
+    description: DESCRIPTION,
+  },
+  twitter: {
+    ...twitterMetadata,
+    title: TITLE,
+    description: DESCRIPTION,
+    images: [`/api/og?title=${TITLE}&description=${DESCRIPTION}`],
+  },
+};
+
+export const dynamicParams = false;
+
+export async function generateStaticParams() {
+  const posts = getReportTemplates();
+  const categories = [...new Set(posts.map((post) => post.metadata.category))];
+
+  return categories.map((category) => ({
+    slug: category.toLowerCase(),
+  }));
+}
+
+export default async function ReportTemplateCategoryPage({
+  params,
+}: {
+  params: Promise<{ slug: string }>;
+}) {
+  const { slug } = await params;
+  const allReportTemplates = getReportTemplates();
+  const filteredReportTemplates = allReportTemplates.filter(
+    (post) => post.metadata.category.toLowerCase() === slug.toLowerCase(),
+  );
+
+  return (
+    <div className="prose dark:prose-invert max-w-none">
+      <h1 className="capitalize">Report Template | {slug}</h1>
+      <ContentCategory data={allReportTemplates} prefix="/report-template" />
+      <ContentList data={filteredReportTemplates} prefix="/report-template" />
+    </div>
+  );
+}

apps/web/src/app/(landing)/report-template/page.tsx

···
+import { defaultMetadata, ogMetadata } from "@/app/shared-metadata";
+import { twitterMetadata } from "@/app/shared-metadata";
+import { getReportTemplates } from "@/content/utils";
+import type { Metadata } from "next";
+import { ContentCategory } from "../content-category";
+import { ContentList } from "../content-list";
+
+const TITLE = "Report Template";
+const DESCRIPTION = "All the latest templates from openstatus.";
+
+export const metadata: Metadata = {
+  ...defaultMetadata,
+  title: TITLE,
+  description: DESCRIPTION,
+  openGraph: {
+    ...ogMetadata,
+    title: TITLE,
+    description: DESCRIPTION,
+  },
+  twitter: {
+    ...twitterMetadata,
+    title: TITLE,
+    description: DESCRIPTION,
+    images: [`/api/og?title=${TITLE}&description=${DESCRIPTION}`],
+  },
+};
+
+export default function ReportTemplateListPage() {
+  const allReportTemplates = getReportTemplates();
+  return (
+    <div className="prose dark:prose-invert max-w-none">
+      <h1>Report Templates</h1>
+      <ContentCategory data={allReportTemplates} prefix="/report-template" />
+      <ContentList
+        data={allReportTemplates}
+        prefix="/report-template"
+        withCategory
+      />
+    </div>
+  );
+}

apps/web/src/app/shared-metadata.ts

···
   openGraph: ogMetadata,
 };
 
-export const getPageMetadata = (page: MDXData): Metadata => {
+export const getPageMetadata = (page: MDXData, basePath?: string): Metadata => {
   const { slug, metadata } = page;
   const { title, description, category, publishedAt } = metadata;
 
···
   )}&description=${encodeURIComponent(
     description,
   )}&category=${encodeURIComponent(category)}`;
+
+  const url = basePath
+    ? `${BASE_URL}/${basePath}/${slug}`
+    : `${BASE_URL}/${slug}`;
 
   return {
     title,
···
       description,
       type: "article",
       publishedTime: publishedAt.toISOString(),
-      url: `${BASE_URL}/changelog/${slug}`,
+      url,
       images: [
         {
           url: ogImage,
···
 
 export const getJsonLDBlogPosting = (
   post: MDXData,
+  basePath: string,
 ): WithContext<BlogPosting> => {
   return {
     "@context": "https://schema.org",
···
         )}&description=${encodeURIComponent(
           post.metadata.description,
         )}&category=${encodeURIComponent(post.metadata.category)}`,
-    url: `${BASE_URL}/blog/${post.slug}`,
+    url: `${BASE_URL}/${basePath}/${post.slug}`,
     author: {
       "@type": "Person",
       name: post.metadata.author,

apps/web/src/content/copy-button.tsx

···
 export function CopyButton({
   className,
   copyText,
+  buttonText = "copy",
+  copiedText = "copied",
   ...props
-}: React.ComponentProps<typeof Button> & { copyText: string }) {
+}: React.ComponentProps<typeof Button> & {
+  copyText: string;
+  buttonText?: string;
+  copiedText?: string;
+}) {
   const { copy, isCopied } = useCopyToClipboard();
 
   return (
···
       onClick={() => copy(copyText, { withToast: true })}
       {...props}
     >
-      {isCopied ? "[link copied]" : "[copy link]"}
+      {isCopied ? `[${copiedText}]` : `[${buttonText}]`}
     </Button>
   );
 }

apps/web/src/content/pages/report-template/api-service-disruption.mdx

···
+---
+title: "API Service Disruption Template"
+description: "Professional template for communicating API outages and third-party service failures to your users."
+author: "OpenStatus"
+publishedAt: "2026-01-19"
+category: "infrastructure"
+---
+
+Use this template when your API or third-party service provider is experiencing issues. Based on real-world examples from companies like Vercel, Stripe, and GitHub.
+
+## When to Use This Template
+
+- Third-party API failures
+- Elevated API error rates
+- Service provider outages
+- Integration connectivity issues
+
+## Template Messages
+
+### Investigating
+
+We are currently experiencing issues with our third-party API provider. Our team is actively investigating and working with the provider to restore normal service.
+
+We apologize for the inconvenience and will provide updates as we learn more.
+
+### Identified
+
+We have confirmed the issue is with our third-party provider's infrastructure. They are working on a fix and we are monitoring their progress.
+
+### Monitoring
+
+A fix has been deployed. We are monitoring service health and will confirm full restoration shortly.
+
+### Resolved
+
+The service has been fully restored. All API operations are back to normal. We apologize for the disruption.
+
+## Real-World Examples
+
+### Vercel: "Elevated error rates across new deployments and Vercel API"
+
+**Context**: Build failures and deployment issues affecting multiple systems
+**Duration**: ~32 minutes
+**Impact**: New deployments and API calls
+
+This incident title demonstrates clear scope communication - users immediately understood both the severity ("elevated error rates") and which systems were affected.
+
+### GitHub: "Configuration error during a model update"
+
+**Context**: Copilot service degradation
+**Duration**: ~1.5 hours
+**Impact**: 18% average error rate, peaking at 100%
+
+GitHub's approach included specific metrics and root cause transparency, helping technical users understand the scope and nature of the issue.
+
+### Stripe: Payment Method Maintenance
+
+**Context**: Scheduled maintenance for payment providers
+**Approach**: Proactive communication with disclaimers about third-party information
+
+Stripe consistently provides context about the source of information and sets clear expectations about accuracy.
+
+## Tips for Using This Template
+
+1. **Be specific about the provider** if you can share that information
+2. **Include timeframes** when you have them (e.g., "Expected resolution: 30 minutes")
+3. **Add metrics** if you're comfortable sharing them (e.g., "affecting 5% of requests")
+4. **Acknowledge impact** - users appreciate transparency about what's affected
+5. **Follow up after resolution** with any lessons learned or preventative measures
+
+## Customization Ideas
+
+- Add your specific API names (e.g., "Payment API" instead of generic "API")
+- Include workaround instructions if available
+- Link to status dashboard or real-time monitoring
+- Add contact information for urgent support needs

apps/web/src/content/pages/report-template/database-performance-degradation.mdx

···
+---
+title: "Database Performance Degradation Template"
+description: "Technical template for communicating database latency and performance issues to your engineering-focused audience."
+author: "OpenStatus"
+publishedAt: "2026-01-19"
+category: "performance"
+---
+
+Use this template when experiencing database performance issues, elevated latency, or query slowdowns. Ideal for engineering teams and technical stakeholders.
+
+## When to Use This Template
+
+- Elevated database latency
+- Slow query performance
+- Connection pool exhaustion
+- Database infrastructure issues
+
+## Template Messages
+
+### Investigating
+
+We are experiencing elevated database latency affecting some features. Users may experience slower response times.
+
+Our database team is actively investigating and working to restore normal performance levels.
+
+### Identified
+
+We have identified the root cause. Our team is implementing a fix.
+
+### Monitoring
+
+Database performance improvements have been deployed. Latency is returning to normal levels. We are continuing to monitor.
+
+### Resolved
+
+Database performance has been fully restored. All queries are executing at normal speeds.
+
+## Real-World Examples
+
+### GitHub: "Infrastructure update to data stores"
+
+**Context**: Data store infrastructure changes
+**Duration**: ~1.5 hours
+**Impact**: 1.8% combined failure rate, peaking at 10%
+
+**What they did well**:
+- Quantified impact with specific percentages
+- Identified multiple affected services
+- Committed to post-incident RCA (Root Cause Analysis)
+- Provided precise UTC timestamps
+
+**Sample messaging**: "Infrastructure update to data stores caused 1.8% combined failure rate, peaking at 10% across multiple services Jan 15, 16:40-18:20 UTC."
+
+### Fly.io: "Network instability in IAD region"
+
+**Context**: Regional infrastructure issue
+**Approach**: Geographic specificity
+
+**What they did well**:
+- Identified specific region (IAD = Ashburn, Virginia)
+- Focused on infrastructure layer
+- Technical but clear naming
+
+This demonstrates the value of being specific about location when database issues are region-specific.
+
+## Tips for Technical Communication
+
+1. **Include specific metrics** when you have them (p95 latency, error rates, query times)
+2. **Name the layer** - application, database, network, storage
+3. **Be technical if your audience is technical** - don't oversimplify for engineers
+4. **Quantify impact** - "affecting 2% of queries" is better than "some users"
+5. **Share root cause** when resolved - technical teams appreciate learning
+
+## Customization Ideas
+
+For **developer audiences**:
+```
+We are experiencing elevated p95 latency (2.5s vs normal 150ms)
+on write operations to our primary PostgreSQL cluster.
+
+Root cause: Connection pool exhaustion due to long-running
+transactions from the reporting service.
+
+Mitigation: Killed long-running queries, increased pool size
+from 100 to 150 connections, added query timeouts.
+```
+
+For **general users**:
+```
+We are experiencing slower than normal response times for some
+features. Our team is working to resolve this quickly.
+```
+
+## Warning Signs to Monitor
+
+Watch for these indicators that might trigger using this template:
+- P95 latency > 2x normal
+- Error rate > 1%
+- Connection timeouts
+- User reports of slowness
+- Database monitoring alerts

apps/web/src/content/pages/report-template/deployment-rollback.mdx

···
+---
+title: "Deployment Rollback Template"
+description: "Template for communicating deployment failures and rollback procedures during service disruptions."
+author: "OpenStatus"
+publishedAt: "2026-01-19"
+category: "deployment"
+---
+
+Use this template when a deployment causes issues and requires rolling back to a previous version. Communicates the issue, mitigation, and resolution clearly.
+
+## When to Use This Template
+
+- Deployment causes service errors
+- New release breaking existing functionality
+- Configuration changes causing issues
+- Need to roll back to previous version
+
+## Template Messages
+
+### Investigating
+
+We encountered an issue during a scheduled deployment and have initiated a rollback to restore service stability.
+
+We apologize for the disruption and are working to complete the rollback as quickly as possible.
+
+### Identified
+
+The deployment issue has been identified. We are completing the rollback to the previous stable version.
+
+### Monitoring
+
+The rollback has been completed successfully. We are monitoring system stability to ensure all services are functioning normally.
+
+### Resolved
+
+All services have been restored to normal operation. The deployment issue has been resolved and we will investigate the root cause.
+
+## Real-World Examples
+
+### Vercel: "Elevated error rates across new deployments"
+
+**Context**: Build system changes affecting deployments
+**Duration**: ~32 minutes
+**Impact**: New deployments and builds failing
+
+**Communication approach**:
+- Clear about what was affected ("new deployments")
+- Specific about the problem ("elevated error rates")
+- Quick resolution time communicated
+
+### GitHub: "Configuration error during a model update"
+
+**Context**: Copilot model deployment issue
+**Duration**: ~1.5 hours
+**Impact**: 18% error rate on average, spiking to 100%
+
+**What worked**:
+- Transparent about the cause ("configuration error")
+- Quantified impact (error rates)
+- Showed progression: investigation → rollback → recovery monitoring
+- Committed to improvement
+
+**Sample update progression**:
+1. "We're investigating reports of Copilot failures"
+2. "Configuration error identified during model update. Rolling back."
+3. "Rollback complete. Monitoring for full recovery."
+4. "Fully resolved. Error rates back to normal. RCA in progress."
+
+## Best Practices
+
+### During Rollback
+
+**Do**:
+- ✅ Announce the rollback immediately
+- ✅ Set expectations on timeline if known
+- ✅ Acknowledge the user impact
+- ✅ Monitor closely during rollback
+
+**Don't**:
+- ❌ Wait until rollback is complete to communicate
+- ❌ Over-promise on fix timing
+- ❌ Skip the post-incident analysis
+
+### After Resolution
+
+Always include:
+1. Confirmation that rollback succeeded
+2. Current system status
+3. Next steps (investigation, new deployment plan)
+4. Preventative measures (if ready to share)
+
+## Communication Patterns
+
+### For User-Facing Services
+
+```
+We've rolled back a deployment that was causing issues with [feature].
+Service is now restored. We're investigating to prevent this in the future.
+```
+
+### For API Services
+
+```
+A recent deployment caused elevated error rates in our API.
+We've rolled back to the previous version and error rates
+have returned to normal. All endpoints are functioning correctly.
+```
+
+### For Internal Tools
+
+```
+Deployment to production caused issues with [system]. Rolled back
+to previous version. Services restored. Post-mortem scheduled for
+tomorrow to identify root cause and improve deployment process.
+```
+
+## Preventative Context
+
+After resolution, consider adding context about prevention:
+
+> "We're improving our deployment process to catch issues like this
+> before they reach production. This includes enhanced pre-deployment
+> testing and gradual rollout procedures."
+
+## Timing Guidance
+
+- **0-5 minutes**: Initial notification of issue and rollback decision
+- **5-20 minutes**: Rollback in progress updates
+- **20-30 minutes**: Rollback complete, monitoring
+- **30-60 minutes**: Confirmed resolution
+- **24 hours later**: Root cause analysis summary (optional)
+
+## Related Templates
+
+- Use **API Service Disruption** if rollback affects external integrations
+- Use **Database Performance** if rollback impacts database operations
+- Use **Security Incident** if deployment exposed security issues

apps/web/src/content/pages/report-template/feature-degradation.mdx

···
+---
+title: "Feature Degradation Template"
+description: "Template for communicating partial service degradation where some features are impacted but the service remains available."
+author: "OpenStatus"
+publishedAt: "2026-01-19"
+category: "performance"
+---
+
+Use this template when specific features are degraded or unavailable, but the core service remains operational. Helps users understand what's working and what isn't.
+
+## When to Use This Template
+
+- Specific feature experiencing errors
+- Elevated latency for particular operations
+- Partial functionality unavailable
+- Non-critical systems impaired
+
+## Template Messages
+
+### Investigating
+
+We are experiencing issues with [Feature Name]. The core service remains available, but this specific feature may not work as expected.
+
+Our team is actively investigating and working to restore full functionality.
+
+### Identified
+
+We have identified the cause of the [Feature Name] degradation. Our team is implementing a fix.
+
+### Monitoring
+
+[Feature Name] has been restored. We are monitoring to ensure stable operation.
+
+### Resolved
+
+[Feature Name] is now fully operational. All features are working normally.
+
+## Real-World Examples
+
+### Notion: "Operations such as duplicate a page or move a block"
+
+**Context**: Specific operations failing while rest of service worked
+**Duration**: ~4 hours
+**Impact**: Users could read/edit but not duplicate or move content
+
+**What worked**:
+- Specific about which operations were affected
+- Clear that core functionality (reading, editing) still worked
+- Precise timestamps in user's timezone (PST)
+
+**Sample progression**:
+```
+12:10pm PST - Investigating
+"We are experiencing an incident that affects operations such as
+duplicate a page or move a block."
+
+2:30pm PST - Identified
+"We've identified the issue and are implementing a fix. Most
+operations continue to work normally."
+
+4:09pm PST - Resolved
+"All operations have been restored. The issue has been fully resolved."
+```
+
+### Notion: "Exporting pages remains in a loading state"
+
+**Context**: Export feature stuck, but rest of service worked
+**Approach**: Clear about single feature impact
+
+**Why it worked**:
+- Users knew exactly what was broken
+- Clear that it wasn't a full outage
+- No operational downtime reported for core features
+
+### GitHub: "Some models missing in Copilot"
+
+**Context**: Specific AI models unavailable
+**Duration**: ~2.5 hours
+**Impact**: Claude Opus 4.5 and GPT-5.2 inaccessible; other models worked
+
+**Communication breakdown**:
+```
+Investigating:
+"Some users unable to access premium AI models in GitHub Copilot"
+
+Identified:
+"Misconfiguration marking Claude Opus 4.5 and GPT-5.2 as inaccessible.
+Other models functioning normally. Deploying configuration fix."
+
+Resolved:
+"All models now accessible. Configuration has been corrected and
+validated across all regions."
+```
+
+**Why it worked**:
+- Specific model names (users could check if they were affected)
+- Clear that other models still worked
+- Technical but not overly complex
+
+## Clear Scope Communication
+
+### ✅ Good Examples
+
+**Specific and clear**:
+```
+The file upload feature is currently unavailable. All other features,
+including viewing, editing, and sharing, are working normally.
+```
+
+**With workaround**:
+```
+Export functionality is temporarily degraded. Exports may take 2-3x
+longer than usual. Viewing and editing are unaffected.
+
+Workaround: For faster exports, try exporting smaller sections
+individually.
+```
+
+**With context**:
+```
+Search is experiencing elevated latency (5-10 seconds vs normal <1s).
+We're working on a fix. All other features operating normally.
+```
+
+### ❌ Vague Examples
+
+```
+"Some features might not work"
+"Experiencing issues"
+"Partial service degradation"
+"Some users affected"
+```
+
+## Feature Impact Matrix
+
+Help users quickly understand what works and what doesn't:
+
+### Example 1: Export Feature Down
+```
+Current Status:
+
+Working:
+✓ View documents
+✓ Edit documents
+✓ Share with team
+✓ Comments and collaboration
+✓ Search
+
+Not Working:
+✗ PDF export
+✗ CSV download
+✗ Bulk export
+
+We're working to restore export functionality.
+```
+
+### Example 2: Upload Feature Degraded
+```
+Current Status:
+
+Working Normally:
+✓ View files
+✓ Download files
+✓ Share links
+✓ Delete files
+
+Degraded:
+⚠️ File uploads (50% success rate, retrying usually works)
+⚠️ Drag-and-drop (use upload button instead)
+
+We're investigating the upload issues.
+```
+
+## Communication by Feature Type
+
+### Core Features Degraded
+
+When important features fail, be very clear about impact:
+
+```
+🔴 Payment Processing Degraded
+
+Impact: High - payments may fail or experience delays
+
+Status: We're experiencing elevated error rates (10%) on payment
+processing. Most transactions are succeeding, but some may fail.
+
+Action: If your payment fails, please wait 5 minutes and retry.
+We're working on a fix.
+
+Other features: Account management, viewing history, and settings
+all working normally.
+```
+
+### Secondary Features Down
+
+When nice-to-have features fail:
+
+```
+🟡 Analytics Dashboard Unavailable
+
+Impact: Low - core product features unaffected
+
+Status: The analytics dashboard is temporarily unavailable due to
+a database issue. All product features continue working normally.
+
+Your data is safe and being collected. Analytics will be updated
+once the dashboard is restored.
+```
+
+### Batch/Background Features
+
+When background processes are affected:
+
+```
+⚠️ Report Generation Delayed
+
+Impact: Reports scheduled in the last hour will be delayed.
+
+Status: The background job processor is experiencing issues. Reports
+will still generate, but may take 2-4 hours instead of the usual
+15 minutes.
+
+If you need a report urgently, please contact [e-mail]
+and we can prioritize it.
+```
+
+## User Action Guidance
+
+### No Action Needed
+```
+The issue is on our end. No action is required from you. We'll
+update this status when resolved.
+```
+
+### Retry Recommended
+```
+If you encounter an error, please wait 30 seconds and try again.
+Most operations succeed on the second attempt.
+```
+
+### Workaround Available
+```
+While we work on a fix, you can use this workaround:
+1. Go to Settings > Export
+2. Select "Legacy Export Mode"
+3. Your export should complete successfully
+
+We'll notify you when the standard export is restored.
+```
+
+### Avoid Feature Temporarily
+```
+We recommend avoiding [feature] until this is resolved to prevent
+data sync issues. We'll send an all-clear when it's safe to use again.
+```
+
+## Timing and SLA Context
+
+### When degradation exceeds SLA:
+
+```
+Update: This degradation has exceeded our 99.9% uptime SLA for the
+month. Affected customers will receive automatic service credits as
+per our SLA terms. No action needed from you.
+```
+
+### When approaching SLA:
+
+```
+We're aware this degradation is approaching our SLA threshold. We're
+treating this as high priority and have additional engineers engaged.
+```
+
+## Progressive Updates
+
+### Initial (Minute 0)
+```
+We're investigating reports of [feature] not working correctly.
+Some users may experience errors. Core functionality unaffected.
+```
+
+### Update 1 (Minute 15)
+```
+We've confirmed [feature] is experiencing issues. Approximately
+20% of requests are failing. We're investigating the cause.
+```
+
+### Update 2 (Minute 30)
+```
+Root cause identified: database connection timeout on [specific service].
+Implementing a fix now. Estimated resolution: 15 minutes.
+```
+
+### Update 3 (Minute 45)
+```
+Fix deployed. [Feature] error rate has dropped from 20% to 2%.
+Monitoring for full recovery.
+```
+
+### Final (Minute 60)
+```
+[Feature] is fully restored. Error rates back to normal (< 0.1%).
+No user action required. Thank you for your patience.
+```
+
+## Partial vs. Complete Degradation
+
+### Partial (50% working)
+```
+[Feature] is partially degraded. About half of requests are succeeding.
+If you receive an error, try again in a few seconds - you'll likely
+succeed on the second or third attempt.
+```
+
+### Severe (90% failing)
+```
+[Feature] is severely degraded with most requests failing. We recommend
+waiting until this is resolved rather than retrying repeatedly.
+
+ETA for fix: 30 minutes
+```
+
+### Complete (100% down)
+```
+[Feature] is currently unavailable. We've identified the issue and
+are working on a fix.
+
+Estimated restoration: 15 minutes
+We'll notify you as soon as it's back.
+```
+
+## Post-Resolution Analysis
+
+After resolving, explain what happened:
+
+```
+[Feature] has been fully restored.
+
+What happened: A configuration change caused connection timeouts
+to the [service] backend.
+
+Resolution: We rolled back the configuration change and implemented
+additional connection monitoring.
+
+Prevention: We're adding pre-deployment validation for configuration
+changes to catch issues like this before they reach production.
+
+Thank you for your patience while we resolved this issue.
+```
+
+## Related Templates
+
+- Use **API Service Disruption** if the degraded feature is API-related
+- Use **Database Performance** if degradation is caused by database issues
+- Use **Network Connectivity** if some regions can't access the feature
+- Use **Deployment Rollback** if a recent deployment caused the degradation

apps/web/src/content/pages/report-template/network-connectivity-issues.mdx

···
+---
+title: "Network Connectivity Issues Template"
+description: "Template for communicating network outages, CDN problems, and regional connectivity issues to affected users."
+author: "OpenStatus"
+publishedAt: "2026-01-19"
+category: "infrastructure"
+---
+
+Use this template when experiencing network-related issues affecting user connectivity, including CDN problems, regional outages, or ISP issues.
+
+## When to Use This Template
+
+- Regional network outages
+- CDN degradation or failures
+- DNS resolution problems
+- ISP-specific connectivity issues
+- DDoS mitigation impacts
+
+## Template Messages
+
+### Investigating
+
+We are aware of connectivity issues affecting some users. The issue appears to be network-related and we are investigating the root cause.
+
+Our team is working to restore connectivity as quickly as possible.
+
+### Identified
+
+We have identified the cause of the connectivity issues. Our team is working with our network provider to implement a fix.
+
+### Monitoring
+
+Network connectivity has been restored. We are monitoring the situation to ensure stability across all regions.
+
+### Resolved
+
+The connectivity issues have been fully resolved. All users should now have normal access to our services.
+
+## Real-World Examples
+
+### Fly.io: "Network instability in IAD region"
+
+**Context**: Regional infrastructure problem
+**Location**: IAD (Ashburn, Virginia)
+**Approach**: Geographic specificity
+
+**What they did well**:
+- Named the specific region affected
+- Used technical but clear naming ("network instability")
+- Focused on infrastructure layer vs vague "connectivity problems"
+
+**Why it worked**: Users in that region immediately knew they were affected, while users elsewhere knew they weren't experiencing issues.
+
+### GitHub: Infrastructure with Specific Impact Areas
+
+**Context**: Multi-service infrastructure issues
+**Approach**: Service-by-service breakdown
+
+**Sample structure**:
+```
+We're experiencing connectivity issues affecting:
+- Issues and Pull Requests: 10% error rate
+- GitHub Actions: 5% job failures
+- API: Elevated latency
+
+Other services operating normally.
+```
+
+**Why it worked**: Users could quickly assess if their workflow was affected.
+
+## Geographic Specificity Best Practices
+
+### Be Specific About Location
+
+✅ Good:
+- "Users in Europe experiencing connectivity issues"
+- "Network problems in AWS us-east-1 region"
+- "CDN degradation affecting Asia-Pacific"
+
+❌ Vague:
+- "Some users having problems"
+- "Network issues"
+- "Connectivity degraded"
+
+### Example: Regional Communication
+
+**For global outage**:
+```
+We're experiencing network connectivity issues affecting users globally.
+Our network provider is investigating. We'll provide updates every 30 minutes.
+```
+
+**For regional outage**:
+```
+We're aware of connectivity issues affecting users in the EU region.
+This appears to be related to our CDN provider. US and Asia-Pacific
+regions are operating normally.
+```
+
+**For ISP-specific**:
+```
+We're receiving reports of connectivity issues from users on [ISP Name].
+We're working with the ISP to resolve. Users on other networks should
+not be affected.
+```
+
+## CDN-Specific Communication
+
+When CDN issues affect your service:
+
+### During Investigation
+```
+We're experiencing degraded performance due to issues with our CDN provider.
+Users may see slower load times or intermittent connectivity. We're working
+with [CDN Provider] to resolve this quickly.
+```
+
+### When Switching to Backup
+```
+We've temporarily switched traffic to our backup CDN to restore performance.
+You may experience brief disruptions during this transition.
+```
+
+### After Resolution
+```
+CDN performance has been fully restored. All traffic has been returned to
+our primary provider, and we're monitoring closely for any recurring issues.
+```
+
+## DNS Issues Communication
+
+### Initial Report
+```
+We're aware of DNS resolution failures affecting access to [service].
+Some users may receive "site cannot be reached" errors. We're working
+with our DNS provider to resolve this immediately.
+
+Workaround: If you have our service's IP address cached, you can
+still access via direct IP.
+```
+
+### Resolution
+```
+DNS resolution has been restored. Changes may take 5-15 minutes to
+propagate globally due to DNS caching. If you still can't access
+the service, try clearing your DNS cache or waiting a few minutes.
+```
+
+## Providing Workarounds
+
+Always include workarounds when possible:
+
+### Example 1: CDN Issues
+```
+While we work on the connectivity issue, you can access the service
+directly via: https://direct.yourservice.com (bypasses CDN)
+```
+
+### Example 2: Regional Issues
+```
+Users in affected regions can temporarily use our US endpoint:
+https://us.yourservice.com
+```
+
+### Example 3: API Connectivity
+```
+If experiencing timeouts, try reducing request rate or adding retry
+logic with exponential backoff. We'll send an all-clear when issues
+are fully resolved.
+```
+
+## DDoS Mitigation Communication
+
+### During Active Mitigation
+```
+We're currently mitigating a distributed denial-of-service (DDoS) attack.
+Some users may experience:
+- Slower response times
+- CAPTCHA challenges
+- Temporary access blocks
+
+These are protective measures. Your data and account remain secure.
+```
+
+### Post-Mitigation
+```
+The DDoS attack has been successfully mitigated. All protective measures
+remain in place. Service performance has returned to normal.
+```
+
+## Timing Expectations
+
+Set clear expectations about updates:
+
+```
+We're investigating network connectivity issues in the APAC region.
+We'll provide updates every 15 minutes until resolved.
+
+Next update: 10:15 UTC
+```
+
+Then honor that commitment:
+
+```
+[10:15 UTC Update] Still investigating. Network provider has identified
+the issue and is implementing a fix. We expect resolution within 30 minutes.
+
+Next update: 10:30 UTC or sooner if resolved.
+```
+
+## Multi-Region Status Example
+
+For services with multiple regions:
+
+```
+Current Status:
+- 🔴 EU-West: Major connectivity issues
+- 🟡 US-East: Minor latency increases
+- 🟢 US-West: Operating normally
+- 🟢 Asia-Pacific: Operating normally
+
+We're prioritizing restoration of EU-West and monitoring other regions closely.
+```
+
+## Third-Party Provider Communication
+
+When the issue is with a third-party:
+
+✅ **Be transparent but professional**:
+```
+We're experiencing connectivity issues due to problems with our CDN
+provider, Cloudflare. They are working on a fix. We're monitoring
+their status page and will update you as we learn more.
+```
+
+❌ **Don't blame or criticize**:
+```
+Cloudflare is down again! Not our fault! 🤷
+```
+
+## Follow-Up After Resolution
+
+### Short-Term (Same Day)
+```
+Connectivity has been fully restored across all regions. We're continuing
+to monitor for any recurring issues.
+```
+
+### Medium-Term (Next Day)
+```
+Yesterday's connectivity issues were caused by [root cause]. We're working
+with our network provider to implement additional safeguards to prevent
+recurrence.
+```
+
+## Related Templates
+
+- Use **API Service Disruption** if network issues primarily affect API calls
+- Use **Database Performance** if network latency affects database connections
+- Use **Security Incident** if connectivity issues are attack-related

apps/web/src/content/pages/report-template/scheduled-maintenance.mdx

···
+---
+title: "Scheduled Maintenance Template"
+description: "Proactive template for communicating planned maintenance windows, upgrades, and scheduled downtime to users."
+author: "OpenStatus"
+publishedAt: "2026-01-19"
+category: "maintenance"
+---
+
+Use this template for planned maintenance, infrastructure upgrades, or scheduled downtime. Proactive communication builds trust and reduces support burden.
+
+## When to Use This Template
+
+- Database upgrades
+- Infrastructure migrations
+- Security patch deployments
+- Third-party provider maintenance
+- Performance optimization work
+
+## Template Messages
+
+### Scheduled (Advance Notice)
+
+We have scheduled maintenance for [System Name] on [Date] at [Time] [Timezone].
+
+**Expected Duration**: [Duration]
+**Expected Impact**: [Impact Description]
+
+We will provide updates throughout the maintenance window.
+
+### In Progress
+
+Scheduled maintenance is currently in progress. We expect to complete within the planned window.
+
+**Current Status**: [Brief status]
+**Expected Completion**: [Time]
+
+### Completed
+
+The scheduled maintenance has been completed successfully. All systems are operating normally.
+
+Thank you for your patience during this maintenance window.
+
+## Real-World Examples
+
+### Stripe: Payment Method Maintenance
+
+**Context**: Scheduled maintenance for TWINT payment method
+**Approach**: Clear scheduling with transparency disclaimers
+
+**Sample messaging**:
+```
+TWINT has an upcoming scheduled maintenance.
+
+Note: Stripe retrieves payment method planned maintenance information
+from payment method partners and the information may not be complete,
+accurate, or up to date.
+```
+
+**What worked**:
+- Clear about the service affected (TWINT)
+- Set expectations about information accuracy
+- Consistent disclaimer across all maintenance notices
+
+**Multi-stage updates**:
+1. **Scheduled**: "TWINT has upcoming scheduled maintenance on [date]"
+2. **In Progress**: "Maintenance is currently in progress"
+3. **Completed**: "The scheduled maintenance has been completed"
+
+### Notion: Planned Maintenance Communication
+
+**Approach**: Clear timing with minimal service impact
+
+**Sample structure**:
+```
+Scheduled Maintenance
+Time: Jan 20, 2026 | 2:00 AM - 4:00 AM PST
+Impact: Brief connectivity interruptions expected
+Status: Scheduled
+
+We'll be performing database maintenance during this window.
+Most features will remain available, but you may experience
+brief disruptions.
+```
+
+## Planning Your Maintenance Communication
+
+### 1 Week Before
+```
+📅 Scheduled Maintenance Notice
+
+We'll be performing infrastructure upgrades on [date] at [time].
+
+What: Database migration to improve performance
+When: January 25, 2026 at 02:00 UTC
+Duration: Approximately 2 hours
+Impact: Read-only mode during migration
+
+Add to calendar: [iCal link]
+```
+
+### 24 Hours Before
+```
+⏰ Reminder: Maintenance Tomorrow
+
+This is a reminder that we'll be performing scheduled maintenance
+tomorrow, January 25 at 02:00 UTC (approximately 2 hours).
+
+During this time, the service will be in read-only mode. You'll be
+able to view data but won't be able to make changes.
+
+We recommend completing any urgent work before maintenance begins.
+```
+
+### 1 Hour Before
+```
+🔧 Maintenance Starting Soon
+
+Scheduled maintenance begins in 1 hour (02:00 UTC).
+
+Quick reminders:
+- Service will be in read-only mode
+- Expected duration: 2 hours
+- We'll provide hourly updates
+
+If you have any questions, please contact support before maintenance begins.
+```
+
+### At Start
+```
+🚧 Maintenance In Progress
+
+Scheduled maintenance has started. The service is now in read-only mode.
+
+Progress: Database backup completed ✓
+Next: Begin migration
+Expected completion: 04:00 UTC
+```
+
+### Hourly Updates
+```
+📊 Maintenance Progress Update (Hour 1)
+
+Migration is progressing as planned.
+
+Completed:
+✓ Database backup
+✓ Schema updates
+✓ Data migration (65%)
+
+In progress:
+⏳ Data migration (ongoing)
+
+Still on track for 04:00 UTC completion.
+```
+
+### At Completion
+```
+✅ Maintenance Complete
+
+Scheduled maintenance has been completed successfully!
+
+The service is now fully operational and out of read-only mode.
+All features are available.
+
+Thank you for your patience. You should notice improved performance
+with our upgraded infrastructure.
+```
+
+### If Extended
+```
+⚠️ Maintenance Extended
+
+We're making excellent progress, but the maintenance will take longer
+than expected.
+
+New estimated completion: 05:00 UTC (1 hour extension)
+Reason: Data migration taking longer due to dataset size
+
+The service remains in read-only mode. We'll provide another update
+in 30 minutes.
+```
+
+## Advance Notice Best Practices
+
+### Minimum Notice Periods
+
+- **Minor maintenance** (< 30 min, no downtime): 48 hours notice
+- **Standard maintenance** (1-4 hours, read-only): 1 week notice
+- **Major maintenance** (> 4 hours, full downtime): 2+ weeks notice
+
+### What to Include
+
+✅ **Always include**:
+- Exact date and time (with timezone)
+- Expected duration
+- Impact description
+- What users can/can't do
+- Who to contact with questions
+
+✅ **Nice to have**:
+- Reason for maintenance
+- Expected benefits
+- Calendar file (.ics)
+- Status page link
+- Estimated completion time
+
+❌ **Avoid**:
+- Vague timing ("sometime next week")
+- Unclear impact ("may affect some users")
+- No duration estimate
+- Technical jargon without explanation
+
+## Impact Level Communication
+
+### No Downtime
+```
+Maintenance Window: January 25, 02:00-04:00 UTC
+Impact: None - We'll be performing rolling updates with no service interruption
+Action Required: None
+```
+
+### Read-Only Mode
+```
+Maintenance Window: January 25, 02:00-04:00 UTC
+Impact: Service will be in read-only mode
+What you CAN do: View all data, run reports, access historical information
+What you CAN'T do: Create, update, or delete records
+Action Required: Complete any urgent changes before maintenance
+```
+
+### Full Downtime
+```
+Maintenance Window: January 25, 02:00-04:00 UTC
+Impact: Service will be completely unavailable
+What to expect: You won't be able to access the service at all
+Action Required: Plan accordingly, download any needed data beforehand
+Alternative: [If you have a status page or alternative access method]
+```
+
+### Partial Service Impact
+```
+Maintenance Window: January 25, 02:00-04:00 UTC
+Impact: Partial service degradation
+
+Available:
+✓ Login and authentication
+✓ Data viewing
+✓ API read endpoints
+
+Unavailable:
+✗ File uploads
+✗ Report generation
+✗ Data exports
+✗ Webhook delivery
+```
+
+## Timezone Considerations
+
+Always include multiple timezones for global audiences:
+
+```
+Maintenance scheduled for:
+- 02:00 UTC
+- 6:00 PM PST (Jan 24)
+- 9:00 PM EST (Jan 24)
+- 11:00 AM JST (Jan 25)
+
+Check your timezone: [worldtimebuddy.com link]
+```
+
+Or use relative time:
+```
+Maintenance begins in 24 hours.
+Check your local time: January 25, 02:00 UTC
+```
+
+## Third-Party Maintenance
+
+When a provider schedules maintenance:
+
+```
+Our payment provider, Stripe, has scheduled maintenance for [date].
+
+Impact: Payment processing may be temporarily unavailable
+Duration: Approximately 30 minutes
+Workaround: We'll queue any failed payments and automatically retry
+
+This maintenance is being performed by our payment provider. For more
+information, visit: [provider status page]
+```
+
+## Emergency Maintenance
+
+Sometimes maintenance can't wait:
+
+```
+🚨 Emergency Maintenance Required
+
+We've identified a critical issue that requires immediate maintenance.
+
+Starting: Now (15:00 UTC)
+Expected duration: 30 minutes
+Impact: Service will be unavailable
+
+We apologize for the short notice. This maintenance is necessary to
+prevent potential data issues.
+
+Updates every 10 minutes.
+```
+
+## Benefits Communication
+
+Help users understand the "why":
+
+```
+This maintenance will deliver:
+✓ 3x faster query performance
+✓ 99.99% uptime SLA (up from 99.9%)
+✓ Support for 10x more concurrent users
+✓ Reduced latency for API calls
+
+We appreciate your patience as we improve the service.
+```
+
+## FAQ to Include
+
+Consider adding to your maintenance notice:
+
+**Q: Can I use the service during maintenance?**
+A: The service will be in read-only mode. You can view data but not make changes.
+
+**Q: What if I'm in the middle of something?**
+A: We recommend saving your work before maintenance begins. Any unsaved changes may be lost.
+
+**Q: Will my data be safe?**
+A: Yes, we perform full backups before all maintenance. Your data is secure.
+
+**Q: What if maintenance takes longer?**
+A: We'll provide updates every hour and notify you of any time extensions.
+
+**Q: Can you reschedule?**
+A: This timing was chosen for minimal impact. Please contact support if you have urgent concerns.

apps/web/src/content/pages/report-template/security-incident-response.mdx

···
+---
+title: "Security Incident Response Template"
+description: "Formal template for communicating security issues with professional, reassuring language that maintains user trust."
+author: "OpenStatus"
+publishedAt: "2026-01-19"
+category: "security"
+---
+
+Use this template when investigating or responding to security-related incidents. Maintains professional tone while reassuring users about security measures.
+
+## When to Use This Template
+
+- Potential security vulnerabilities discovered
+- Unauthorized access attempts detected
+- Data exposure concerns
+- Security patch deployments
+- Compliance-related issues
+
+## Template Messages
+
+### Investigating
+
+We are investigating a potential security issue. We take security very seriously and are working with our security team to assess the situation.
+
+We will provide updates as we learn more. For security questions, please contact [e-mail].
+
+### Identified
+
+We have identified the nature of the security issue and are implementing remediation measures.
+
+### Monitoring
+
+Security measures have been implemented. We are monitoring systems to ensure the issue is fully resolved.
+
+### Resolved
+
+The security issue has been resolved. We have taken steps to prevent similar issues in the future.
+
+## Key Principles for Security Communication
+
+### 1. **Be Transparent, But Not Reckless**
+
+Share what you know, but don't provide details that could help attackers:
+
+✅ Good: "We identified unauthorized access attempts to our admin panel"
+❌ Avoid: "Attackers tried SQL injection on /admin/login using parameter X"
+
+### 2. **Reassure Without Minimizing**
+
+✅ Good: "No user data was accessed. We take security seriously and have implemented additional safeguards."
+❌ Avoid: "It's not a big deal, don't worry about it."
+
+### 3. **Provide Clear Next Steps**
+
+Tell users what (if anything) they should do:
+- Change passwords?
+- Review account activity?
+- Update client software?
+- No action needed?
+
+### 4. **Show Competence**
+
+Demonstrate you're handling it professionally:
+- "Working with our security team"
+- "Engaged external security experts"
+- "Following our incident response procedures"
+
+## Real-World Security Communication Examples
+
+### Example 1: Data Access Concern
+
+**Investigating**:
+```
+We are investigating reports of unusual account activity. As a precaution,
+we've temporarily disabled affected accounts and are conducting a thorough
+security audit.
+
+If your account was affected, we will contact you directly via email.
+```
+
+**Resolved**:
+```
+Our investigation is complete. No user data was compromised. The unusual
+activity was caused by automated testing scripts that were misconfigured.
+
+We've implemented additional monitoring to prevent similar false positives
+and improved our alerting to distinguish between legitimate and suspicious
+activity.
+```
+
+### Example 2: Vulnerability Patch
+
+**Investigating**:
+```
+We've been notified of a potential security vulnerability in a third-party
+library we use. We are investigating the impact and preparing a security
+patch.
+
+This appears to be a low-severity issue with no evidence of exploitation,
+but we're treating it with high priority.
+```
+
+**Resolved**:
+```
+We've deployed a security patch addressing the vulnerability. No user data
+was at risk, and we saw no signs of exploitation. All systems have been
+updated and are operating normally.
+```
+
+## Tone Guidelines
+
+### Professional & Calm
+Security incidents can be stressful. Your communication should be:
+- **Measured**: Not panicked or overly casual
+- **Clear**: No jargon or ambiguity
+- **Authoritative**: Demonstrates control and competence
+- **Empathetic**: Acknowledges user concerns
+
+### Example Tone Comparisons
+
+❌ **Too casual**: "Oops, we had a little security hiccup, but it's all good now!"
+
+❌ **Too alarming**: "URGENT: Your data may be compromised! Immediate action required!"
+
+✅ **Just right**: "We've identified and resolved a security issue. No user data was compromised. We've implemented additional safeguards to prevent similar issues."
+
+## Legal & Compliance Considerations
+
+### Include if Required
+
+- **GDPR**: Data breach notifications within 72 hours if personal data affected
+- **CCPA**: Notification if California residents' data compromised
+- **SOC 2**: Incident must be logged and reported per agreements
+- **Industry-specific**: HIPAA (healthcare), PCI DSS (payments), etc.
+
+### Standard Disclaimers
+
+Consider adding:
+```
+This incident has been reported to relevant authorities as required by
+[regulation name]. Affected users will be notified directly via email
+as required by law.
+```
+
+## Security Incident Checklist
+
+Before publishing updates:
+
+- [ ] Verified facts with security team
+- [ ] Removed any tactical details that could help attackers
+- [ ] Confirmed legal/compliance requirements met
+- [ ] Prepared answers to likely follow-up questions
+- [ ] Coordinated with PR/communications team if needed
+- [ ] Set up dedicated [e-mail] contact
+- [ ] Drafted FAQ for support team
+
+## Follow-Up Communication
+
+### Within 24 Hours
+Initial resolution and immediate actions taken
+
+### Within 7 Days
+Preliminary findings and preventative measures
+
+### Within 30 Days (Optional)
+Full post-mortem with technical details (if appropriate)
+
+## Example: Complete Incident Progression
+
+**00:00 - Detection**
+```
+We're investigating reports of unusual login activity. As a precaution,
+we've temporarily increased authentication requirements and are reviewing
+account access logs.
+```
+
+**00:45 - Identification**
+```
+We've identified the cause as compromised API keys from a third-party
+integration. We've revoked the affected keys and are auditing all
+access during the exposure window. No evidence of data access.
+```
+
+**02:00 - Monitoring**
+```
+All compromised keys have been revoked and replaced. We're monitoring
+for any related activity. Additional security measures have been
+deployed to prevent similar issues.
+```
+
+**04:00 - Resolution**
+```
+Incident resolved. Our investigation confirms no user data was accessed.
+We've strengthened our API key rotation procedures and added real-time
+monitoring for unusual API activity.
+
+Users with affected integrations will receive direct communication
+about key rotation requirements.
+```
+
+## When NOT to Use This Template
+
+- System outages unrelated to security → Use appropriate infrastructure template
+- Planned security patches with no active threat → Use maintenance template
+- Minor configuration issues → Use general service disruption template
+
+Only use security incident language when there's an actual security concern to avoid alarm fatigue.

apps/web/src/content/sub-nav.tsx

···
         {segments.map((segment, index) => (
           <Fragment key={segment}>
             <Link href={`/${segments.slice(0, index + 1).join("/")}`}>
-              {segment}
+              {segment.split("-").join(" ")}
             </Link>
             {index < segments.length - 1 ? (
               <span className="text-muted-foreground">{" | "}</span>
···
       </div>
       <CopyButton
         copyText={typeof window !== "undefined" ? window.location.href : ""}
+        buttonText="copy link"
+        copiedText="link copied"
       />
     </div>
   );

apps/web/src/content/utils.ts

···
   );
 }
 
+export function getReportTemplates(): MDXData[] {
+  return getMDXDataFromDir(
+    path.join(process.cwd(), "src", "content", "pages", "report-template"),
+    "/report-template",
+  );
+}
+
 export function getUnrelatedPages(): MDXData[] {
   return getMDXDataFromDir(
     path.join(process.cwd(), "src", "content", "pages", "unrelated"),

apps/web/src/data/content.ts

···
       href: "https://docs.openstatus.dev",
     },
     {
+      label: "Report Templates",
+      href: "/report-template",
+    },
+    {
       label: "External Status",
       href: "/status",
     },