GitHub & GitLab Integration: Auto-Close Tasks When PRs Merge

Introduction

You just merged a pull request. The CI pipeline is green, the feature works, and you feel the quiet satisfaction of closing a browser tab. Then you remember: the task card. It's still sitting in "In Progress" on your project board, mocking you. You switch tabs, find the card, drag it to "Done," and wonder -- for the hundredth time -- why this isn't automatic.

It turns out you're not alone. A GitHub Octoverse report found that developers context-switch between tools dozens of times per day, and project board updates are among the most frequently forgotten tasks. The board drifts out of sync with reality, stakeholders lose trust in it, and eventually nobody checks it at all.

FlowBoard's native GitHub and GitLab integration eliminates this entire category of busywork. When you merge a PR or MR, the linked task automatically moves to "Done." No manual updates, no stale boards, no tab-switching guilt. Here's how it works and how to set it up in five minutes.

What You Get

With FlowBoard's GitHub/GitLab integration, you get:

• Auto-Link PRs/MRs to Tasks: Based on branch name patterns, PRs are automatically linked
• Status Tracking: See PR/MR status (Open, Merged, Closed) directly on your tasks
• Auto-Move on Merge: Tasks automatically move to "Done" when the PR/MR is merged
• Activity Comments: Comments are added to tasks when they're linked or moved
• "Just Merged" Badge: A visual warning that the deployment might still be in progress

Branch Naming Convention

The magic happens through branch names. FlowBoard recognizes task numbers in branch names using these patterns:

feat/#123_feature_description_username
fix/#456_bug_fix_description_username

Where #123 is the task number from FlowBoard. When you create a branch with this pattern and open a PR, FlowBoard automatically links them.

Pro Tip: Copy Branch Names

When you start working on a task in FlowBoard, click "Copy Branch Name" to get the correctly formatted branch name. Paste it when creating your branch:

git checkout -b feat/#123_add_dark_mode_john

Setting Up GitHub Integration

Setting up GitHub integration takes just a few minutes:

1. Go to your GitHub repository → Settings → Webhooks
2. Click "Add webhook"
3. Configure:
   • Payload URL: https://europe-west3-flowwboard.cloudfunctions.net/githubWebhook?workspace=YOUR_WORKSPACE_ID
   • Content type: application/json
   • Events: Select "Pull requests"
4. Click "Add webhook"

That's it! Your GitHub repository is now connected to FlowBoard.

Setting Up GitLab Integration

GitLab setup is equally simple:

1. Go to your GitLab project → Settings → Webhooks
2. Configure:
   • URL: https://europe-west3-flowwboard.cloudfunctions.net/gitlabWebhook?workspace=YOUR_WORKSPACE_ID
   • Trigger: Check "Merge request events"
3. Click "Add webhook"

How the Workflow Works

1. Start a Task

In FlowBoard, start working on a task and copy the generated branch name.

2. Create Your Branch

Use the copied branch name when creating your feature branch:

git checkout -b feat/#123_implement_user_auth_alice

3. Open a Pull Request

When you push and open a PR, FlowBoard automatically:

• Detects the task number from the branch name
• Links the PR to the task
• Shows the PR status on the task card
• Adds a comment to the task

4. Merge the PR

When the PR is merged, FlowBoard automatically:

• Updates the PR status to "Merged"
• Moves the task to "Done"
• Adds a merge comment with details
• Shows a "Just Merged" badge for 20 minutes

The "Just Merged" Badge

When a task moves to done via a merge, FlowBoard shows a pulsing "Just Merged" badge for 20 minutes. This is a helpful warning for QA testers and team members:

• The CI/CD pipeline might still be running
• The deployment might not be complete yet
• You might want to wait before testing

The badge automatically disappears after 20 minutes, indicating it's safe to test.

Why This Beats Manual Updates

Manual task updates have several problems:

• Forgotten Updates: Developers forget to update tasks after merging
• Inconsistent Status: Board doesn't reflect actual code state
• Wasted Time: Context switching between GitHub and task board
• Delayed Visibility: Team doesn't know when work is actually done

With automatic integration, your board is always in sync with your code. No more hunting for "is this actually merged?" or manually moving cards. This is part of a broader pattern: the less manual upkeep your tool requires, the more your team will actually use it.

Best Practices

• Use FlowBoard's branch generator: Always copy the branch name from FlowBoard
• One PR per task: Keep PRs focused for clean tracking
• Include task number in PR title: As backup, add #123 to your PR title
• Respect the badge: Wait for "Just Merged" to disappear before testing
• Review linked PRs: Use the task view to see all code changes

Frequently Asked Questions

How do you sync GitHub or GitLab issues with a project management tool?

The most reliable approach is webhook-based integration. When events occur in your repository -- such as a pull request being opened or merged -- the webhook sends a payload to your PM tool's API, which updates the corresponding task automatically. This avoids manual syncing and ensures your board always reflects the actual state of your code.

How does branch-to-task linking work?

Branch-to-task linking uses a naming convention to connect code branches to task board items. By including the task number in your branch name (e.g., fix/#123_bug_description), the PM tool can parse the branch name from webhook events and automatically associate pull requests with the correct task. No manual linking required.

Can task statuses update automatically when code is committed or merged?

Yes. With a webhook configured on your repository, your PM tool receives events for pull request actions. When a PR is merged, the tool can automatically move the linked task to "Done." This eliminates the most common source of stale boards -- developers forgetting to update task status after merging their code.

Do I need a paid plan for GitHub or GitLab webhook integration?

No. Webhooks are a free feature on both GitHub and GitLab, including free-tier accounts. The integration uses standard webhook payloads and does not require any paid GitHub Apps or GitLab premium features. Setup typically takes less than five minutes per repository.

Conclusion

GitHub and GitLab integration transforms your development workflow. No more manual task updates, no more out-of-sync boards, no more wasted time. Your code and your tasks stay perfectly aligned.

Set up the webhook once, use the branch naming convention, and let FlowBoard handle the rest. It's one of those small automations that saves hours over time. If you're also using chat tools, pair this with Slack or Teams notifications so the whole team sees merge activity without opening the board. And if you want to take automation even further, see how an AI agent can autonomously fix bugs using this same integration.