How to Create a Status Update Deck with AI (Weekly & Monthly Templates)

Status update decks are the highest-volume repeatable deck type in any company — a typical project manager produces 50–100 per year, and an engineering lead often doubles that. In 2026, AI tools cut the time per weekly status deck from 60 minutes to under 5 minutes, producing a 10–12 slide update from a 200-word bullet summary. 2Slides' REST API takes this further: feed a weekly status CSV from your PM tool (Linear, Jira, Asana), and an automated workflow generates a PowerPoint deck plus an MP4 video summary — ideal for distributed teams where async video updates work better than synchronous meetings. This guide covers the 10-slide weekly-status template, a 20-slide monthly-status variant, paste-ready prompts, and a Python script that turns a Linear export into a deck. By the end, you'll have a repeatable pipeline that eliminates 40+ hours of annual status-deck busywork per PM while keeping stakeholders genuinely informed.

Status updates are the connective tissue of cross-functional work. They're also where most PMs lose 3–5 hours every week copy-pasting Jira tickets into slide templates. Automating them is the single highest-ROI AI workflow a project manager can adopt in 2026.

The Weekly Status Deck (10 Slides)

A weekly status deck has one job: answer "Are we on track?" in under 90 seconds of stakeholder reading time. The structure below is optimized for async consumption — every slide is self-contained and scannable.

Why 10 slides and not 15?

Stakeholder attention on a weekly update tops out around 90 seconds. Anything longer gets skimmed or skipped. The 10-slide cap forces ruthless prioritization — if a detail doesn't fit, it belongs in a linked doc, not in the deck.

The Monthly Status Deck (20 Slides)

Monthly decks serve a different audience: executives and cross-team stakeholders who aren't in your weekly channel. They need trend context, not task granularity.

Monthly decks benefit from charts more than weekly ones. Include at least one burndown, one velocity trend, and one business-outcome metric (revenue impact, user adoption, or cost saved).

The AI Prompt Templates

Paste these directly into 2Slides' prompt input or the

endpoint's field.

Weekly Status Prompt

Generate a 10-slide weekly project status deck for [Project Name], covering
[Week Range]. Audience: engineering leadership and cross-functional stakeholders.
Tone: concise, factual, no marketing language.

Inputs:
- Shipped this week: [3-5 bullets]
- In progress: [3-5 bullets with % complete]
- Blocked: [items + blocker reason + owner]
- Key metrics: [metric: current vs. last week]
- Decisions needed: [question + who needs to decide + by when]
- Next week top 5: [priorities]

Structure: cover / TL;DR / RAG status / wins / in-progress / blockers /
metrics / next week / decisions needed / appendix. Use RAG color coding
(red/amber/green) explicitly. Every slide must be self-contained.

Monthly Status Prompt

Generate a 20-slide monthly project status deck for [Project Name], covering
[Month Year]. Audience: executives and cross-team stakeholders.

Inputs:
- Month-at-a-glance: [2-3 sentence summary]
- OKR progress: [each KR with % complete]
- Shipped milestones: [list with dates]
- KPIs (4): [metric + current + MoM delta + YoY delta]
- Workstreams (up to 5): [name + status + highlights + risks]
- Top 3 risks: [risk + severity + owner + mitigation]
- Next month priorities: [list]

Structure per outline: executive summary (3) / outcomes (4) / metrics (4) /
workstream deep-dives (5) / risks (2) / next month (1) / appendix (1).
Include chart placeholders for each KPI slide.

Both prompts are deterministic enough that the same inputs produce near-identical deck structures — critical when you're running this weekly and stakeholders expect consistent format.

Automation: Linear/Jira → Deck via 2Slides API

Here's a production-ready Python script that pulls weekly status data from Linear and generates a deck via the 2Slides API. Adapt the

function for Jira, Asana, or any other source — the rest of the pipeline is identical.

import os
import time
import requests
from datetime import datetime, timedelta

SLIDES_API_KEY = os.environ["TWOSLIDES_API_KEY"]
LINEAR_API_KEY = os.environ["LINEAR_API_KEY"]
API_BASE = "https://2slides.com/api/v1"

def fetch_linear_weekly(team_id: str) -> dict:
    """Pull shipped, in-progress, and blocked issues from Linear for last 7 days."""
    since = (datetime.utcnow() - timedelta(days=7)).isoformat()
    query = """
    query($teamId: String!, $since: DateTime!) {
      team(id: $teamId) {
        issues(filter: { updatedAt: { gte: $since } }) {
          nodes { title state { name } estimate assignee { name } }
        }
      }
    }
    """
    r = requests.post(
        "https://api.linear.app/graphql",
        headers={"Authorization": LINEAR_API_KEY},
        json={"query": query, "variables": {"teamId": team_id, "since": since}},
    )
    issues = r.json()["data"]["team"]["issues"]["nodes"]
    return {
        "shipped": [i["title"] for i in issues if i["state"]["name"] == "Done"],
        "in_progress": [i["title"] for i in issues if i["state"]["name"] == "In Progress"],
        "blocked": [i["title"] for i in issues if i["state"]["name"] == "Blocked"],
    }

def build_prompt(data: dict, week_range: str) -> str:
    return f"""Generate a 10-slide weekly status deck for Week {week_range}.
Shipped: {data['shipped']}
In progress: {data['in_progress']}
Blocked: {data['blocked']}
Structure: cover / TL;DR / RAG / wins / in-progress / blockers / metrics /
next week / decisions / appendix. Concise, factual tone."""

def generate_deck(prompt: str) -> str:
    """Submit generation job and return the job ID."""
    r = requests.post(
        f"{API_BASE}/slides/generate",
        headers={"Authorization": f"Bearer {SLIDES_API_KEY}"},
        json={"prompt": prompt, "slide_count": 10, "language": "en"},
    )
    return r.json()["job_id"]

