AgentsStudioTemplatesPricingDocs
Sign inGet Started

Give your AI agent an automation engine.

Build

  • MCP server
  • kovca CLI
  • Kovca's agent
  • Studio
  • Templates

Run

  • Apps and events
  • Decision and Generative AI
  • Workflows API
  • Run history
  • Pricing

People in the loop

  • Approvals and waits
  • Tasks
  • Coding agents
  • Docs

Company

  • About
  • Security
  • Contact
  • Privacy Policy
  • Terms of Service
© Kovca. kovca.io
GuidesOperations

Turn Slack bug reports into Jira issues

Build a Kovca workflow that starts from a new Slack message, classifies it, and on a bug creates a Jira issue, reacts on the message, and replies in the thread with the issue key.

Support Triage30 min readcURL
InputTriageBug?LowerCrashErrorBrokenMention?SummaryShortIssueNoteReactReplySeenResult
TemplateSlack bug reports to JiraClassify a new Slack message and create a Jira issue when it is a bug, or when the text mentions a crash, error, or broken feature. React on the message and reply in the thread with the issue key.
16 nodesUp to 1 evaluation per run
Use this template

A bug channel collects real bugs, questions, and chatter in one scroll. Someone has to read each message, decide whether it is a bug, and copy it into Jira with a summary a teammate can scan. The reporter often never hears that an issue exists. Messages get lost above the fold.

This guide builds a workflow that starts when a new message is posted in that channel and classifies it. A technical message becomes a Jira issue. A message in another category becomes a Jira issue too when the text contains crash, error, or broken, so a billing note that also reports a crash is not only marked as seen. The summary is kept to at most 255 characters before it is sent. The workflow adds a reaction on the original message and replies in the thread with the issue key. Anything else gets a different reaction and no issue. You'll start from a template, test it, and activate it on the channel.

The template already uses the Slack New message trigger, Jira Create issue, Slack Add reaction (twice), and Slack Send message. It does not store a Slack account or a Jira account. You choose the accounts when you activate. Until then the draft saves, and Studio tests simulate the Slack and Jira steps.

Escalate urgent Slack channel messages into incidents starts from the same kind of Slack message and opens an incident when the priority is high. This one files a Jira issue when the category is technical, including a medium or low bug, and also when another category's text contains crash, error, or broken. It answers in the thread. Turn customer bug reports from Gmail into clean developer issues starts from email. Triage and label new GitHub issues and Triage new Linear issues start from issues that already exist. Check Jira change requests against your policy starts from a Jira issue and reads it. This guide is the handoff from a Slack channel into a new Jira issue.

If the channel only gets a few reports a day, Jira's own Slack shortcut, or a person who files the obvious ones, is less machinery than this. That option is at the end. The workflow is for the channel where bugs, questions, and chatter sit in the same scroll.

What you'll build

Slack: New message connects to Triage, then Bug?. The default handle of Bug? reaches Lower, then Crash, Error, Broken, and Mention?. Lower, Crash, Error, and Broken are Transform Text. Mention? is a Condition. The false handle continues to the right, outside the crop.

StepNodeWhat it does
InputSlack: New message (slack/new_message)Starts the workflow. The event fields are attachments, blocks, bot_id, channel, channel_type, files, subtype, team_id, text, thread_ts, ts, and user.
TriageSupport Triage (builtin:support/triage@1)Returns category, priority (low, medium, high), and requires_human_review.
Bug?Switchbug when category is technical. Everything else is default, which continues to Lower.
LowerTransform TextOn the default branch. Lowercases the Slack text.
CrashTransform TextTrue when that text contains crash.
ErrorTransform TextTrue when that text contains error.
BrokenTransform TextTrue when that text contains broken.
Mention?ConditionTrue when any of those three is true. True continues to Summary. False continues to Seen.
SummaryTextOn the file path. One line: the priority in brackets, then the Slack text.
ShortTransform TextTruncates that line to 255 characters. A longer line ends with ….
IssueJira Create issue (action:jira/create_issue@1)Creates the issue from the truncated line. Sent once.
NoteTextThe thread reply, including the issue key.
ReactSlack Add reaction (action:slack/add_reaction@1)Adds ticket on the original message. Safe to retry.
ReplySlack Send message (action:slack/send_message@1)Posts the note in the thread. Sent once.
SeenSlack Add reaction (action:slack/add_reaction@1)On Mention? false. Adds speech_balloon. Safe to retry.
OutputOutputThe card on the canvas says Result. Returns the classification, whether a keyword matched, the summary that would be sent, the issue key, and whether the reaction or the reply ran.

