Daily accountability digest for PMs

The automation reads tasks from issue tracking, classifies them by urgency and risk, compiles them into a short digest, and sends it to the project manager in their communications channel. Each PM receives one card in the morning that shows their entire operational scope in a minute — without switching between Jira, Notion, Slack threads, and personal notes. The digest replaces the manual morning-routine and removes the cognitive load of the first 30 minutes of the day from the PM.

What the process does step by step

1. Collects open tasks from issue tracking where the current PM is owner, assignee, or observer on the relevant projects; the filter is configurable to the team's structure.
2. Separates three categories: overdue items, tasks with a deadline ≤72 hours, and tasks stuck without updates ≥5 days.
3. Summarizes each ticket to one line: status, blocker (if any), expected action, and responsible assignee.
4. Applies rubric-check: flags tasks with potentially compliance-sensitive context — work involving client data, NDA obligations, legal deadlines, and mentions of regulators.
5. Groups the result by priority: "critical today", "this week", "on my radar", "requires escalation".
6. Sends the digest to the PM's personal channel (Slack DM, Telegram, MS Teams) at the agreed time — 30 minutes before stand-up or at the start of the working day.
7. Maintains a log: which items the digest flagged and which were closed within 24 hours — material for retrospectives and feedback on rubric accuracy.

What the automation does not do

• Does not replace the project manager. Decisions on prioritization, escalation, and reallocation of work remain with the human — the digest only surfaces the relevant items.
• Does not modify tickets. The automation operates read-only with respect to issue tracking; status updates and comments the PM makes manually.
• Does not provide compliance guarantees. Rubric-check highlights suspicious wording as a triage signal, but legal expertise and the final decision remain with the specialized team.

The solution is built as a custom-code workflow: a daily cron trigger launches a pipeline that pulls tasks from issue tracking, runs them through an LLM for summarization and rubric-check, assembles a markdown digest, and publishes it via a communications API. The architecture is intentionally simple — one script, one queue, one log-store — so the PMO team can maintain it without a dedicated DevOps.

Technical flow

1. The cron trigger starts the pipeline at a set time (default 08:00 in each PM's time zone).
2. The script queries the issue tracking API with a filter: open tickets, assigned to or watched by the PM, in projects from the whitelist.
3. The enrichment step loads comments from the last 7 days, status history, and metadata (deadline, labels, ticket relationships).
4. The AI model receives each ticket and returns a single-line summary in a strictly defined format.
5. The LLM runs tickets through a QA-rubric: compliance criteria, quality of wording, presence of an owner and deadline, indicators of a stuck state.
6. The aggregator assembles the final markdown: a header with daily metrics, priority blocks, and a list of flags with a brief explanation.
7. The communications integration sends the digest to the PM's personal channel.
8. The log module writes each run to an audit table: list of flags, digest size, generation time, LLM error rate.

Implementation steps

1. Define the scope: list of PMs, issue tracking filters, schedule, delivery channels.
2. Set up API access to issue tracking and communications via a service account with the minimum required permissions.
3. Compose a rubric document: what counts as a compliance flag, what counts as a stylistic note, what counts as a blocker.
4. Develop LLM prompts: summary (with a strict length limit) and rubric review (with JSON output for validation).
5. Run the first pass in a sandbox and manually compare the digest against the actual picture for the pilot PM.
6. Launch a pilot with 1-2 PMs for 2 weeks, collecting feedback on format, flag accuracy, and usefulness of grouping.
7. Based on pilot results, refine the rubric, add whitelists/blacklists for wording, and roll out to all team PMs.

Key components

Typical configuration options

• One PM, one team. Minimal configuration: one workflow, one channel. MVP in 1-2 weeks.
• Multiple PMs, shared PMO. Shared rubric, individual filters per PM, a single log for rubric error analytics.
• With multi-level escalation. On top of the base digest, a weekly rollup is added for the PMO head with aggregated statistics on overdue items and closed flags.

Automation runs on top of the existing issue tracking and communications stack. If the team already manages tasks in Jira/Linear/ClickUp and lives in Slack/Telegram — 80% of the infrastructure is already in place, all that remains is to connect an LLM and write a pipeline.

Access and data

• API access to issue tracking (Jira, Linear, ClickUp, GitHub Projects, Asana and equivalents) from a service account.
• Read permissions for tasks, comments, and status history in the required projects.
• API access to the communications channel for sending direct messages (Slack, Telegram, MS Teams).
• LLM provider key (AI model or equivalent) with sufficient rate-limit for the daily ticket volume.
• An environment for cron jobs: a workflow engine, serverless function, or a regular VPS with a systemd timer.

Team readiness

• One engineer with API integration experience (~10-20 hours for setup and maintenance of an MVP).
• One PM as a pilot user for calibrating the rubric and digest format.
• A sponsor from the PMO to define the scope and boundaries of compliance criteria.

Timeline

• Week 1: access, basic workflow, first test run on sandbox.
• Week 2: rubric, LLM prompts, final markdown format, pilot launch with one PM.
• Week 3-4 (optional): iteration on feedback, rollout to the remaining PMs, connecting a log for flag quality analytics.