Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
chore: report template content (#1801)
Maximilian Kaske2175ea783b11
diff --git a/apps/web/src/app/(landing)/blog/[slug]/page.tsx b/apps/web/src/app/(landing)/blog/[slug]/page.tsxindex 0434e5949..032168d54 100644--- a/apps/web/src/app/(landing)/blog/[slug]/page.tsx+++ b/apps/web/src/app/(landing)/blog/[slug]/page.tsx@@ -29,7 +29,7 @@ export async function generateMetadata({return;}- const metadata = getPageMetadata(post);+ const metadata = getPageMetadata(post, "blog");return metadata;}@@ -53,7 +53,10 @@ export default async function Blog({notFound();}- const jsonLDBlog: WithContext<BlogPosting> = getJsonLDBlogPosting(post);+ const jsonLDBlog: WithContext<BlogPosting> = getJsonLDBlogPosting(+ post,+ "blog",+ );return (<section className="prose dark:prose-invert max-w-none">diff --git a/apps/web/src/app/(landing)/blog/category/[slug]/page.tsx b/apps/web/src/app/(landing)/blog/category/[slug]/page.tsxindex fe5d12123..21304524b 100644--- a/apps/web/src/app/(landing)/blog/category/[slug]/page.tsx+++ b/apps/web/src/app/(landing)/blog/category/[slug]/page.tsx@@ -9,7 +9,7 @@ import { getBlogPosts } from "@/content/utils";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,diff --git a/apps/web/src/app/(landing)/blog/page.tsx b/apps/web/src/app/(landing)/blog/page.tsxindex 8050e1268..8bfff9243 100644--- a/apps/web/src/app/(landing)/blog/page.tsx+++ b/apps/web/src/app/(landing)/blog/page.tsx@@ -7,7 +7,7 @@ import { ContentCategory } from "../content-category";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,diff --git a/apps/web/src/app/(landing)/changelog/[slug]/page.tsx b/apps/web/src/app/(landing)/changelog/[slug]/page.tsxindex a60719571..37d78358f 100644--- a/apps/web/src/app/(landing)/changelog/[slug]/page.tsx+++ b/apps/web/src/app/(landing)/changelog/[slug]/page.tsx@@ -1,13 +1,12 @@-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;export async function generateStaticParams() {@@ -29,7 +28,7 @@ export async function generateMetadata({return;}- const metadata = getPageMetadata(post);+ const metadata = getPageMetadata(post, "changelog");return metadata;}@@ -53,6 +52,11 @@ export default async function Changelog({notFound();}+ const jsonLDBlog: WithContext<BlogPosting> = getJsonLDBlogPosting(+ post,+ "changelog",+ );+return (<section className="prose dark:prose-invert max-w-none"><script@@ -60,26 +64,7 @@ export default async function Changelog({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>diff --git a/apps/web/src/app/(landing)/changelog/category/[slug]/page.tsx b/apps/web/src/app/(landing)/changelog/category/[slug]/page.tsxindex 719b26105..60843fc4e 100644--- a/apps/web/src/app/(landing)/changelog/category/[slug]/page.tsx+++ b/apps/web/src/app/(landing)/changelog/category/[slug]/page.tsx@@ -9,7 +9,7 @@ import { getChangelogPosts } from "@/content/utils";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,diff --git a/apps/web/src/app/(landing)/changelog/page.tsx b/apps/web/src/app/(landing)/changelog/page.tsxindex 730197f32..705f6052e 100644--- a/apps/web/src/app/(landing)/changelog/page.tsx+++ b/apps/web/src/app/(landing)/changelog/page.tsx@@ -7,7 +7,7 @@ import { ContentCategory } from "../content-category";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,diff --git a/apps/web/src/app/(landing)/report-template/[slug]/page.tsx b/apps/web/src/app/(landing)/report-template/[slug]/page.tsxnew file mode 100644index 000000000..331a64fda--- /dev/null+++ b/apps/web/src/app/(landing)/report-template/[slug]/page.tsx@@ -0,0 +1,107 @@+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>+ );+}diff --git a/apps/web/src/app/(landing)/report-template/category/[slug]/page.tsx b/apps/web/src/app/(landing)/report-template/category/[slug]/page.tsxnew file mode 100644index 000000000..768bb16e2--- /dev/null+++ b/apps/web/src/app/(landing)/report-template/category/[slug]/page.tsx@@ -0,0 +1,60 @@+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>+ );+}diff --git a/apps/web/src/app/(landing)/report-template/page.tsx b/apps/web/src/app/(landing)/report-template/page.tsxnew file mode 100644index 000000000..08701c169--- /dev/null+++ b/apps/web/src/app/(landing)/report-template/page.tsx@@ -0,0 +1,41 @@+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>+ );+}diff --git a/apps/web/src/app/shared-metadata.ts b/apps/web/src/app/shared-metadata.tsindex b41451a36..e4c6f217b 100644--- a/apps/web/src/app/shared-metadata.ts+++ b/apps/web/src/app/shared-metadata.ts@@ -46,7 +46,7 @@ export const defaultMetadata: Metadata = {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;@@ -56,6 +56,10 @@ export const getPageMetadata = (page: MDXData): Metadata => {description,)}&category=${encodeURIComponent(category)}`;+ const url = basePath+ ? `${BASE_URL}/${basePath}/${slug}`+ : `${BASE_URL}/${slug}`;+return {title,description,@@ -64,7 +68,7 @@ export const getPageMetadata = (page: MDXData): Metadata => {description,type: "article",publishedTime: publishedAt.toISOString(),- url: `${BASE_URL}/changelog/${slug}`,+ url,images: [{url: ogImage,@@ -95,6 +99,7 @@ export const getJsonLDWebPage = (page: MDXData): WithContext<WebPage> => {export const getJsonLDBlogPosting = (post: MDXData,+ basePath: string,): WithContext<BlogPosting> => {return {"@context": "https://schema.org",@@ -110,7 +115,7 @@ export const getJsonLDBlogPosting = ()}&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,diff --git a/apps/web/src/content/copy-button.tsx b/apps/web/src/content/copy-button.tsxindex 45c2338d1..f03d985d7 100644--- a/apps/web/src/content/copy-button.tsx+++ b/apps/web/src/content/copy-button.tsx@@ -7,8 +7,14 @@ import { Button } from "@openstatus/ui";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 (@@ -19,7 +25,7 @@ export function CopyButton({onClick={() => copy(copyText, { withToast: true })}{...props}>- {isCopied ? "[link copied]" : "[copy link]"}+ {isCopied ? `[${copiedText}]` : `[${buttonText}]`}</Button>);}diff --git a/apps/web/src/content/pages/report-template/api-service-disruption.mdx b/apps/web/src/content/pages/report-template/api-service-disruption.mdxnew file mode 100644index 000000000..83dff4314--- /dev/null+++ b/apps/web/src/content/pages/report-template/api-service-disruption.mdx@@ -0,0 +1,76 @@+---+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 needsdiff --git a/apps/web/src/content/pages/report-template/database-performance-degradation.mdx b/apps/web/src/content/pages/report-template/database-performance-degradation.mdxnew file mode 100644index 000000000..e7678eeb9--- /dev/null+++ b/apps/web/src/content/pages/report-template/database-performance-degradation.mdx@@ -0,0 +1,101 @@+---+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 alertsdiff --git a/apps/web/src/content/pages/report-template/deployment-rollback.mdx b/apps/web/src/content/pages/report-template/deployment-rollback.mdxnew file mode 100644index 000000000..1ebd8bc56--- /dev/null+++ b/apps/web/src/content/pages/report-template/deployment-rollback.mdx@@ -0,0 +1,137 @@+---+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 issuesdiff --git a/apps/web/src/content/pages/report-template/feature-degradation.mdx b/apps/web/src/content/pages/report-template/feature-degradation.mdxnew file mode 100644index 000000000..01c9a9f0a--- /dev/null+++ b/apps/web/src/content/pages/report-template/feature-degradation.mdx@@ -0,0 +1,357 @@+---+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 [email protected]+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 degradationdiff --git a/apps/web/src/content/pages/report-template/network-connectivity-issues.mdx b/apps/web/src/content/pages/report-template/network-connectivity-issues.mdxnew file mode 100644index 000000000..768cdb315--- /dev/null+++ b/apps/web/src/content/pages/report-template/network-connectivity-issues.mdx@@ -0,0 +1,260 @@+---+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-relateddiff --git a/apps/web/src/content/pages/report-template/scheduled-maintenance.mdx b/apps/web/src/content/pages/report-template/scheduled-maintenance.mdxnew file mode 100644index 000000000..18028cd03--- /dev/null+++ b/apps/web/src/content/pages/report-template/scheduled-maintenance.mdx@@ -0,0 +1,342 @@+---+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.diff --git a/apps/web/src/content/pages/report-template/security-incident-response.mdx b/apps/web/src/content/pages/report-template/security-incident-response.mdxnew file mode 100644index 000000000..763b444ab--- /dev/null+++ b/apps/web/src/content/pages/report-template/security-incident-response.mdx@@ -0,0 +1,207 @@+---+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 [email protected].++### 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 [email protected] 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.diff --git a/apps/web/src/content/sub-nav.tsx b/apps/web/src/content/sub-nav.tsxindex 8617d3002..8929481fe 100644--- a/apps/web/src/content/sub-nav.tsx+++ b/apps/web/src/content/sub-nav.tsx@@ -19,7 +19,7 @@ export function SubNav({ className, ...props }: React.ComponentProps<"div">) {{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>@@ -29,6 +29,8 @@ export function SubNav({ className, ...props }: React.ComponentProps<"div">) {</div><CopyButtoncopyText={typeof window !== "undefined" ? window.location.href : ""}+ buttonText="copy link"+ copiedText="link copied"/></div>);diff --git a/apps/web/src/content/utils.ts b/apps/web/src/content/utils.tsindex f8dfee0fa..585e10936 100644--- a/apps/web/src/content/utils.ts+++ b/apps/web/src/content/utils.ts@@ -91,6 +91,13 @@ export function getProductPages(): MDXData[] {);}+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"),diff --git a/apps/web/src/data/content.ts b/apps/web/src/data/content.tsindex c4ddd73ca..bb305aa52 100644--- a/apps/web/src/data/content.ts+++ b/apps/web/src/data/content.ts@@ -30,6 +30,10 @@ const resourcesFooterSection = {label: "Docs",href: "https://docs.openstatus.dev",},+ {+ label: "Report Templates",+ href: "/report-template",+ },{label: "External Status",href: "/status",