How to Build Your Own Simple Poll Slack App
Introduction #
Poll Slackbots are a great tool for sourcing async decisions, as well as having fun. For an off-the-shelf polling Slackbot, you may have to pay $100+ per month. It turns out, it's actually very easy to build and host on Replit for an order of magnitude less. This step-by-step guide will walk you through building and deploying your own polling Slack bot with no coding experience needed.
Getting started #
To get started, fork the template below:
Create a new Slack App #
Go to the Slack API website and navigate to your apps dashboard. Click on "Create New App."
Select "From an app manifest". Select the Slack workspace you want to add your bot to.
html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
{
"display_information": {
"name": "Poll Bot"
},
"features": {
"bot_user": {
"display_name": "Poll Bot",
"always_online": False
},
"slash_commands": [{
"command": COMMAND_NAME,
"url": f"https://{url_domain}/slack/events",
"description": "Make a poll",
"usage_hint":
"Choose a superpower:, invisibility, flight, super strength, time travel",
"should_escape": False
}]
},
"oauth_config": {
"scopes": {
"bot": [
"channels:history",
"chat:write",
"commands",
"reactions:write",
]
}
},
"settings": {
"org_deploy_enabled": False,
"socket_mode_enabled": False,
"token_rotation_enabled": False
}
}Paste the code above from `manifest.json` into the manifest file on Slack. This manifest already includes the correct request_url field with the Replit deployment URL, appended with /slack/events.
Install the app to the workspace #
On your app page, scroll down until you see the ability to "Install App to Workspace." Follow that process.
Add secrets #
Scroll down to the "App credentials" section, and copy and paste the following credentials into the Secrets pane in Replit:
- SLACK_SIGNING_SECRET - The "signing secret" for your app, found on the "Basic Information Page"
- SLACK_APP_TOKEN - The app-level token, found under "App Credentials" on the "Basic Information" page
- SLACK_BOT_TOKEN - The bot token for your app, found on the "OAuth & Permissions" page
Building the bot #
Import packages
Begin by importing the correct packages into main.py:
python
1
2
3
4
5
6
import logging
import os
from flask import Flask, request, render_template
from slack_bolt import App
from slack_bolt.adapter.flask import SlackRequestHandler
from emojis import random_emojis- logging, os: Standard Python libraries for handling logging and operating system interactions.
- flask, request, render_template: Flask libraries for creating web applications and handling HTTP requests and responses.
- slack_bolt, SlackRequestHandler: Libraries for creating Slack applications and adapting them to work with Flask.
- random_emojis: A custom function from `emojis.py` that shuffles and returns a list of emojis.
Slackbot setup
First, we are going to establish some demand-related constants:
python
1
2
COMMAND_NAME = '/poll'
COMMAND_DELIMITER = ','Here's more on what they mean:
- COMMAND_NAME: The name of the Slack command to be used.
- COMMAND_DELIMITER: Delimiter to split the command into question and options.
Second, we will set up some logging. This is optional, but it can be helpful information for debugging:
python
1
2
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)Third, we need to use the Secrets you set up in the previous section. Let's make them accessible to our program:
python
1
2
bot_token = os.environ.get('SLACK_BOT_TOKEN', 'UNSET')
signing_secret = os.environ.get('SLACK_SIGNING_SECRET', 'UNSET')Finally, we need to initialize the Slack App, so it has the secrets we made accessible. This will ensure Slack knows to grant access to the bot:
python
1
app = App(token=bot_token, signing_secret=signing_secret, token_verification_enabled=False)Set up command handler
Next, we need to set up route that handles the initial request to the bot. We will call this the command handler.
python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
@app.command(COMMAND_NAME)
def handle_command(ack, body, say, client):
ack()
emojis = random_emojis()
user_id = body['user_id']
text = body.get('text', '')
logger.info('Received command: %s', text)
parts = text.split(COMMAND_DELIMITER)
question = parts[0]
options = [part.strip() for part in parts[1:] if part.strip()]
if len(options) < 2:
say("Please provide at least two options for the poll.")
return
blocks = []
blocks.append({
'type': 'header',
"text": {
"type": "plain_text",
"text": f"{question}",
"emoji": True
}
})
emojis_used = []
for i, option in enumerate(options):
if i >= len(emojis):
say(f"Only up to {len(emojis)} options are supported.")
return
blocks.append({
"type": "section",
"text": {
"type": "mrkdwn",
"text": f":{emojis[i]}: {option}"
}
})
emojis_used.append(emojis[i])
blocks.append({"type": "divider"})
blocks.append({
"type": "section",
"text": {
"type": "mrkdwn",
"text": f"Poll created by <@{user_id}>! Use the reactions to vote. ❤️ <https://replit.com|Replit>"
}
})
response = client.chat_postMessage(channel=body['channel_id'], blocks=blocks, unfurl_links=False)
message_ts = response['ts']
for emoji in emojis_used:
client.reactions_add(channel=body['channel_id'], name=emoji, timestamp=message_ts)The code above defines the command handler (`handle_command`) with the following specifications:
- The command handler is defined for the /poll command.
- ack(): Acknowledges receipt of the command.
- random_emojis(): Generates a shuffled list of emojis.
- Splits the command text into a question and options.
- Checks if there are at least two options, returning an error message if not.
- Constructs a Slack message with the question and options.
- Posts the message to Slack.
- Adds emoji reactions corresponding to the poll options.
Set up an error handler
We want to make sure we capture requests that do not work, so we will create an error handler:
python
1
2
3
4
@app.error
def custom_error_handler(error, body, logger):
logger.exception(f"Error: {error}")
logger.info(f"Request body: {body}")Set up the Flask server
We need a server for this bot, so we will use a common approach called Flask. Here is the code:
python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
flask_app = Flask(__name__)
flask_app.config['JSON_AS_ASCII'] = False
handler = SlackRequestHandler(app)
@flask_app.route("/slack/events", methods=["POST"])
def slack_events():
if bot_token == 'UNSET' or signing_secret == 'UNSET':
return "Error: Missing environment variables", 500
logger.debug("Received Slack event")
return handler.handle(request)
@flask_app.route("/health", methods=["GET"])
def health_check():
return "OK", 200
@flask_app.route("/", methods=["GET"])
def index():
replit_deployment_domains = os.getenv('REPLIT_DOMAINS')
replit_deployment_domain = replit_deployment_domains.strip().split(',')[0] if replit_deployment_domains is not None else None
replit_dev_domain = os.getenv('REPLIT_DEV_DOMAIN')
url_domain = replit_deployment_domain if replit_deployment_domain is not None else replit_dev_domain
manifest = None
if url_domain is not None:
manifest = {
"display_information": {
"name": "Poll Bot"
},
"features": {
"bot_user": {
"display_name": "Poll Bot",
"always_online": False
},
"slash_commands": [{
"command": COMMAND_NAME,
"url": f"https://{url_domain}/slack/events",
"description": "Make a poll",
"usage_hint": "Choose a superpower:, invisibility, flight, super strength, time travel",
"should_escape": False
}]
},
"oauth_config": {
"scopes": {
"bot": [
"channels:history",
"chat:write",
"commands",
"reactions:write",
]
}
},
"settings": {
"org_deploy_enabled": False,
"socket_mode_enabled": False,
"token_rotation_enabled": False
}
}
secrets_defined = bot_token != 'UNSET' and signing_secret != 'UNSET'
return render_template('index.html', is_deployed=replit_deployment_domain is not None, manifest=manifest, secrets_defined=secrets_defined)This code above does the following:
- Initializes a Flask app (flask_app) and configures routes for Slack events, health checks, and the index page.
- /slack/events: Endpoint to handle Slack events.
- /health: Health check endpoint returning "OK".
- /: Index page that renders a web page with the app's deployment status and manifest information.
Finally, we need to add some code that starts the server when the app is run:
python
1
2
if __name__ == "__main__":
flask_app.run(debug=True, host='0.0.0.0', port=int(os.environ.get('PORT', 3000)))Deploy your bot #
Finally, deploy your bot to a Reserved VM. Make sure to select "Background worker."
IMPORTANT NOTE: Once your application is deployed, you need to add your deployed URL to the Secret defined as `REPLIT_DOMAINS`. Then Redeploy the application.
On the next screen, click Approve and configure build settings most internal bots work fine with the default machine settings but if you need more power later, you can always come back and change these settings later. You can monitor your usage and billing at any time at: replit.com/usage.
On the next screen, you’ll be able to set your primary domain and edit the Secrets that will be in your production deployment. Usually, we keep these settings as they are.
Finally, click Deploy and watch your bot go live!
What's Next #
If you’d like to bring this project and similar templates into your team, set some time here with the Replit team for a quick demo of Replit Teams.
Happy coding!