Automate Daily Scrum Questions via Slack Bot

Hey there, Darian Vance here. Let’s talk about a classic time-sink: the daily scramble to get scrum updates. For the longest time, I was the one poking people in DMs, trying to collate what everyone was working on. I probably wasted a solid two hours a week just on that administrative churn. Then it hit me—why am I, a DevOps engineer, doing this manually? This is a perfect task for a simple, scheduled bot.

This tutorial will show you how to build a fire-and-forget Python script that posts your team’s daily stand-up questions to a Slack channel automatically. It’s a small investment of time that pays back daily dividends in focus and efficiency. Let’s get it done.

Prerequisites

Before we start, make sure you have the following ready:

• Python 3 installed on the machine where this script will run.
• A Slack workspace where you have permission to create and install apps.
• Basic familiarity with using a terminal and environment variables.

The Guide: Step-by-Step

Step 1: Create Your Slack App and Get the Bot Token

First, we need to tell Slack about our bot. This process generates the API token our script will use to authenticate.

1. Navigate to the Slack API page and click “Create New App”.
2. Choose “From scratch”, give your app a name (e.g., “Daily Scrum Bot”), and select the workspace you want to install it in.
3. Once your app is created, you’ll be on its basic information page. In the left sidebar, click on “OAuth & Permissions”.
4. Scroll down to the “Scopes” section. Under “Bot Token Scopes”, click “Add an OAuth Scope” and add chat:write. This is the crucial permission that allows your bot to post messages.
5. Scroll back up and click “Install to Workspace”. Follow the prompts to authorize the app.
6. After authorizing, the page will refresh and you’ll see a “Bot User OAuth Token” that starts with xoxb-. Copy this token. This is your secret key. Treat it like a password.

Pro Tip: Store this token somewhere safe immediately. I use a password manager. You’ll need it for the script, but you never want to commit it directly into your code repository.

Step 2: Find Your Slack Channel ID

Your bot needs to know *where* to post. We need to get the unique ID for the channel, not just its name.

1. Open your Slack client.
2. Right-click on the channel name in your sidebar (e.g., #dev-standup).
3. Select “Copy Link”.
4. Paste the link somewhere. It will look something like this: https://your-workspace.slack.com/archives/C0123ABCDEF
5. That last part, the string starting with a ‘C’ (C0123ABCDEF), is your Channel ID. Copy that and keep it handy.

Step 3: Write the Python Script

Alright, let’s get to the code. I’ll skip the standard virtualenv setup since you likely have your own workflow for that. Just make sure you’re in a clean project directory. You’ll need to install a couple of libraries; run a pip install for slack_sdk and python-dotenv to manage our dependencies and environment variables.

First, create a file named config.env in your project directory. This is where we’ll safely store our secrets. Add your token and channel ID to it:

SLACK_BOT_TOKEN="xoxb-YOUR-BOT-TOKEN-HERE"
SLACK_CHANNEL_ID="C0123ABCDEF"

Now, create your main Python file, let’s call it scrum_bot.py. Here’s the full script. I’ll explain the logic below.

import os
from dotenv import load_dotenv
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError

# Load environment variables from config.env
load_dotenv('config.env')

# Initialize the Slack WebClient with your bot token
slack_token = os.environ.get("SLACK_BOT_TOKEN")
channel_id = os.environ.get("SLACK_CHANNEL_ID")

# A best practice is to validate that your variables loaded correctly
if not slack_token or not channel_id:
    print("Error: Ensure SLACK_BOT_TOKEN and SLACK_CHANNEL_ID are set in config.env")
    # In a real script, you'd want to handle this more gracefully, but for now we just stop.
    # We use 'return' here to exit cleanly if this were in a function.
else:
    client = WebClient(token=slack_token)

    # Define the daily scrum questions
    scrum_message = """
    :wave: Good morning, team! Time for our daily stand-up.
    Please reply in a thread with your updates:
    • *What did you accomplish yesterday?*
    • *What are you working on today?*
    • *Any blockers?*
    """

    try:
        # Call the chat.postMessage method using the WebClient
        result = client.chat_postMessage(
            channel=channel_id,
            text="Good morning! Time for our daily stand-up.", # Fallback text for notifications
            blocks=[
                {
                    "type": "section",
                    "text": {
                        "type": "mrkdwn",
                        "text": scrum_message
                    }
                }
            ]
        )
        print(f"Message sent successfully: {result['ts']}")

    except SlackApiError as e:
        # You will get a SlackApiError if something went wrong
        print(f"Error sending message: {e.response['error']}")

The Logic Explained:

• Loading Secrets: We use dotenv to load the variables from our config.env file. This keeps our secrets out of the code itself, which is a major security win.
• Client Initialization: We create an instance of the WebClient from the slack_sdk and pass it our bot token. This client object is what we’ll use to interact with the Slack API.
• Message Payload: I’m using Slack’s Block Kit format here. It gives you much richer formatting than plain text. We define a simple “section” block with our formatted Markdown text. The text parameter is a fallback for notifications.
• Error Handling: I’ve wrapped the API call in a try...except block. In my production setups, this is non-negotiable. If the Slack API is down or our token is invalid, the script won’t just crash; it will catch the SlackApiError and print a helpful error message.

Step 4: Schedule the Bot with Cron

A bot that you have to run manually isn’t much of an automation. We’ll use cron, the classic Unix job scheduler, to run our script automatically.

You can edit your system’s crontab to add a new job. Here’s a cron expression that will run the script at 9:00 AM every weekday (Monday to Friday):

0 9 * * 1-5 python3 /path/to/your/project/scrum_bot.py

Let’s break that down:

• 0 9: At 0 minutes past the 9th hour (9:00 AM).
• * *: Every day of the month and every month.
• 1-5: On days 1 through 5 of the week (Monday to Friday).
• Finally, the command to execute: your python interpreter followed by the path to your script.

Pro Tip: Cron jobs run based on the server’s system time. If your server is in UTC but your team is in PST, your 9 AM message will go out in the middle of the night! Always double-check the server’s timezone with the date command before setting up your cron job.

Common Pitfalls

Here is where I usually mess up when I’m setting one of these up from scratch, so you can avoid my mistakes:

• missing_scope Error: This is the most common one. If you get this error, it means you forgot to add the chat:write permission to your bot’s token scopes in the Slack API settings.
• Wrong Channel ID: The script will fail if you use the channel *name* (e.g., `#dev-standup`) instead of its ID (e.g., `C0123ABCDEF`). Slack’s API requires the ID.
• Environment Variable Issues: The script can’t find your token if it’s run from a directory that doesn’t contain the config.env file. When setting up your cron job, always use the absolute path to your script to avoid any confusion about the working directory.

Conclusion

And that’s it. You now have a simple, robust, and automated bot handling a piece of daily project management for you. This is a classic DevOps mindset win: identify a repetitive, manual task and automate it away. It’s a small script, but the reclaimed time and mental energy add up significantly. Now, you can focus on the real work while the updates roll in automatically.

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions