How to Send Sprint Notifications from Jira to Slack with Pipedream

Pipedream > Workflows > New

Create New Pipedream Workflow

Log into pipedream.com and click New Workflow in the top right. Choose to start with a trigger source. You'll see a blank workflow canvas with a single trigger step. This will listen for Jira webhook events about sprint changes.

1. 1Click 'New Workflow' in the dashboard
2. 2Select 'HTTP / Webhook Requests' as your trigger source
3. 3Copy the generated webhook URL from the trigger step
4. 4Leave the HTTP method as POST

Workflow > Add Step > Apps > Jira

Configure Jira Webhook Connection

Add a new step after your trigger and select Jira. You'll authenticate using your Atlassian account credentials. Pipedream stores these securely and handles token refresh automatically. Choose the 'Custom Request' action since we're processing webhook data.

1. 1Click the + button below your webhook trigger
2. 2Search for and select 'Jira Software Cloud'
3. 3Click 'Connect Account' and auth with Atlassian
4. 4Choose 'Make a Custom API Request' action

Jira > Settings > System > Webhooks

Set Up Jira Webhook in Admin

In your Jira instance, go to System settings and create a new webhook pointing to your Pipedream URL. Select sprint-related events: sprint started, sprint closed, and sprint updated. This ensures you catch all ceremony timing changes and goal updates.

1. 1Navigate to Jira Settings > System > WebHooks
2. 2Click 'Create a WebHook'
3. 3Paste your Pipedream webhook URL
4. 4Select 'Sprint started', 'Sprint closed', and 'Sprint updated' events
5. 5Click 'Create' to save the webhook

Workflow > Add Step > Apps > Slack

Add Slack Connection Step

Add another step and select Slack. Connect your workspace using OAuth - this gives Pipedream permission to post messages and read channel info. Choose the 'Send Message to Channel' action since you'll be posting sprint updates to a specific channel.

1. 1Click + to add another step after Jira
2. 2Search for and select 'Slack'
3. 3Click 'Connect Account' and authorize your workspace
4. 4Choose 'Send Message to Channel' action
5. 5Select your target channel from the dropdown

Workflow > Add Step > Code > Node.js

Create Sprint Data Processing Code Step

Add a Node.js code step between Jira and Slack to parse the webhook payload and fetch additional sprint data. This step extracts sprint details, calculates burndown metrics, and formats the data for Slack. You'll use Jira's REST API to get incomplete issue counts.

1. 1Click + between your Jira and Slack steps
2. 2Select 'Code' then 'Run Node.js code'
3. 3Name the step 'Process Sprint Data'
4. 4Clear the default code and paste the processing logic

Add this Node.js code to your processing step to calculate sprint velocity trends and include team performance context in notifications. Paste this in the code step between Jira and Slack.

export default defineComponent({
  async run({ steps, $ }) {
    const event = steps.trigger.event;

export default defineComponent({
  async run({ steps, $ }) {
    const event = steps.trigger.event;
    const sprint = event.sprint;
    
    // Fetch sprint issues for burndown calculation
    const issuesResponse = await $.send.http({
      method: 'GET',
      url: `https://your-domain.atlassian.net/rest/agile/1.0/sprint/${sprint.id}/issue`,
      headers: {
        'Authorization': `Bearer ${auths.jira_software_cloud.oauth_access_token}`,
        'Accept': 'application/json'
      }
    });
    
    let completedPoints = 0;
    let remainingPoints = 0;
    let incompleteIssues = [];
    
    issuesResponse.issues.forEach(issue => {
      const storyPoints = issue.fields.customfield_10016 || 0;
      if (issue.fields.status.statusCategory.key === 'done') {
        completedPoints += storyPoints;
      } else {
        remainingPoints += storyPoints;
        incompleteIssues.push({
          key: issue.key,
          summary: issue.fields.summary,
          points: storyPoints
        });
      }
    });
    
    // Calculate burndown health
    const totalPoints = completedPoints + remainingPoints;
    const completionRate = totalPoints > 0 ? (completedPoints / totalPoints) * 100 : 0;
    
    // Get sprint duration info
    const startDate = new Date(sprint.startDate);
    const endDate = new Date(sprint.endDate);
    const sprintDays = Math.ceil((endDate - startDate) / (1000 * 60 * 60 * 24));
    
    return {
      sprintName: sprint.name,
      sprintGoal: sprint.goal || 'No goal set',
      startDate: startDate.toLocaleDateString(),
      endDate: endDate.toLocaleDateString(),
      sprintDays,
      completedPoints,
      remainingPoints,
      totalPoints,
      completionRate: Math.round(completionRate),
      incompleteCount: incompleteIssues.length,
      topIncompleteIssues: incompleteIssues.slice(0, 5),
      eventType: event.webhookEvent,
      burndownHealth: completionRate > 70 ? '🟢' : completionRate > 40 ? '🟡' : '🔴'
    };
  }
});

Slack Step > Configuration > Message Text

Configure Message Field Mapping

In your Slack step, map the processed data from your code step to create rich sprint notifications. Use the dynamic field picker to reference sprint name, dates, and metrics. Format the message with Slack markdown for better readability including bullet points for incomplete tickets.

1. 1Click in the 'Text' field of your Slack step
2. 2Use the field picker to select data from your code step
3. 3Format with Slack markdown: *bold*, code, and bullet points
4. 4Add conditional text based on sprint event type
5. 5Test the message preview

Code Step > Edit Code

Add Sprint Burndown Chart Logic

Enhance your code step to calculate remaining story points and compare against ideal burndown. Query Jira's sprint report API to get completion metrics. This requires additional API calls but provides the team with actionable sprint health data in each notification.

1. 1Return to your Node.js code step
2. 2Add burndown calculation functions
3. 3Make API calls to Jira's sprint report endpoint
4. 4Calculate story point completion percentage
5. 5Format burndown summary for Slack

Jira Board > Sprint Actions > Start Sprint

Test Sprint Event Simulation

Trigger a test by starting or updating a sprint in your Jira board. Watch the workflow execution in Pipedream's logs to verify each step processes correctly. Check that your Slack channel receives the formatted notification with all expected sprint data and burndown metrics.

1. 1Go to your Jira board and start a new sprint
2. 2Watch for the webhook event in Pipedream's event inspector
3. 3Check each step's output in the execution log
4. 4Verify the Slack message appears in your target channel
5. 5Confirm all data fields are populated correctly

Workflow Settings > Deploy > Error Handling

Enable Workflow and Set Error Handling

Activate your workflow using the toggle switch and configure error notifications. Set up failure alerts to your personal Slack DM so you know immediately if sprint notifications fail. Add retry logic to handle temporary Jira API outages during critical sprint transitions.

1. 1Click the Deploy button to activate your workflow
2. 2Toggle the workflow status to 'On'
3. 3Configure error notifications in Workflow Settings
4. 4Set retry attempts to 3 with exponential backoff
5. 5Test error handling by temporarily breaking a connection