The bug branch does not run Lower, Crash, Error, Broken, Mention?, or Seen. Mention? false does not create an issue, react with ticket, or reply.

Support Triage does not return a bug, feature request, or how-to label of its own. technical is its bucket for errors, bugs, outages, crashes, slow performance, and integration problems. product covers both how a feature works and a feature request. priority is what this node returns. This template puts that word in the summary. It does not write Jira's Priority field. A person may need to change the priority on the issue.

The keyword steps are not a second classification. Contains text looks for those letters after the text is lowercased. crashes matches crash. A billing message that uses the word error, and is not a bug, is filed too.

Create issue's inputs are Project Key, Summary, Issue Type, Labels, Priority, Assignee, and Due Date. There is no description field on this action. The summary is the Slack message, with the priority in front, then cut to 255 characters. Extract data is a real node, and it leaves a field out when the text does not state it. Summary is required, so this template builds it with a text step from the message itself. The Text step has no length limit of its own. Transform Text does: its Truncate operation keeps at most the length you set, and when it cuts, the last character is ….

Watch the test

Watch the Studio test (MP4). It is a screen recording of the production Studio at kovca.io, in light mode, 17 seconds. The frame is the page: the workflow header, the Test panel, and a strip of the canvas. Browser chrome is not in the frame. The assistant panel is outside the crop. The Running line is played a little slower than it was captured, so it stays readable. Nothing is sped up. The clip opens on a clean Test panel: the login-timeout input is on screen, and there is no result yet. Run test is clicked. Running shows, then the result comes back on that panel, and the clip ends holding that output through seen null and the closing brace. No Slack account is connected, no Jira account is connected, and Send real requests stays off. Issue, React, and Reply are marked sample. That is not an issue created in Jira, and it is not a reaction or a message posted in Slack. Seen is skipped.

Send real requests is off. Status 200, 5 credits. category technical, priority high, route bug, mentioned null, issue_key SUP-212, filed true. issue, react, and reply are marked sample. seen is null.

The recording follows these steps:

  1. The Test tab is open on Slack bug reports to Jira. The draft is not published. The header says 1 Decision AI evaluation max and 5 connections. The input on screen is text "The login page times out after 30s", channel C08BUGS0001, and ts 1732118400.123456. Send real requests is off. The switch's own text says action steps return their sample result and nothing is sent. There is no result yet.
  2. Run test is clicked. Running shows, and the previous result stays cleared until this one finishes. The result then comes back on that panel.
  3. The result comes back: status 200, 5 credits used for that one Decision AI step.
  4. The steps list shows lower, crash, error, broken, mention, and seen skipped. summary, short, and note succeeded. issue, react, and reply succeeded and are marked sample.
  5. The output holds through the end of the clip, through seen null and the closing brace. category is technical. priority is high. requires_human_review is false. route is bug. mentioned is null, because the keyword steps did not run. summary is [high] The login page times out after 30s. issue_id is 10482. issue_key is SUP-212. filed, reacted, and replied are true. reply is Filed SUP-212 (high). seen is null.

That is one Studio test of that text. What Support Triage returns on another message depends on the text. 10482 and SUP-212 are the sample Create issue returns when the step is simulated. The project key on the step is BUGS. The sample key does not change to match it.

The JSON later in this guide is the template's unit test for the same text when the test does not read the message. The category is the first Support Triage category, billing. That text contains none of crash, error, or broken, so Mention? is false and Seen is the only action that runs. It is not the decision on this recording.

Build it in the Studio

1Start from the template

Click Use this template above, or open Slack bug reports to Jira in Workflows.

The draft opens on the canvas. The components library is on the left. Triggers, AI, Action in an app, Data transformation, Flow, Core, and Human review are the groups. This workflow uses Slack and Jira, so both are under Triggers and under Action in an app once the draft uses them. Apps you have not connected, and that this workflow does not use, stay behind Connect another app. The pictures below are the Studio, in light mode, with no Slack account and no Jira account connected. The template's step titles are the ones in the table above. The last card on the canvas is Result.

