Skip to content
Sign inRequest access

Channels: Slack, Telegram, Teams & webhooks

Channels reach your team collectively, where they already work. Where email and in-app preferences are per user, a channel is a shared destination: a Slack channel, a Telegram chat, a Microsoft Teams channel, or your own signed webhook. uMarker posts a project’s activity there as events occur, with no uMarker login required to see them.

Channels are additive to personal notifications. They don’t replace them; they broadcast the same events to a place the whole team can see.

uMarker splits a channel into two things, and it’s worth understanding the split before you set one up:

The connection: account level

The credential itself: the Slack webhook URL, the Telegram bot token and the chat you picked, your endpoint. Entered once on the account’s Integrations page, and reusable everywhere.

The route: project level

Which project sends to it, and which events. Added from that project’s Distribution tab. One connection can serve any number of projects.

That means an agency pastes a Slack URL once and then attaches it to ten client projects with different event selections, rather than re-pasting the same credential per project. It also means disconnecting a credential warns you by name which projects lose their routing — with one limit that matters if you use more than one space.

The four kinds, and what each plan includes

Section titled “The four kinds, and what each plan includes”
Kind What uMarker sends Included from
Generic signed webhook A structured, signed JSON payload Free (every plan)
Slack (incoming webhook) A readable message with a link Starter (99 ⃁)
Telegram (your bot, posting to a chat you pick) The same readable message Starter (99 ⃁)
Microsoft Teams (Workflows webhook) The same readable message Professional (249 ⃁)

A kind your plan doesn’t include is shown on the Integrations page locked, naming the plan that unlocks it, never hidden. There’s also a cap on how many connections an account holds at once, and channels share it with issue trackers: 1 on Free, 3 on Starter, 10 on Professional, 25 on Agency, counted account-wide across both kinds. A connected GitHub uses one of them — so on Free you have room for a tracker or a channel, not both.

A route subscribes to any of these seven:

Event Fires when
new_feedback New feedback is submitted to the project
assigned A report is assigned to a member
mentioned A member is @mentioned in a comment
status_change A report’s status changes
priority A report’s priority changes
resolved A report is resolved, or a pin in its thread is
issue_linked A report is linked to an external tracker issue

Each route also has an Enabled switch. Disable it to stop delivery without deleting the routing; re-enable to resume.

On the account’s Integrations page, press Connect on the tool’s card. A guided panel opens, the same shape for every tool:

  1. How to connect. Numbered steps, each with a direct link that opens the right page in the other service, and the fields you fill in right there in the step that asks for them. You’re only asked for what that service needs: uMarker fills in any fixed address itself, so you never assemble an API URL by hand.

  2. Test. Press Send test message. uMarker delivers a real message, clearly labelled as a test, to exactly what is on screen. Check that it arrived.

  3. Save. Connect turns on once a test passes. If you change anything after the test, the panel says so and asks you to test again before saving.

If the destination is down right now and you want to save it anyway, Save without a passing test is there, named for what it does. A Slack, Teams or webhook URL must still be a public https address (see Endpoint safety).

When a test or a save is refused, the panel tells you why in your language, as a cause and a What to do: line. The service’s own text sits folded under Details from the service, with any secret scrubbed out of it.

Once saved, the credential is encrypted at rest and never shown back to you. For a generic webhook, uMarker also mints a 40-character signing secret, which you see after connecting.

