1. Log in to your Slack workspace or join the Developer Program to get a free enterprise sandbox.
2. Open Your Apps dashboard.
3. Click Create New App > From scratch.
   
   
4. Add a name for your app, such as “Useless Fact App” (you can update it later).
5. Select the workspace where you want to install your app (e.g., the sandbox you created).
6. Click Create App.
   
   

Your app will use Socket Mode to connect to Slack using a dynamic, two-way communication. This simplifies the setup for developing and testing new applications. 

1. Click Socket Mode on the sidebar.
2. Toggle Enable Socket Mode on.
3. To enable Socket Mode, you must generate an app-level token. Type “useless-fact-app-token” for the Token Name.
4. Click Generate.
   
   
5. The new app level token is displayed. You will need this token, but you can copy and paste it in a later step. Click Done.
   

All apps built for Slack have an app manifest. This is the configuration for the app, such as the name, settings, and required permissions. The app manifest also describes any functions (custom code) your app will make available to your Slack workspace. It’s important to note the following app manifest includes a function named useless_fact_step and declares the function returns one value named “Fact” as its output.

1. Click App Manifest on the sidebar. 
2. Copy the following app manifest and update your default app manifest. Update the name “Useless Fact App” if you used a different name.
   {    “display_information”: {

           “name”: “Useless Fact App”

       },

       “features”: {

           “app_home”: {

               “home_tab_enabled”: true,

               “messages_tab_enabled”: true,

               “messages_tab_read_only_enabled”: true

           },

           “bot_user”: {

               “display_name”: “Useless Fact App”,

               “always_online”: false

           }

       },

       “oauth_config”: {

           “scopes”: {

               “bot”: [

                   “chat:write”,

                   “app_mentions:read”,

                   “workflow.steps:execute”

               ]

           }

       },

       “settings”: {

           “event_subscriptions”: {

               “user_events”: [

                   “message.app_home”

               ],

               “bot_events”: [

                   “app_mention”,

                   “workflow_step_execute”,

                   “function_executed”

               ]

           },

           “interactivity”: {

               “is_enabled”: true

           },

           “org_deploy_enabled”: true,

           “socket_mode_enabled”: true,

           “token_rotation_enabled”: false,

           “hermes_app_type”: “remote”,

           “function_runtime”: “remote”

       },

       “functions”: {

           “useless_fact_step”: {

               “title”: “Useless Fact Custom Step”,

               “description”: “Runs useless fact step”,

               “input_parameters”: {},

               “output_parameters”: {

                   “message”: {

                       “type”: “string”,

                       “title”: “Fact”,

                       “description”: “A random useless fact”,

                       “is_required”: true,

                       “name”: “message”

                   }

               }

           }

       }

   }

3. Save your changes.

Now, install your app to your Slack workspace (sandbox). 

1. Navigate to Install App in the sidebar.
2. Click Install to <Name of your workspace>.
   
   
3. Approve the installation and scopes, and it will generate the Bot User token. You will need this token for the app to work, but you can copy it in a later step.
   
   

Now that you’ve completed the app setup, it’s time to write some code!

1. Open your terminal or command prompt.
2. First, check to see that you have Node.js installed and it is a recent long-term support (LTS) version by typing the following command.
   
   node -v
   
   If you get an error or if it’s an older version than what’s available for download on the Node.js website, take a moment to install the latest version.
3. Create a new directory for the project named useless-fact-app and change to the new directory.
   
   mkdir useless-fact-app
   cd useless-fact-app
   
   (If you’re on Windows, the command is: md useless-fact-app)
4. Initialize a new Node.js project using the following command and answer each question with defaults.
   
   npm init
5. Our project is going to use two packages: Slack’s Bolt for JavaScript framework and axios, a popular HTTP client for making API calls. Install these dependencies with the following command.
   
   npm install @slack/bolt axios
6. Open the project in Visual Studio Code or your favorite code editor.
7. Create a new file in the project folder named .env, open the file and paste the following.
   
   SLACK_SIGNING_SECRET={your-app-signing-secret}
   SLACK_BOT_TOKEN={your-bot-token-xoxb-1234}
   SLACK_APP_TOKEN={your-app-token-xapp-1234}
   PORT=3000
8. Return to the Slack app dashboard and find the values needed for the .env file. Click on Basic Information, click on Show by the Signing Secret, and copy this value. Replace {your-app-signing-secret} in the .env file with your Signing Secret.
   
9. Scroll down and click on the name of your app-level token, then click Copy. Replace {your-app-token-xapp-1234} in the .env file with your app-level token.
   
   
10. Click OAuth & Permissions. Find your Bot User OAuth Token, and click Copy. Replace {your-bot-token-xoxb-1234} in the .env file with your Bot User token.
    
    
11. Edit the package.json file, update the following settings, and save the file.
    
    Change “main” to:
    
    “main”: “app.js”,
    
    Change the “scripts” to:
    
    “scripts”: {
      “dev”: “node –env-file=.env –watch app.js”
    },
    
    Change “type” to “module” (or add this line if not already present):
    
    “type”: “module”,