Triggers, Slack. New message is selected. Reaction added, New Channel Created, Direct Message Received, and Message Reaction Removed are in the same list. Several descriptions are cut off by the card.

Slack: Send message. The card says it posts a message to a Slack channel, DM, or private group.

Action in an app, Jira. Jira: Create issue says it creates a Jira issue in a specified project with standard and additional custom fields. The card ends that sentence with an ellipsis. Bulk Create Issues and Create Issue Type are in the same list.

2The workflow starts from a new message

Select the input step. It is Slack: New message, not an API request. The account line asks you to connect Slack. Leave it empty while you test.

The step warns that this event can happen very often, and that every event that starts a run uses credits. Narrow it with the settings below.

Connect Slack is still to do. Only in channel (ID) is C08BUGS0001. Channel Type is channel. Bot messages and Thread replies are unchecked.

SettingTemplate value
Only in channel (ID) (channel_id)C08BUGS0001
Channel Type (channel_type)channel
Bot messages (is_bot_message)false
Thread replies (is_thread_reply)false

C08BUGS0001 is a stand-in, the same kind of channel id as the trigger's sample event. Replace it with the bug channel's ID. The other channel types are group and mpim. Until an account is connected, Only in channel asks you to connect Slack to choose a channel. Once an account is connected, that field lists the workspace's channels.

The two checkboxes are labeled Bot messages and Thread replies. In the picture they are unchecked, which is how the template's false looks. The connector schema describes them as "Filter by message source" and "Filter by thread status." Those sentences are not printed next to the boxes. This guide has not watched a live channel, so it does not say which messages a checked or unchecked box keeps out. After you connect Slack, post one bot message and one thread reply in a test channel and see whether a run starts. Change the boxes if the wrong messages start runs.

Event fields later steps read:

FieldUsed for
input.textSupport Triage's message, Lower, and the summary
input.channelBoth reactions, and the thread reply
input.tsBoth reactions, as the message timestamp, and the thread reply, as the thread timestamp
input.userNot read by this template
input.thread_tsNot read by this template

The event also includes attachments, blocks, bot_id, channel_type, files, subtype, and team_id. A manual run or an API call can omit them. The same message does not start two runs: the event id is ts. A later message is a new event and runs again. A message Reply posts does not start the automation again.

Send the new message, not a long thread you pasted in. Support Triage reads input.text only.

3Classify the message

Select Triage. It is Support Triage. message is mapped from the event. Slack messages have no subject, and subject is optional on this node, so the template leaves it unmapped.

Title Triage. subject is Not set. message is a reference to input.text.

Triage's subtitle is Support Triage, and the badge says Decision AI. The card on the left is the trigger, cut off by the crop, and it reads message.

The node decides on fixed, published rules:

  • category is billing, technical, account, product, or other. technical is its bucket for errors, bugs, outages, crashes, slow performance, and integration problems. product covers both how a feature works and a feature request.
  • priority is low for a question or feedback, medium when the customer has a problem but can keep working, and high when they're blocked right now. A message the node treats as a security problem is high.
  • requires_human_review is true when a legal threat or a security problem is reasonably possible, or when the category or priority itself is unclear.

message is required and accepts at most 8,000 characters, which is also the limit on input.text. An empty text fails this step. A message that is only a file, with no text, is in that group. This template does not branch on requires_human_review. A technical message is filed either way.

4File a bug, and mark everything else

Select Bug?. The switch reads nodes.triage.output.category and continues on the first matching case.

Route on nodes.triage.output.category. The case name is bug and the matching value is technical. Apply cases is black, so this draft matches what is already saved.

CaseMatchesGoes to
bugtechnicalSummary
defaultbilling, account, product, other, and anything elseLower

default does not go straight to Seen. Lower, Crash, Error, and Broken run first. Each Contains text step reads nodes.lower.output.result and looks for one substring. The Find values are crash, error, and broken. Contains text is case-sensitive, which is why Lower runs first: Crashes becomes crashes, and that contains crash.

Mention? continues on true when any rule matches. The three rules are is true on nodes.crash.output.result, nodes.error.output.result, and nodes.broken.output.result. True goes to Summary, the same step the bug case uses. False goes to Seen.

Error and Broken are Transform Text. Mention? is a Condition. The true line leaves upward, outside the crop.