def poll_job(job_id: str, timeout: int = 300) -> dict:
    """Poll /jobs/:id until status is success or failed."""
    start = time.time()
    while time.time() - start < timeout:
        r = requests.get(
            f"{API_BASE}/jobs/{job_id}",
            headers={"Authorization": f"Bearer {SLIDES_API_KEY}"},
        )
        data = r.json()
        if data["status"] in ("success", "failed"):
            return data
        time.sleep(5)
    raise TimeoutError(f"Job {job_id} did not complete in {timeout}s")

if __name__ == "__main__":
    week = f"{(datetime.utcnow() - timedelta(days=7)).strftime('%b %d')}–{datetime.utcnow().strftime('%b %d, %Y')}"
    data = fetch_linear_weekly(team_id=os.environ["LINEAR_TEAM_ID"])
    prompt = build_prompt(data, week)
    job_id = generate_deck(prompt)
    result = poll_job(job_id)
    print(f"Deck ready: {result['pptx_url']}")

Schedule this with a cron job or GitHub Action every Friday at 4 PM — the deck lands in your inbox before the weekly review. For the Zapier no-code version of the same workflow, see our automated weekly reports guide.

Async Video Updates

Distributed teams increasingly replace synchronous status meetings with async video updates. The 2Slides API supports this in two calls after the deck is generated:

# 1. Generate narration audio for each slide
narration = requests.post(
    f"{API_BASE}/workspace/generate-narration",
    headers={"Authorization": f"Bearer {SLIDES_API_KEY}"},
    json={"job_id": job_id, "voice": "alloy", "style": "professional"},
).json()

# 2. Poll the narration job, then download slides + voices package
time.sleep(60)  # narration typically takes 30-90s for a 10-slide deck
package = requests.get(
    f"{API_BASE}/workspace/download-slides-pages-voices?job_id={job_id}",
    headers={"Authorization": f"Bearer {SLIDES_API_KEY}"},
).json()
# package contains signed URLs for each slide PNG + matching MP3 narration

From there, client-side FFmpeg (or any video encoder) can stitch slide PNGs + MP3 narration into a single MP4. A 10-slide weekly update produces roughly a 2-minute video at 1920×1080 — watchable at 1.5× speed in 80 seconds, which beats a 30-minute standup. For PMs specifically, see our deeper guide on AI presentations for sprint reviews and stakeholder updates.

Status-Deck-Specific Mistakes

1. Burying the ask. "Decisions needed" belongs on slide 9, not slide 20. Stakeholders who skim still need to see what you need from them.
2. RAG inflation. If every workstream is green every week, your RAG scale is broken. Calibrate: green = on track with no action needed, amber = intervention required, red = slipping goal.
3. Copy-pasting Jira ticket titles verbatim. "BACKEND-4271: Refactor auth middleware" is not a stakeholder-readable win. Rewrite as "Shipped: faster login (auth refactor cuts p99 latency 40%)."
4. No week-over-week comparison. A metric without last week's value is a data point, not a trend. Always show delta.
5. Inconsistent format week-to-week. Stakeholders develop muscle memory for where to look. Changing the structure monthly breaks that muscle memory and increases read time 2–3×.
6. Treating the deck as the source of truth. The deck is a summary. Always link back to the Jira board, Linear cycle, or Notion doc for depth.

Frequently Asked Questions

How long should a weekly status deck take to produce?

With AI automation via the 2Slides API, under 5 minutes end-to-end — 30 seconds to pull data from Linear/Jira, 90 seconds for the generation job, 2 minutes to review and tweak. Without automation, the same deck takes 45–60 minutes manually. Across a year that's the difference between 4 hours and 50 hours of PM time.

Should I use the same template every week?

Yes. Consistency is the entire point of a weekly deck — stakeholders need to find the RAG status in the same place every time. Use the 10-slide template above as-is for at least 8 weeks before considering changes. If the structure genuinely doesn't fit your team, change it once and commit.

What if my project has five workstreams — does it still fit in 10 slides?

Use slide 3 (RAG status) as a 5-row table, one row per workstream. Keep slide 5 (in-progress) as a combined view with workstream tags. If individual workstreams need more depth, link to per-workstream docs in the appendix. Resist the urge to grow the deck — that's what the monthly format is for.

Can I generate decks in languages other than English?

Yes. The

endpoint accepts a parameter covering English, Spanish, French, German, Japanese, Chinese, Portuguese, and 20+ others. For bilingual teams, generate two decks with the same prompt in different languages — the structure stays identical, so side-by-side review is easy.

How do I handle confidential status data with a cloud AI tool?

2Slides processes prompt data in memory and doesn't train on customer content. For highly sensitive projects, use the API with a dedicated API key per project and rotate keys quarterly. You can also pre-sanitize prompts by replacing ticket titles with generic descriptions before submission.

The Takeaway

Status decks are the most repeatable deck type you'll ever produce, which makes them the highest-ROI target for AI automation. A PM producing 50 weekly decks and 12 monthly decks per year spends roughly 60 hours annually on status reporting with manual tooling. The same output with a Linear-to-2Slides automation takes under 5 hours — a 12× productivity gain on a task that's pure overhead for the business.

More importantly, async video status updates change the calculus of how teams communicate. When a 90-second narrated video replaces a 30-minute standup for 8 people, that's 4 reclaimed hours per week at team level — compounding faster than the deck automation itself. The status-deck workflow is where AI presentation tools pay back their cost in the first month.

Automate your weekly status decks — try 2Slides free or see the API docs for the full automation workflow.