The Problem: Keeping Project Stakeholders in the Loop

Development teams live in GitHub. Product managers, designers, and executives often live in Notion. This disconnect creates a common project management headache: developers open, update, and close issues in GitHub, while someone else manually copies that information into a Notion board to keep the wider team informed.

This manual process is slow, prone to human error, and creates information silos. Updates get missed, stakeholders work with outdated information, and developers waste time in meetings providing status updates that should be readily available.

The Solution: Automated, Real-Time Syncing

By using n8n, you can build a powerful workflow that acts as a bridge between GitHub and Notion. This automation listens for changes to issues in a specific GitHub repository and instantly creates or updates corresponding items in a Notion database.

The result is a single source of truth for project tasks. Developers can work uninterrupted in their preferred environment, while the entire team gets a real-time, high-level view of progress directly in Notion.

Why Automate This Workflow?

• Real-Time Visibility: Eliminate the lag between a task's true status in GitHub and its representation in Notion.
• Single Source of Truth: Ensure everyone from engineering to marketing is looking at the same, up-to-the-minute project data.
• Reduce Context Switching: Allow developers to stay focused on code without needing to jump into another tool to update a status card.
• Improve Collaboration: Non-technical team members can easily track progress, link documents, and add comments in Notion without needing a GitHub account.

Prerequisites

Before you start building, you'll need a few things:

• An active n8n instance (cloud or self-hosted).

• A GitHub account with admin access to a repository.

• A Notion account and a workspace where you can create integrations.

• A pre-configured Notion database to serve as your issue tracker.

Setting Up Your Notion Database

Your Notion database needs specific properties to store the data from GitHub. Create a new database with the following properties:

• Issue Title (Title)
• Status (Select - with options like 'Open', 'In Progress', 'Closed')
• GitHub URL (URL)
• Issue Number (Number)
• Repo (Text)
• Last Updated (Last edited time)

This structure ensures a clean mapping from a GitHub issue to a Notion database item.

Example n8n Workflow: Syncing GitHub Issues to Notion

This workflow will handle two primary scenarios: creating a new page in Notion when a GitHub issue is opened, and updating the status of that page when the issue is closed.

Step 1: The Trigger - GitHub Trigger Node

The workflow starts when an event happens in GitHub. We'll use the GitHub Trigger node to listen for issue-related events.

1. Add a GitHub Trigger node to your canvas.

2. Authenticate your GitHub account by creating new credentials.

3. In the 'Events' parameter, select issues.

4. You can leave the 'Events on Resource' parameter as * to listen for all issue events (like opened, edited, closed, labeled).

5. Specify your repository in the 'Repository' field (e.g., your-username/your-repo).

This node will now activate every time an issue is created, edited, or closed in your specified repository.

Step 2: The Logic - Route Based on Action

GitHub sends different 'action' payloads for different events. We need a way to handle new issues differently from closed issues. The IF node is perfect for this.

1. Add an IF node and connect it to the GitHub Trigger node.

2. Set a condition to check the action.

3. Click 'Add Condition' > 'String'.

4. In the first value field, use an expression to get the action from the trigger node: {{ $json.action }}.

5. Set the 'Operation' to 'Equals'.

6. Set the second value to opened.

Now, the 'true' output of the IF node will only run when a new issue is created.

Step 3: The Action - Create a Notion Page

Connect a Notion node to the 'true' output of the IF node.

1. Authenticate your Notion account. You will need to create a new integration in Notion and share your target database with it.
2. Set 'Resource' to Database/Page.
3. Set 'Operation' to Create.
4. Select your Notion issue tracker database in the 'Database ID' field.
5. Now, map the properties. Use the expression editor to pull data from the GitHub Trigger node:

• Issue Title: {{ $json.issue.title }}

• Status: Select your 'Open' status option.

• GitHub URL: {{ $json.issue.html_url }}

• Issue Number: {{ $json.issue.number }}

• Repo: {{ $json.repository.full_name }}

When you run this, a new issue in GitHub will automatically create a corresponding, properly filled-out page in your Notion database.

Step 4: Finding and Updating Existing Pages

What happens when an issue is closed? We need to find the existing Notion page and update its status.

1. Connect another IF node to the 'false' output of the first one. This will handle all actions that are not opened.

2. Set its condition to check if the action equals closed: {{ $json.action }} 'Equals' closed.

3. Connect a Notion node to the 'true' output of this second IF node.

4. Set 'Resource' to Database/Page and 'Operation' to Get Many.

5. Select your database.

6. Click 'Add Filter' and select 'Filter on a Property'. Choose your 'Issue Number' property.

7. Set the condition to 'Equals' and use the expression {{ $json.issue.number }} to find the page with the matching issue number.

8. Add another Notion node, connected to the 'Get Many' node.

9. Set 'Resource' to Database/Page and 'Operation' to Update.

10. For the 'Page ID' field, use an expression to get the ID of the page found in the previous step: {{ $node['Notion1'].json.results[0].id }}.

11. Under 'Properties', update the 'Status' property by selecting your 'Closed' status option.

Putting It All Together

Your final workflow logic will look like this:

1. GitHub Trigger: Fires on any issue event.

2. IF (Is Opened?): Checks if action is opened.

• True Path: Notion node creates a new page.

• False Path: Proceeds to the next check.

3. IF (Is Closed?): Checks if action is closed.

• True Path:

• Notion node ('Get Many') finds the page by Issue Number.

• Notion node ('Update') updates the found page's status to 'Closed'.

Activate your workflow, and you now have a fully automated bridge between your development work and your project management board. This simple automation saves countless hours and ensures your entire team is always on the same page.