A message Support Triage calls billing can still be filed. "I was charged twice for my invoice AND the export button crashes the app with a 500 error" contains crash and error after lowercasing, so Mention? is true and the issue path runs. "thanks!" contains none of the three, so Seen runs. "Please refund the double charge on my invoice. I was billed twice." contains none of them either, so Seen runs. The check does not read the sentence. It only looks for those letters.

Summary, Short, Issue, Note, React, and Reply are on the top row. Short is Transform Text. Issue is Jira: Create issue and shows a warning. Note is Text. React and Reply are Slack actions and show a warning. Result is under Reply. Triage and Bug? sit on the row below.

Seen is the false branch of Mention?. It adds speech_balloon so the channel shows the message was read and not filed. Change the emoji to one your workspace has. The short name has no colons.

If it fails, the run continues. Channel is input.channel. Message timestamp is input.ts. Emoji name is the fixed value speech_balloon.

Seen fieldValue
Channel (channel)input.channel
Message timestamp (timestamp)input.ts
Emoji name (name)speech_balloon

If it fails is Continue (output.ok is false). A missed emoji does not fail the run. The step is safe to retry: Kovca retries it if Slack is briefly unavailable. Choose the Slack account on this step before you activate. Studio tests simulate it and do not add a reaction. The simulated result is ok: true and result: {}. This template reads ok only.

5Build the summary

Summary runs when the bug case matches, and when Mention? is true. The template is one line. In the inspector the line wraps inside the box.

[{{nodes.triage.output.priority}}] {{input.text}}

The template box shows the priority placeholder and input.text. The line wraps inside the box.

For the login-timeout text, with priority high, the summary the Studio test produced was:

[high] The login page times out after 30s

A missing priority or a missing text leaves an empty spot in that line. The Text step does not cut the line. input.text can be 8,000 characters, and the brackets and the priority sit in front of that.

Short is Transform Text. The operation is Truncate with …. Text is nodes.summary.output.text. Maximum length is 255. When the line is already 255 characters or shorter, the result is the same line. When it is longer, the result is the first 254 characters plus …, so the whole value is 255 characters. That ellipsis is one character, and it counts toward the 255. Jira's summary field is limited to about 255 characters. Kovca's Summary input on Create issue accepts up to 8,000, so this step is what keeps the value inside Jira's limit. This guide has not created a Jira issue, so it does not say what Jira returns for a longer summary.

Title Short. Text is a reference to nodes.summary.output.text. Operation is Truncate with an ellipsis. Maximum length is 255.

The word in brackets is the priority Support Triage returned on that run. It is not a rank this template checks. See Make it yours.

6Create the issue

Select Issue. It is Jira's Create issue action. The account line asks you to connect Jira. Leave it empty while you test.

If it fails is Stop the run. Project Key is the fixed value BUGS. Summary is a reference to nodes.short.output.result. Issue Type is the fixed value Bug. Labels and Priority are Not set.

Create issue fieldValue
Project Key (project_key)BUGS
Summary (summary)nodes.short.output.result
Issue Type (issue_type)Bug
Labels, Priority, Assignee, Due DateNot set

BUGS and Bug are stand-ins. Replace them with a project key and an issue type that project already has. This guide has not created a Jira issue, so it does not say what happens when the type or the project key is wrong. Labels, Priority, Assignee, and Due Date are optional on this action. The template leaves them unset. Jira's own priority names are not the same strings Support Triage returns (low, medium, high). The priority is in the summary instead.

If it fails is Stop the run. React and Reply do not run if the issue was not created. The step's own line says it is sent once: Kovca does not retry it. A second run with a new idempotency key can create another issue. Choose the Jira account on this step before you activate. Studio tests simulate it and do not create an issue. The simulated result is ok: true, id: 10482, and key: SUP-212. This template reads ok, id, and key only.

7React, and reply in the thread

Note is the reply. It runs after the issue, so the key is the sample key in a Studio test and the created key when the step runs for real.

Filed {{nodes.issue.output.key}} ({{nodes.triage.output.priority}}).

The template names the issue key and the priority. The line wraps inside the box.

React marks the original message.

If it fails, the run continues. Channel is input.channel. Message timestamp is input.ts. Emoji name is ticket.

React fieldValue
Channel (channel)input.channel
Message timestamp (timestamp)input.ts
Emoji name (name)ticket

ticket is a stand-in short name, without colons. Change it to an emoji the workspace has. If it fails is Continue (output.ok is false). The step is safe to retry. Studio tests simulate it.