What you do in each service:

  1. Create a Slack app for your workspace, and choose From scratch. The step’s link opens Slack’s new-app page.
  2. In the app, open Incoming Webhooks and switch it on. Press Add New Webhook and pick the channel.
  3. Copy the webhook URL Slack gives you (it starts https://hooks.slack.com/…) and paste it into Endpoint URL.
  4. Press Send test message, see it arrive in the channel, then Connect.

uMarker posts a Block Kit message: the headline, the report’s details as fields, and buttons to open it (see What a message looks like). No app install, bot, or OAuth is involved; the webhook URL is the whole integration.

That URL is a bearer credential in disguise: anyone holding it can post into your channel. That is why uMarker encrypts it at rest and never shows it back.

Each channel gets the message in its own platform’s format, so a triager can decide priority and owner without opening the report:

  • Telegram: a bold headline, the details below it, and an Open report button. Telegram only accepts buttons that point to a public https address, so on a platform without one the link is written into the text instead.
  • Slack: a Block Kit message — the headline, the details as fields, and buttons — with a plain-text fallback for the notification preview.
  • Microsoft Teams: an Adaptive Card with the headline, the details as a list of facts, and an Open report button.
  • Generic webhook: the same machine-readable payload as before, plus the human-readable text in a message field for convenience.

Every message carries what happened and who did it, the report’s headline, and the project, status, priority, assignee, reporter, page, device and browser, number of pins, and labels when there are any. Empty fields are left out, not shown as blanks. Then the event itself:

Event What the message adds
status_change The status, from → to
priority The priority, from → to
mentioned The comment, quoted, and its author
assigned Who it’s assigned to
issue_linked The tracker and issue key, with an Open … in … button (for example “Open MD-45 in Jira”)

Messages are written in your account’s language, right-to-left for Arabic, and anything a person typed is escaped so it can’t break the formatting. Long text is shortened to fit each platform’s limit. Send test message uses the same renderer with a sample report, so the test shows exactly what real messages will look like.

  1. Open the project and go to its Distribution tab.

  2. Attach the connection you just made.

  3. Tick the events this project should forward through it.

  4. Save. It starts posting on the next matching event.

  5. Press Test on the route to confirm the wiring before you rely on it. It delivers a real message, labelled as a test, without needing an existing report.

Repeat for each project. The same connection can carry different event selections in different projects: reports from a client site going to that client’s channel, mentions only, and so on.

The generic webhook is the one you wire into your own systems, so it’s signed. uMarker POSTs a JSON body and includes a signature over the exact bytes it sends, together with a timestamp, in the header:

X-uMarker-Signature: t=<unix-ts>,v1=HMAC_SHA256(<t>.<raw-body>, secret)

Your receiver recomputes the same HMAC-SHA256 with the shared secret and compares: a match proves authenticity and integrity; a tampered body won’t match. For the payload fields and a copy-paste verification example, see Outbound webhooks.

If a secret leaks, rotate it. Rotate secret on the connection replaces it with a fresh 40-character value. It needs the integrations.rotatechannel permission, which is also what decides whether the secret is shown back to you: on the Integrations page, only a role holding it sees the signing secret under Manage. Without it the connection shows its endpoint and no secret.

uMarker validates every channel URL you paste (Slack, Teams, generic webhook) when you test or save it. The endpoint must use https, and its host must resolve only to public addresses. Anything that resolves to a private, loopback, link-local, or otherwise reserved range is rejected:

The endpoint must be a public https URL — private or internal addresses are not allowed.

This is an SSRF guard: it stops a channel from being pointed at localhost, an internal service, or the cloud metadata endpoint (169.254.169.254). A host that won’t resolve at all is refused too: the check fails closed. As defence in depth, delivery refuses to follow redirects and resolves IPv4 only, so a public URL can’t 302 its way to an internal address, or slip an unvetted IPv6 record past the guard, at send time. See Security & privacy overview.

Every post is dispatched to a queue, so it never blocks the action that triggered it, and each destination is delivered independently: one channel failing never affects another channel, your email, or other recipients.

Delivery uses a 10-second timeout, and what happens next depends on whether your destination answered.

  • It answered, with anything other than a 2xx: retried up to three attempts, backing off 10 then 30 seconds.
  • It couldn’t be reached — DNS failure, refused connection, timeout: retried the same way for the generic webhook, whose payload carries an event id your receiver can dedupe on. For Slack, Teams and Telegram it is not retried and the delivery fails immediately. Those take no idempotency key, so a retry would announce the same report in your channel two or three times with nothing to tell the readers it was one event.

If it still can’t deliver, the connection is flagged:

  • Its card on the Integrations page turns its status dot amber and says Needs attention, with the cause in plain words. Press Manage for the full picture per connection: the cause, a What to do: line, and the destination’s own words folded under Details from the service. The dot is per tool rather than per endpoint, so with two Slack hooks connected and one failing, the Slack card is amber for both — Manage lists them separately.
  • The project’s Distribution tab shows the same cause and fix on each affected route. A channel route has Test again right there; a tracker route links to Test it again in Integrations, where its credential lives.
  • Delivery to every other connection and to email is unaffected.
  • The next successful send clears the flag automatically.

Disconnecting removes the stored credential. If projects in the space you’re currently in route through it, uMarker refuses the first attempt and names them, so you find out before their notifications go quiet rather than after. Confirm, and the connection and all of its routes are deleted together — including routes in your other spaces, which the warning does not name.

To stop one project without touching the others, disable or remove that project’s route instead, from its Distribution tab.