Conference Talk Preparation Checklist

Production-ready guide covering conference talk preparation checklist with implementation patterns, code examples, and anti-patterns for enterprise engineering teams.

Preparing for a conference talk is a process that begins weeks before the first slide and ends with the final question from the audience. This checklist guides you through the essential, non-negotiable steps—from concept to delivery—ensuring your talk is clear, compelling, and resilient under real-world conditions. Use this checklist when you’ve accepted a talk proposal, confirmed your session type and time, and have at least two weeks to refine your content.

Define Your Core Message

A talk without a core message is a sequence of slides, not a narrative. The core message is a single, complete sentence that captures the essence of your talk.

  We can reduce API latency by 70% in production by adopting a layered caching strategy that combines in-memory, disk-based, and CDN layers, with consistent invalidation across all tiers.

> Common failure: The core message is too broad, or it’s a title with no depth. > Sharp edge: The core message is written but never revisited during rehearsal. Revisit it before every rehearsal and before recording the final video.

Structure the Talk

Your talk structure is the skeleton. Build it in a Markdown file at structure.md.

Use the following pattern:

## Introduction: The Problem
### The bottleneck is not the database, but the network
- 40% of our API latency comes from network round trips between service and cache.
- Example: `curl -v http://api.example.com/users/123` shows 312ms RTT, 210ms in DNS and TCP handshake.

## Core Architecture: Layered Caching
### Cache layers act as independent, coordinated systems
- In-memory (Redis) at 15ms latency.
- Disk-based (SQLite) at 80ms, with LRU eviction.
- CDN (Cloudflare) for static assets, 30ms global average.

## Case Study: Live Deployment
### We reduced latency from 420ms to 145ms in two weeks
- Deployed new cache tier using `docker-compose up -d --no-recreate`.
- Verified with `watch -n 1 'curl -s http://api.example.com/health | jq .cache'`.

> Common failure: Sections are titled but not named; the talk jumps from topic to topic without signposting. > Sharp edge: The structure file is not updated after a rehearsal. Add a Rehearsal 1 section after the first run-through.

Build the Slides

Use a tool that supports live editing and export to PDF and HTML. The checklist assumes you’re using Reveal.js, a real, widely used open-source framework.

  mkdir slides && cd slides
  npm init -y
  npm install reveal.js --save-dev
  cp -r node_modules/reveal.js/* .
  <!doctype html>
  <html lang="en">
    <head>
      <meta charset="utf-8">
      <title>Conference Talk</title>
      <link rel="stylesheet" href="css/reveal.css">
      <link rel="stylesheet" href="css/theme/white.css">
      <script src="js/reveal.js"></script>
      <script>
        Reveal.initialize({
          hash: true,
          slideNumber: true,
          transition: 'slide',
          dependencies: [
            { src: 'plugin/markdown/markdown.js', condition: function() { return !!document.querySelector( '[data-markdown]' ); } },
            { src: 'plugin/notes/notes.js', async: true }
          ]
        });
      </script>
    </head>
    <body>
      <div class="reveal">
        <div class="slides">
          <section data-markdown>
            ## Introduction
            ### The Problem
            - 40% of our API latency comes from network round trips
            - Example: `curl -v http://api.example.com/users/123`
          </section>
          <!-- More slides -->
        </div>
      </div>
    </body>
  </html>
  <section data-markdown>
    ## Core Architecture: Layered Caching
    ### Cache layers act as independent, coordinated systems
    - In-memory (Redis) at 15ms latency.
    - Disk-based (SQLite) at 80ms, with LRU eviction.
    - CDN (Cloudflare) for static assets, 30ms global average.
  </section>

> Common failure: Slides are created in PowerPoint or Google Slides but never tested in the actual Reveal.js environment. > Sharp edge: data-markdown content is not validated before the rehearsal. Run reveal.js locally using npx http-server and open index.html in a browser for all rehearsals.

Rehearse the Talk

Rehearsal is not just speaking the talk—it’s testing the tools, timing, and transitions.

  ffmpeg -f alsa -i pulse -f x11grab -s 1920x1080 -i :0.0 -c:v libx264 -crf 23 -preset fast -c:a aac -ab 128k -r 30 -t 30 \
         -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" \
         -y output.mp4
  time -p sh -c 'echo "Start: $(date)" && sleep 60 && echo "End: $(date)"'
    0:00–0:15 — Introduction
    0:15–3:00 — The Problem
    3:00–6:30 — Core Architecture
    6:30–10:00 — Case Study
    10:00–11:30 — Demo
    11:30–12:00 — Q&A

> Common failure: Rehearsal is a single run-through with no feedback. > Sharp edge: The ffmpeg recording captures the wrong window—Reveal.js is not the active window when recording starts. Use xwininfo to verify the target window ID and pass it to x11grab.

Prepare the Demo

A demo is a live, interactive part of your talk. It must be rehearsed, tested, and instrumented.

    #!/bin/bash
    echo "Starting demo environment..."
    cd /path/to/demo
    redis-server --daemonize yes
    python -m http.server 8000 &
    sleep 2
    echo "Demo ready. Access at http://localhost:8000"
    echo "Press Ctrl+C to stop."
    wait
    #!/bin/bash
    echo "Verifying demo environment..."
    curl -s http://localhost:8000/health | jq .status
    if [ $? -eq 0 ]; then
      echo "✓ Demo is healthy"
    else
      echo "✗ Demo is unhealthy"
      exit 1
    fi
  ./run-demo.sh &
  sleep 5
  ./verify-demo.sh

> Common failure: The demo runs but is not tested before rehearsal. > Sharp edge: The demo server crashes between slides. Use systemctl to manage the demo process:

  sudo systemctl enable demo.service
  sudo systemctl start demo.service
  sudo systemctl status demo.service

Finalize the Delivery

The final delivery is the talk as it appears in the venue.

  cd slides
  pandoc -f markdown -t pdf -o talk.pdf structure.md
  reveal.js -o speaker-notes.html

> Common failure: The USB stick contains only the slides, but no supporting files. > Sharp edge: The venue has a projector that doesn’t support 1920x1080. Test your slides at 1280x720 and 1024x768 using ffmpeg:

  ffmpeg -i output.mp4 -vf "scale=1280:720:force_original_aspect_ratio=decrease,pad=1280:720:(ow-iw)/2:(oh-ih)/2" -y output-720p.mp4

Pre-Conference Checklist

Use this checklist the week before the talk.

On-Site Day Checklist

Use this checklist on the day of the talk.

> Sharp edge: The demo service fails to start. Use journalctl -u demo.service to check logs and restart with systemctl restart demo.service.

This page was rewritten on 18 October 2026. It replaced a templated version that was not specific to its own title. How these pages are written and checked. If anything here is wrong, tell us at [email protected] and we will correct it.