Reply is Slack's Send message action. The field Reply in thread (message timestamp) is thread_ts. Its description says it is the timestamp (ts) of an existing message, and that setting it makes this a threaded reply. This template maps it to input.ts, the message that started the run.

If it fails, the run continues. Channel is input.channel. Message is nodes.note.output.text. Reply in thread is input.ts. Also post to the channel is at the bottom of the crop.

Reply is Slack: Send message and shows a warning. Result is under Reply.

Send message fieldValue
Channel (channel)input.channel
Message (markdown_text)nodes.note.output.text
Reply in thread (thread_ts)input.ts
Also post to the channel (reply_broadcast)Not set

Also post to the channel says that if it is true for a threaded reply, the message is also posted to the main channel. The template leaves it unset. Message accepts at most 8,000 characters. This note is short. If it fails is Continue (output.ok is false). If the reply does not go out, the issue still exists and the run still succeeds, with replied false. Send message is sent once: Kovca does not retry it. Choose the same Slack account. Studio tests simulate it and do not post. The simulated result includes ok: true, ts: 1762004012.004900, and channel: C08SUPPORT1. This template reads ok only. The sample channel is C08SUPPORT1 even when the trigger channel is C08BUGS0001.

8Test it

Open the Test tab. Login timeout and How-to question are the template's examples. Leave Send real requests off. Issue, React, Reply, and Seen then return their samples and are marked sample. Nothing is written to Jira or Slack. That sample is not what a published API call returns. The Test panel still charges Support Triage when that step succeeds. It does not charge the run fee, and it does not charge a simulated action. See What it costs.

Send real requests is off. 200, 5 credits. seen is skipped. issue, react, and reply are sample. The output ends with seen null.

On this recording the route was bug, so Lower through Mention? did not run, and Seen was skipped. The same Studio session, still with Send real requests off, also ran four other messages.

thanks! came back other, priority low, mentioned false, and Seen ran. No issue.

Please refund the double charge on my invoice. I was billed twice. came back billing, priority medium, mentioned false, and Seen ran. No issue.

I was charged twice for my invoice AND the export button crashes the app with a 500 error came back billing, priority high, and mentioned true. The issue path ran. route stayed default. The summary was the full line, [high] and then that message. Seen was skipped. issue, react, and reply were sample.

The sentence "The dashboard crashes with a 500 error when exporting a CSV. " repeated 60 times came back technical, priority high, route bug. The summary was 255 characters and ended with ….

A billing, account, product, or other result goes to Lower. If the text contains crash, error, or broken, Mention? is true and the issue path runs, with route still default. If it contains none of them, Seen runs, and Summary, Short, Issue, Note, React, and Reply are skipped. The unit-test JSON below is that last path, for the login-timeout text, when the test does not read the message and returns billing. That text contains none of those words.

Before you activate, run messages you have actually seen, including ones that should be filed and ones that should stay in the channel. When the routes look right, turn on Send real requests once, with both accounts chosen, on a message where an extra Jira issue is harmless.

Publish, call it, and activate it

The same workflow can be called over the API. The body uses the trigger's field names. Create an API key under API keys and keep it on your backend.

cURL
curl https://kovca.io/api/v1/workflows/wf_.../execute \
  -H "Authorization: Bearer $KOVCA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: 1732118400.123456" \
  -d '{
    "input": {
      "attachments": [],
      "blocks": [],
      "channel": "C08BUGS0001",
      "channel_type": "channel",
      "files": [],
      "team_id": "T02ACME0001",
      "text": "The login page times out after 30s",
      "ts": "1732118400.123456",
      "user": "U04MARIA01"
    }
  }'

That curl calls a published workflow. The call runs Create issue, the reaction, and the thread reply for real when an issue is filed (bug branch, or Mention? true). The steps need the accounts you chose on them. If an account is missing, the action fails. With If it fails set to stop on Issue, the run stops before the reaction and the reply. A published call does not return the sample you see with Send real requests off.

The JSON below is the output this template's unit test expects for the login-timeout input when Seen is simulated and Support Triage returns billing. The test does not read the message. That text contains none of crash, error, or broken, so Mention? is false and Seen runs. That is one result the step can return. It is not a response from a published API call, and it is not the decision on the Studio recording. In the example, seen is true because the simulated step's sample says ok: true. That does not mean a reaction was added in Slack. How-to question is the other example. On this same test it also takes Seen. A message that contains one of those words is filed even when the category is billing. The unit test checks that path separately. It is not this JSON.