12. Create a new file named app.js and add the following code.

import bolt from “@slack/bolt”;

import axios from “axios”;

const { App } = bolt;

// Initialize the Bolt app

const app = new App( {

  token: process.env.SLACK_BOT_TOKEN,

  signingSecret: process.env.SLACK_SIGNING_SECRET,

  appToken: process.env.SLACK_APP_TOKEN,

  socketMode: true

} );

// Make an API call to retrieve a random fact

async function getUselessFact() {

  const res = await axios.get( “https://uselessfacts.jsph.pl/api/v2/facts/random” );

  return ( res.status === 200 ) ? res.data : null;

}

// Define the function for Workflow Builder

app.function( “useless_fact_step”, async ( { complete, fail, logger } ) => {

  try {

    app.logger.info( “Running useless fact step…” );

    // Get the fact using the API

    const fact = await getUselessFact();

    if ( fact && fact.text ) {
      // Use complete() to send results to Slack

      await complete( {

        outputs: {

          message: fact.text

        }

      } );

    } else {
      // Use fail() to send an error to Slack

      await fail( { error: “There was an error retrieving a random useless fact :cry:” } );

    }

  } catch ( error ) {
    // Log the error and send an error message back to Slack

    logger.error( error );

    await fail( { error: `There was an error 😥 : ${ error }` } );

  }

} );

// Start the Bolt App!

async function main() {

  await app.start( process.env.PORT || 3000 );

  app.logger.info( “⚡️ Bolt app is running!” );

}

main();

The code in app.js initializes the Bolt app using your tokens and signing secret and enables socket mode. Next it defines the getUselessFact() function that retrieves a random fact using axios. Then it uses the Bolt framework to create a Slack function named useless_fact_step. This is the same function we registered in the app manifest in step 3, and it’s important when creating functions that the code and app manifest match on name, inputs, and outputs. Finally, a function named main() is used to start the Bolt app.

From your terminal, enter the following command.

npm run dev

You should see the following printed to the console.

> bolt-useless-facts@0.1.0 dev

> node --env-file=.env --watch app.js

[INFO]  bolt-app ⚡️ Bolt app is running!

Your Bolt app is running, and you can now use it in your Slack workspace!

To create a new workflow, you will need to open Workflow Builder in Slack. You can open Workflow Builder using one of the following methods.

Option 1: Use the message box

In any channel, write: /workflow and select Create a new workflow

Option 2: Use the sidebar

1. Navigate to the left sidebar and click More > Automations > Workflows
   
   
2. Click +New Workflow > Build Workflow
   
   

Every workflow starts with a trigger. For this workflow, it may make sense to have it scheduled for each work day at a specific time. 

1. Under Start the workflow… click Choose an event
2. From the list of events, click On a schedule
   
   
3. Configure the schedule for your app to run. Under Starts on, choose today’s date. Change the time to 15 or 30 minutes from now (you can update the scheduled time and frequency after you verify it is working). Under Frequency, choose Every weekday (Monday to Friday). Click Continue.
   
   

After the workflow is triggered, the next step is to call the function in the Bolt app. This is done using a custom step.

1. Click + Add steps.
2. Click Search steps…
3. In the search box, start typing the name of your Bolt app.
4. Click Useless Fact Custom Step.
5. Click Save.
   
   

After calling the Bolt app and retrieving a random fact, the next step is to send a message to a channel.

1. Click + Add Step.
2. Click Messages and then click Send a message to a channel.
   
   
3. Click Select a channel and choose a channel to send a message.
4. Under Add a message, type something like “🤓Random useless fact:”
5. Click {} Insert a variable and then select Fact under 1. Useless Fact Custom Step.
6. Click Save.
   
   

Almost there! The final task is to publish the workflow and wait for the next scheduled run to see it in action!

1. Click Finish Up.
2. Enter a Name, such as “Daily Useless Fact”
3. Update the Description.
4. Click Publish.
   
   
5. Wait for the scheduled time and see your new custom Bolt app in action!
   
   

If needed, you can always make changes to your workflow, such as the schedule, channel, or message. 

1. Click More -> Automations -> Workflows.
2. Find your workflow and click the three vertical dots on the right side.
3. Click Edit workflow.
   

Congratulations! You’ve learned how to create a Bolt app using the Bolt for JavaScript framework and a daily scheduled workflow using Workflow Builder! 

The Bolt app will continue to work as long as you have it running on your computer. This is fine for development and testing purposes, but a better long-term solution is deploy the application to a production environment. You can follow the guides available for Deploying to AWS Lambda or Deploying to Heroku for steps on deploying to those environments, or deploy to any platform that supports JavaScript serverless functions or Node.js applications.