Daily Standup Meeting Notes: How to Capture and Act on Them Automatically

Every day, teams spend 15 minutes in a standup sharing updates. Someone takes notes - or doesn’t. The meeting ends. The notes get pasted into a Slack message, or saved in a doc, or forgotten entirely.

Meanwhile, the Jira tickets from those updates don’t change. The bugs mentioned don’t get filed. The blockers don’t get tracked. By next standup, everyone’s reconstructing what happened yesterday.

Standup notes should do work. Here’s how to capture them properly and connect them to your project management system automatically.

What Good Standup Notes Actually Contain

A useful standup note isn’t a transcript. It’s a structured record of:

What each person shipped since last standup

Completed tasks (which tickets can be closed or moved to Done)
PRs merged or reviews completed
Decisions made

What’s in progress

Active work that should already be tracked
Any changes to scope or approach on existing tickets

Blockers and dependencies

Items that need someone else to act
External dependencies that are creating delay
Questions that need answers before work can continue

New work surfaced

Bugs noticed during development
Features or tasks that came up and need to be tracked
Follow-up actions from completed work

Most standup notes capture the first two. The blockers and new work are where tickets get missed.

The Standard Standup Note Template

A simple format that works for most teams:

## Standup Notes - [Date]

**[Name]**
- Done: [what they completed]
- Doing: [what they're working on now]
- Blockers: [anything slowing them down]
- New items: [anything that surfaced that needs tracking]

For Jira users, the “Done” section maps directly to tickets that should move to Done. The “New items” section maps to tickets that should be created.

The Problem with Manual Note-Keeping

The most common standup note workflow:

One person writes notes in a doc during the standup
They paste the notes into Slack or a shared doc
The notes sit there
No one updates Jira

The bottleneck isn’t the format. It’s the gap between “person said something in standup” and “ticket reflects that information.”

Closing that gap manually takes time - and it’s time no one budgets for.

How to Connect Standup Notes to Jira Automatically

There are a few ways to bridge standup notes and Jira:

Option 1: Meeting recorder + manual review

Tools like Otter, Fathom, or Granola can transcribe your standup and generate a summary. Someone then reviews the summary and manually updates tickets.

This reduces the note-taking burden but doesn’t close the execution gap. Someone still has to go through the summary and take action in Jira.

Option 2: Async standup tools with Jira integration

Tools like Geekbot, Standuply, or Sup collect standup updates in Slack and can post summaries to Jira tickets. This works well when:

Updates are text-based (not video)
The Jira ticket exists before the standup
The team consistently links updates to tickets

The limitation: these tools capture what team members report. They don’t infer what should be created or updated based on the content.

Option 3: AI agent that reads standups and updates Jira automatically

The most complete solution is an AI agent that joins your standup (video or async), reads what was discussed, and proposes Jira updates based on the actual content.

How Telos handles daily standups:

Joins your standup call (Google Meet, Zoom, Teams) and reads the transcript
Identifies updates for existing tickets - status changes, new comments, blockers to add
Identifies new work that should be filed as tickets - bugs, tasks, follow-up items
Proposes a batch of actions: “Based on today’s standup, here’s what I want to update in Jira - approve to apply”
PM approves in Slack - usually 2-3 minutes
Jira is updated without anyone opening Jira

The difference from manual note-taking: the system reads context and infers what should change in Jira, rather than just capturing what was said.

What Happens When You Automate Standup Notes

When standup updates flow into Jira automatically, a few things change:

Jira becomes accurate in real time. Tickets reflect current status after every standup, not just when someone remembers to update them.

Standups get shorter. If the AI is updating Jira, you don’t need to spend standup time on status that’s already visible in the board. The meeting can focus on blockers and decisions.

Nothing falls through the cracks. The bug mentioned in passing, the task that should have been filed two days ago - these get captured without anyone having to remember to do it.

Async standups become viable. If Jira is staying current via AI, you can run standups asynchronously more easily. The signal still flows from the team’s activity into the backlog, without requiring a synchronous meeting.

Getting Started

Start by improving your standup note format. The template above is a good starting point - the key is consistently capturing blockers and new work, not just “done/doing” status.

From there, pick your integration level:

Low friction: a meeting recorder that transcribes and summarizes
Medium: an async standup tool with Jira integration for structured updates
Full automation: an AI agent that reads standups and proposes Jira updates

Telos handles the full automation layer - connecting your standup meetings to Jira without requiring any manual steps between the meeting and the backlog update.