JSON
{
  "request_id": "req_...",
  "run_id": "run_...",
  "workflow": { "id": "wf_...", "version": 1 },
  "status": "succeeded",
  "output": {
    "category": "billing",
    "priority": "low",
    "requires_human_review": false,
    "route": "default",
    "mentioned": false,
    "summary": null,
    "issue_id": null,
    "issue_key": null,
    "filed": null,
    "reacted": null,
    "reply": null,
    "replied": null,
    "seen": true
  },
  "steps": [
    { "id": "input", "status": "succeeded" },
    { "id": "triage", "status": "succeeded" },
    { "id": "bug", "status": "succeeded" },
    { "id": "lower", "status": "succeeded" },
    { "id": "crash", "status": "succeeded" },
    { "id": "error", "status": "succeeded" },
    { "id": "broken", "status": "succeeded" },
    { "id": "mention", "status": "succeeded" },
    { "id": "summary", "status": "skipped", "reason": "branch_not_taken" },
    { "id": "short", "status": "skipped", "reason": "source_skipped" },
    { "id": "issue", "status": "skipped", "reason": "source_skipped" },
    { "id": "note", "status": "skipped", "reason": "source_skipped" },
    { "id": "react", "status": "skipped", "reason": "source_skipped" },
    { "id": "reply", "status": "skipped", "reason": "source_skipped" },
    { "id": "seen", "status": "succeeded" },
    { "id": "output", "status": "succeeded" }
  ],
  "evaluations": 1
}

Look up the run later. This returns status, timing, and steps. It does not return the output. Keep the execute response if you need the decision or the issue key. Runs are kept for 30 days.

cURL
curl https://kovca.io/api/v1/runs/run_... \
  -H "Authorization: Bearer $KOVCA_API_KEY"

1732118400.123456 is a key you choose. Keys are kept for 24 hours. A retry with the same key and the same request returns the original run instead of creating another issue. A new key can create again, because Create issue is not idempotent. Add reaction is safe to retry. Kovca does not store the message or the output. On a delivery whose category is not technical and whose text contains none of crash, error, or broken, route is default, mentioned is false, and the summary, the issue, and the reply come back null. When the text does contain one of those words, route is still default, mentioned is true, and the issue path runs. On a technical message the keyword steps do not run, so mentioned is null and route is bug.

The login-timeout output is the Result fields for that run. mentioned is null. summary is the short line. seen is null.

category technical, priority high, route bug, mentioned null. summary is the login-timeout line. issue_key SUP-212. seen is null.

To run it from the channel, open Activate. The checklist is what's left: connect Slack, connect Jira, and, once the accounts are connected, choose them on the trigger, on Issue, on React, on Reply, and on Seen. It says up to 19 credits per event. The activate row is Publish and activate: run on every new message. The button on that row says Publish & activate. That publishes the draft and starts it. A live automation runs that pinned version. Later edits don't reach it until you publish them to the automation.

The automation is still a draft. Up to 19 credits per event. Connect Slack and Connect Jira are still to do. Tested is checked. Publish and activate runs on every new message. The button is not clicked.

Connect Slack and Jira from the checklist, or from the steps, when the routes in the Test tab look right. Until then, leave the accounts empty and keep Send real requests off. Each sign-in opens a connection page. Kovca keeps an ID for the account.

A new message in the channel starts a run when Slack sends the event. Follow runs on the workflow's Executions page (Studio → Usage → Executions). While an automation is paused, events that arrive are skipped. Kovca does not keep them to run later. A failed run is not retried on its own, because the issue or the reply may already have happened.

If a Slack shortcut is enough

You don't need this if a person can read the channel and the list is short. Jira's Slack app can create an issue from a message shortcut or a slash command. A person still decides which message is a bug, and they still type or accept the summary. That is a fair setup for a few reports a day.

A small script on Slack's events API can post every message in the channel into Jira. That is enough when the channel is already only bugs. It does not separate a question from a bug, and it does not reply with the issue key unless you write that too.

