Meeting Prep Template That Actually Works
A meeting prep template for engineering managers that pulls context from your actual tools, not your memory.
By Ellis Keane · 2026-04-03
Every meeting prep template I've encountered is just an agenda template wearing a disguise. They give you a place to write "Discussion topics" and "Action items" and call it preparation, but they skip the actual hard part: knowing what's happened since the last time you spoke with someone.
The real work of meeting prep is the fifteen minutes you spend scrolling through Slack trying to remember what your direct report mentioned on Tuesday, or the ten minutes clicking through Linear issues to figure out whether that migration shipped, or opening a 1:1 and realizing you have nothing specific to discuss because the week blurred together (as weeks tend to do).
This meeting prep template starts from a different premise: preparation is about gathering context, not writing an agenda. Operational context lives in your tools, not in your head; interpersonal context still requires judgment and notes, but that's a smaller surface area than most people think. The approach is three layers: an activity scan, a decision and blocker check, and a change delta. You can run through all three in under seven minutes.
Who This Template Is For
Primary audience: engineering managers running 1:1s, team syncs, and cross-functional check-ins, though anyone who walks into meetings wishing they'd looked things up beforehand can adapt this. If you manage 5-8 direct reports across a mix of Linear, GitHub, Slack, and maybe Notion or Figma, you're who I had in mind. Different tool stack? The structure still applies; swap out the specific queries.
A quick 1:1 might only need Layer 1. A high-stakes planning session with five or more attendees and irreversible decisions on the table probably needs all three.
Layer 1: The Activity Scan (3 Minutes)
Before any meeting, pull recent activity for the people attending. Not everything they've done, just enough to walk in knowing what their week actually looked like.
- [ ] Check each attendee's recent PRs (merged, open, and reviewed) in GitHub
- [ ] Scan their Linear issues: what moved to Done, what's been In Progress for more than 3 days, what got reassigned
- [ ] Skim Slack channels where they've been active, look for threads with 5+ replies (those tend to be the meaty discussions). Slack's search modifiers like
from:@person before:today can speed this up considerably
- [ ] If applicable, check Figma activity for design-related meetings or Notion updates for planning meetings
The point isn't to surveil anyone (please don't turn this into a productivity audit). The point is to show up informed enough to ask good questions. There's a world of difference between "How's the migration going?" and "I saw the migration PR got three rounds of review comments from the platform team, what's the sticking point?" The second one tells your direct report that you're paying attention, and in my experience it gets to the real conversation faster.
Here's what this looks like in practice. Say you're prepping for a 1:1 with an engineer who's been working on a notification system refactor. You check GitHub and see they merged two PRs this week but have one that's been open for four days with no reviewers. You check Linear and notice the parent epic slipped from "In Progress" to "Blocked" yesterday. You check Slack and find a thread in #platform where they asked about a database schema change and got conflicting answers from two senior engineers.
Now you have three concrete things to discuss, and you haven't even written an agenda yet.
Meeting prep isn't about writing topics down. It's about gathering enough context from your tools that the important topics surface on their own.
Layer 2: The Decision and Blocker Check (2 Minutes)
Meetings are (theoretically) where decisions get made, so it helps to know which decisions are pending. This layer takes about two minutes and catches the things that would otherwise ambush you mid-meeting.
- [ ] Search Slack for messages from attendees containing "decision", "should we", "waiting on", or "blocked by" in the past week
- [ ] Check Linear for issues tagged with blockers or dependencies involving the attendees
- [ ] Look for any open questions in shared Notion docs or Figma comments that haven't been resolved
- [ ] Review your own notes from the last meeting with this person: did you promise to follow up on anything?
That last item is the one most people skip, and it's arguably the most important. Forgetting commitments reliably damages trust, and following through unprompted reliably builds it. This is the single easiest way to make 1:1s better, and it has nothing to do with meeting prep templates or any tool.
Prep that works
- Pull specific activity data from tools before writing any agenda
- Search for pending decisions across Slack threads and Linear blockers
- Reference previous meeting notes to check your own follow-through
- Let context surface the topics rather than guessing what to discuss
Prep that wastes time
- Write a generic agenda like "Updates / Blockers / Action Items" with no supporting context
- Rely on memory to recall what happened across a week of scattered tool usage
- Ask "anything else?" at the end because you ran out of things you remembered to discuss
- Treat every meeting the same regardless of what's actually happening in the work
Layer 3: The Change Delta (2 Minutes)
This layer is optional but genuinely useful for meetings that happen on a regular cadence, like weekly 1:1s or biweekly team syncs. The question you're answering is: what changed since we last talked?
Pull up your notes or records from the last meeting (even if those "notes" are just a bullet list in a doc somewhere) and compare the state of things then versus now. Specifically:
- Which issues that were "in progress" last time have shipped? Which ones haven't moved?
- Did any new priorities or emergencies appear that weren't on the radar?
- Were there any team changes, reorg announcements, or roadmap shifts that affect this person's work?
The change delta keeps your meeting focused on progress versus drift. Instead of a flat list of topics, you're walking into a conversation about trajectory: here's where things were, here's where they are, and here's what that means for what we do next.
For a worked example: suppose last week your direct report had three issues in progress on the payments epic, and one of them was a high-priority bug fix. This week, the bug fix shipped (great), one issue moved to review (good), and one hasn't been updated in six days (worth asking about, gently). That's your 1:1 structure right there, and it took about ninety seconds to assemble.
Putting It Together: The Template
Here's the actual template. Copy it, adapt it, throw away the parts that don't apply. The format matters less than the habit.
```
Meeting Prep: [Person/Group] - [Date]
Layer 1: Activity Scan
- Recent PRs (merged/open/reviewing):
- Linear issues (completed/in-progress/blocked):
- Notable Slack threads:
- Other tool activity (Figma/Notion/etc.):
Layer 2: Decisions & Blockers
- Pending decisions that need resolution:
- Active blockers:
- My follow-ups from last meeting:
Layer 3: Change Delta (vs. last meeting)
- What shipped:
- What didn't move:
- New priorities/context:
Discussion Notes
(Fill during the meeting)
Action Items
(Capture with owner and deadline) ```
The template is deliberately tool-agnostic. Whether you're querying GitHub, Linear, Jira, Shortcut, or a whiteboard photo, the structure is the same: activity, decisions, change.
Why This Works Better Than an Agenda
The traditional meeting prep template asks "what do I want to talk about?" This one asks "what actually happened?" and lets the topics emerge from the data. In practice that means you catch things you'd otherwise miss, like a PR that's been sitting without review for four days, or a decision that got made in a Slack thread but never made it into Linear.
Same checklist every time also means fewer missed blockers. When preparation is a concrete five-to-seven minute routine (well, as concrete as "skim some Slack threads" can be), you stop dreading it.
Scaling This Across Your Week
Say you manage six direct reports with weekly 1:1s, plus two team syncs and a cross-functional meeting. That's nine meetings requiring prep, which is already more meetings than anyone would design from scratch if they were building a company on a whiteboard (but here we are, and the meetings aren't going anywhere, so let's deal with them).
If each prep session averages fifteen minutes of unstructured hunting across tools, that's over two hours per week spent gathering context. With this meeting prep template, each session runs five to seven minutes once you've built the muscle memory. For nine meetings, that's roughly an hour, so you're saving about an hour a week, which across 48 working weeks comes to roughly 48-50 hours per year. Whether you spend those reclaimed hours on actual engineering work or just staring out the window feeling smug about your process is (honestly) none of my business.
stat: "~48-50 hours/year" headline: "Time saved on meeting prep" source: "Based on 9 weekly meetings across 48 work weeks, 15 min unstructured vs 6 min templated"
The quality difference compounds too. Nine prepared meetings means nine conversations that surface real issues sooner and generate fewer "oh wait, I meant to ask about..." follow-up Slack messages afterward. That's harder to quantify, but if you've ever sent a 3pm DM to someone you just spent thirty minutes with at 10am, you know the feeling.
When to Skip Prep Entirely
Not every meeting deserves preparation. If you're attending a company all-hands or a social coffee chat, don't pull Linear queries beforehand (seriously). And if the meeting is one of those recurring 30-minute slots that nobody remembers scheduling but everyone's afraid to delete, maybe the prep you need is the courage to hit "Decline." Use this meeting prep template when you own the outcomes or need to make decisions: 1:1s, team syncs, planning sessions, cross-functional reviews.
If a meeting doesn't warrant five minutes of prep, it's worth asking whether it warrants thirty minutes of attendance. And if you want to go further and automate your meeting prep entirely, that's a separate (and honestly more interesting) conversation.
Get signal intelligence delivered to your inbox.
Frequently Asked Questions
Q: What should an engineering manager's meeting prep template include? A: A good meeting prep template pulls three things before each meeting: recent activity from the people attending (PRs, issues, messages), any open decisions or blockers relevant to the agenda, and a quick scan of what changed since the last meeting. The template itself is less important than the habit of filling it in from real tool data rather than memory.
Q: How long should meeting prep take for a 1:1? A: With a structured template and the right tool queries, meeting prep for a 1:1 should take under five minutes. Most engineering managers spend 15-20 minutes because they're hunting across Slack, Linear, and GitHub manually. A template that specifies exactly where to look cuts that dramatically.
Q: Does Sugarbug automate meeting prep for engineering teams? A: Yes. Sugarbug connects to tools like Linear, GitHub, Slack, Google Calendar, and Notion, then assembles a briefing before each meeting based on who's attending and what's been happening across those tools. It pulls the same context you'd gather manually with this template, but does it automatically.
Q: Can I use this meeting prep template without any special tools? A: Absolutely. The template works with nothing more than a text editor and browser tabs. The whole point is a repeatable structure for gathering context. If you want to automate it later, tools exist for that, but the template stands on its own.