A human gate in your pipeline, answered from WhatsApp

Last updated 17 November 2026

By Mumen Tayyem, founder of Jabee

Published 17 November 2026.

There are two ways to put a person in front of a production deploy. One is to make the pipeline wait for a click in a web interface. The other is to make it ask somebody, wherever that person is, and carry on when they answer.

GitHub has the first, and it is good: environments with required reviewers, up to six people or teams, one approval enough to proceed. Two things about it are worth knowing before you plan around it. On private repositories it needs a paid plan — GitHub's own documentation puts environment protection rules on Team and Pro, with Free limited to public repositories. And the approval lives inside GitHub, so the reviewer gets an email and a page to open, which on a Sunday evening is a laptop and a password manager away.

This is the second way, in about fifteen lines, on any CI that can run curl.

The gate

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Ask a person
        env:
          JABEE_KEY: ${{ secrets.JABEE_KEY }}
        run: |
          set -euo pipefail
          ID=$(jq -n \
                --arg t "Deploy ${GITHUB_REF_NAME} to production?" \
                --arg b "${GITHUB_ACTOR} pushed ${GITHUB_SHA:0:7}" \
                --arg u "${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}" \
                --arg x "deploy-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}" \
                '{title:$t, body:$b, url:$u, external_id:$x,
                  options:["approve","skip"], expires_in_minutes:60}' \
              | curl -sS -X POST https://api.jabee.ai/api/v1/approvals \
                  -H "Authorization: Bearer $JABEE_KEY" \
                  -H "Content-Type: application/json" --data-binary @- \
              | jq -r .id)

          for _ in $(seq 1 120); do
            STATUS=$(curl -sS "https://api.jabee.ai/api/v1/approvals/$ID" \
                       -H "Authorization: Bearer $JABEE_KEY" | jq -r .status)
            [ "$STATUS" = "pending" ] || break
            sleep 15
          done

          echo "answer: $STATUS"
          [ "$STATUS" = "approved" ]

      - name: Deploy
        run: ./deploy.sh

The last line is the gate: the step exits non-zero on anything but approved, so the deploy step never runs. skipped, expired, failed and cancelled all stop the pipeline, which is the correct reading of every one of them — nobody said yes.

Three details that are not decoration. The payload is built with jq -n rather than interpolated into a JSON string, because a branch name is attacker-controlled in your own CI and "title": "$BRANCH" is an injection waiting to happen. external_id includes GITHUB_RUN_ATTEMPT, so a re-run asks a fresh question while a retried curl inside the same attempt returns the request already made instead of buzzing somebody twice. And expires_in_minutes is set, so a question nobody answers dies rather than holding a runner until the job times out.

What the person sees

A message on WhatsApp with the title, the body, a link to the run, and Approve and Skip buttons. Tapping one answers the request; the status changes and the next poll sees it. Add "edit" to options and they get a third button that returns free text — "yes, but staging first" — which arrives in response_text. An edited answer is not an approval, and the snippet above treats it as a stop; if you want to act on the words, read them and decide.

It goes to the handset your business verified, from Jabee's own approved sender. There is no WhatsApp number to buy, no business verification to sit through, and no message template to get through review.

Polling, or a webhook

The loop above polls because a CI runner has no public address. If the thing being gated is a long-running service rather than a job, a webhook is better: approval.answered is posted to your endpoint, signed t=<unix>,v1=<hex> as the HMAC-SHA256 of <t>.<raw body>. Verify over the raw bytes, compare in constant time, and refuse a timestamp older than five minutes. Working receivers in Node and Python, with tests for the tampered and replayed cases, are in the examples folder.

Either way the rate limit matters: 60 API calls a minute per key. A fifteen-second poll uses four.

When GitHub's own reviewers are the right answer

Often. If your repository is public, or you are already on Team, and your reviewers live in GitHub during working hours, environment protection rules cost nothing extra and keep the audit trail in the same place as the code. Use them.

The case for asking on WhatsApp instead is narrower and worth stating plainly: a private repository on a free plan, a pipeline that is not GitHub Actions at all, a reviewer who is not a GitHub user — a client signing off a release, an operations manager approving a migration window — or an approval that has to reach somebody who is not at a desk. The same endpoint also gates things that are not deploys, which is where most of its use turns out to be: a refund over a limit, a quote, an outbound email to a list, a step an AI agent is about to take.

Setup is one key and one secret: make the key under Management then Approvals in the dashboard, put it in your repository secrets as JABEE_KEY. The full field reference is on the approvals page, and the GitHub Actions page has the simpler case — a failed workflow messaging you, with no question attached.

Questions

Does GitHub's required-reviewers feature cost money? On private repositories, yes — GitHub's documentation places environment protection rules on Team and Pro, with the Free plan limited to public repositories. Up to six people or teams can be required reviewers and one approval is enough to proceed.

What happens if nobody answers? The request expires at expires_in_minutes and the status becomes expired, which the gate treats as a refusal, so the deploy does not run. Set the expiry to something shorter than your job timeout.

Can I use this outside GitHub Actions? Yes. It is two authenticated HTTP calls, so GitLab CI, Jenkins, CircleCI, a Makefile or a deploy script all work the same way. Nothing in it is GitHub-specific except the environment variables used to build the message.

Does a re-run ask again? Yes, because external_id includes the run attempt. A retried curl within the same attempt is the same id and returns the existing request rather than sending a second message.

How do I stop a lost phone approving a deploy? The same way you would with any approval: the person answering is the handset your business verified, so treat that device as a credential. For a stricter trail, record what you did with the answer against the request and read it back later.

Is an "edited" answer a yes? No. edited means the person sent words instead of tapping Approve, and those words are in response_text. Treat it as a stop unless your code reads the text and decides deliberately.