What the workflow adds is the same classification on every message, a Jira issue when the category is technical or when the text contains crash, error, or broken, a reaction on the original message, and a thread reply that includes the issue key from Create issue. You still choose the Slack account and the Jira account, replace C08BUGS0001, BUGS, and Bug, and read a sample of results before you activate it.

Make it yours

  • Point the channel at the one you actually watch. C08BUGS0001 is a stand-in. Set it on the trigger. The reactions and the reply read input.channel, so they follow the message.
  • Use your project key and issue type. BUGS and Bug are stand-ins. Set them on Issue.
  • Use your emoji. ticket and speech_balloon are stand-ins, without colons.
  • Leave questions in the channel. A message that is not technical, and that does not contain crash, error, or broken, only adds a reaction. Clear Seen if that message should stay unmarked.
  • Change the words that also get filed. Crash, Error, and Broken look for those substrings after Lower. crashes matches crash. A message that uses the word error, and is not a bug, is filed too. Edit the three Find values, or delete Mention? and connect the default branch straight to Seen, if only the technical category should be filed.
  • Treat the priority bracket as triage. Support Triage returns low, medium, or high, and the summary prints that word. This template does not set Jira's Priority field. A person may need to change the priority on the issue.
  • File only the urgent bugs. Add a condition after Short that continues when nodes.triage.output.priority equals high, if a medium bug should stay in Slack. That step sits on the shared path, so it covers a technical message and a keyword match.
  • Roll it out on a copy of the channel. Point Only in channel at a test channel for a week and compare the issues with what the team would have filed.
  • Change it without surprising a live channel. Edit the draft and publish the changes to the automation. The running version stays pinned until you do.

What it costs

Credits, and only for steps that succeed. Billing is the list.

A Studio test skips the run fee. It does not skip Support Triage. That step is 5 credits when it succeeds, including a test with Send real requests off. A simulated action is not charged, and an action that fails is not charged. With Send real requests off, Issue, React, Reply, and Seen are simulated, so they add nothing.

  • A Slack event: 6 credits for the run.
  • A published API call: 1 credit for the run.
  • Support Triage: 5 credits when it succeeds.
  • Create issue: 2 credits when it runs for real and succeeds, charged when an issue is filed (bug branch, or Mention? true).
  • Add reaction: 2 credits when it runs for real and succeeds. React runs when an issue is filed. Seen runs when Mention? is false.
  • Send message: 2 credits when it runs for real and succeeds, charged when an issue is filed (bug branch, or Mention? true).

The switch, the condition, the text steps, and the transform steps use no credits. A branch that doesn't run isn't charged. The Activate panel adds every step together, so its number is the cost of the branch that does the most, counted as if every action ran. With this template that number is 19 credits per event: the 6 credit event fee, Support Triage, Create issue, React, Reply, and Seen. A live event that files an issue is 17 credits (the event fee, Support Triage, Create issue, React, and Reply). That is a technical category, and also a message in another category whose text contains crash, error, or broken. A live event that is only marked seen is 13 credits (the event fee, Support Triage, and Seen). The response's credits field is the run's total. See the workflows API, HTTP actions, and automations.

On this page

  • What you'll build
  • Watch the test
  • Build it in the Studio
  • Publish, call it, and activate it
  • If a Slack shortcut is enough
  • Make it yours
  • What it costs

Built on Support Triage: Classify inbound support tickets by category and priority, and flag the ones a person should review.

Keep going

Workflows API
InputLead textLead Intellig…Follow up?Search contac…New contact?Create contactOutput
Lead Intelligence24 min read

Add qualified sales emails from Outlook to HubSpot

Build a Kovca workflow that starts from a new Outlook email, classifies it, and creates a HubSpot contact only when no matching contact is found.

Read guide
InputShipment Inte…Needs action?Ticket subjectOpen support …Output
Shipment Intelligence8 min read

Catch delivery exceptions from carrier tracking events

Build a Kovca workflow that reads every carrier tracking update, spots delays, failed deliveries, address problems, and disputes, and opens a support ticket when someone needs to act. Runs from the carrier's webhook. Step by step in the Studio, with a ready-made template.

Read guide
InputSupport TriageHigh priority?Create incide…Alert textPage on-callAdd reactionJoinOutput
Support Triage14 min read

Escalate urgent Slack channel messages into incidents

Build a Kovca workflow that starts from a new Slack message, classifies it, and on high priority opens an incident, posts to on-call, and reacts on the message.

Read guide
Sign inGet Started