Build an Open-Source Kanban Board with Make.com for SAP Focused Build

This how-to guide explains how to use Make.com to create an open-source Kanban board for SAP Focused Build so you can visualize work packages and streamline delivery.

The approach is based on connecting SAP Focused Build with GitHub, GitHub Projects, and optional tools such as Slack or Microsoft Teams. With Make.com, you can automate data flows from SAP to a Kanban view and keep everything synchronized.

Why use Make.com for an SAP Kanban board?

SAP Focused Build provides strong project and requirements management, but its built-in visualization may not fit every agile team. By combining Make.com with GitHub Projects, you can:

• Visualize SAP work packages and work items as Kanban cards.
• Use flexible, open-source boards for different teams.
• Automate synchronization between SAP and GitHub.
• Notify stakeholders in collaboration tools when tickets change.

The solution is non-invasive: it does not replace SAP Focused Build but augments it with a customizable Kanban interface.

Architecture of the Make.com and SAP Focused Build solution

The overall architecture leverages SAP Focused Build as the system of record while Make.com orchestrates data movement to and from open-source components.

Main components integrated with Make.com

• SAP Focused Build: Source of work packages, work items, and status information.
• GitHub: Repository host and issue tracker for development work.
• GitHub Projects: Kanban-style boards to visualize issues and statuses.
• Communication tools: Slack or Microsoft Teams for notifications.
• Make.com: Integration and automation platform connecting all these systems.

Make.com scenarios link the SAP APIs, GitHub REST API, and collaboration tools so that teams see consistent information across all platforms.

Prerequisites for using Make.com in this use case

Before building the automation, ensure the following prerequisites are in place:

• Access to an SAP Focused Build system and its APIs.
• A GitHub organization or repository where issues can be created.
• A GitHub Project board configured with columns (e.g., To Do, In Progress, Done).
• Accounts and tokens for Slack or Microsoft Teams if you want notifications.
• An active Make.com account with permissions to create and run scenarios.

It is also helpful to have basic familiarity with REST APIs and the data model of SAP Focused Build work packages and work items.

Step-by-step: Build the integration with Make.com

The following steps describe how to design and configure the Kanban integration using Make.com.

Step 1: Design your Kanban and data mapping

Start by defining what you want to see on the Kanban board and how fields should map between SAP Focused Build and GitHub.

1. Identify which SAP Focused Build objects to sync (for example, work packages and work items).
2. Define how SAP statuses map to GitHub issue states and project columns.
3. Decide which attributes (title, description, priority, owner, release, sprint) are required on the Kanban cards.
4. Document one central mapping table: SAP fields on one side, GitHub issue fields on the other.

This design step ensures that when you move to Make.com, every module and transformation has a clear purpose.

Step 2: Prepare SAP Focused Build and API access

To allow Make.com to read from SAP Focused Build, you need stable API access.

1. Work with your SAP team to expose OData or REST endpoints that list work packages and work items.
2. Create a technical user for API access with read permissions (and write permissions if you want to push status changes back).
3. Test the endpoints with a tool such as Postman to confirm authentication and data structure.
4. Note endpoint URLs, credentials, and required parameters for later use in Make.com HTTP modules.

Make sure that filters (for example, project, release, or date) are available so your scenarios only pull relevant work items.

Step 3: Configure GitHub and project boards

Next, prepare GitHub to receive and visualize items coming from SAP via Make.com.

1. Create or choose a repository that will hold the synchronized issues.
2. Set up a GitHub Project (classic or project boards) with columns matching your workflow.
3. Ensure you have a GitHub personal access token with rights to create issues and update project cards.
4. Decide on labels or milestones you wish Make.com to assign when creating issues (for example, release, component, or team).

This preparation enables Make.com to turn SAP work items into GitHub issues that appear on the Kanban board automatically.

Step 4: Build the core Make.com scenario

The core scenario in Make.com is responsible for reading SAP Focused Build data and creating or updating GitHub issues.

1. Create a new scenario: In Make.com, start a blank scenario and choose a scheduling or webhook trigger.
2. Add an HTTP module for SAP: Configure an HTTP GET call to the SAP Focused Build endpoint that lists work items to sync.
3. Parse the response: Use JSON parsing and mapping tools in Make.com to extract fields such as ID, title, description, status, and assignee.
4. Search or create GitHub issues: Add GitHub modules or HTTP modules to check if a corresponding issue already exists (for example, by SAP ID stored in the issue title or body). If missing, create a new issue.
5. Update the GitHub project board: For each issue, use GitHub Project APIs to place it into the correct column based on the mapped SAP status.
6. Log and handle errors: Add routes to capture failed calls, log them, and optionally send them to a monitoring channel.

By scheduling this scenario in Make.com to run periodically, your Kanban board remains synchronized with SAP Focused Build.

Step 5: Add reverse synchronization and status updates

Some teams need SAP to reflect changes made directly on the Kanban board. You can extend the Make.com design to handle this.

1. Create a second scenario: Use a webhook or scheduled trigger to poll GitHub for updated issues or project card movements.
2. Identify changes: Compare issue status, labels, and project columns with the last known values.
3. Map back to SAP statuses: Use the same mapping table in reverse to derive the proper SAP Focused Build status.
4. Call SAP APIs: With Make.com HTTP modules, send PATCH or POST requests to update the corresponding work item in SAP.

Carefully test this bidirectional approach to avoid conflicting updates.

Step 6: Integrate notifications with Make.com

Many teams want visibility when important work items change state. Make.com makes it easy to connect collaboration tools.

1. Add a route in your core scenario that watches for key status changes (for example, moved to testing or ready for production).
2. Insert Slack or Microsoft Teams modules to send channel messages containing links to the GitHub issue and SAP object.
3. Include summary details such as title, priority, assignee, and target release in the message body.
4. Use filters in Make.com so only relevant teams get notified, for example by component or project.

This creates an end-to-end flow where SAP changes trigger updates on the Kanban board and alerts in your collaboration channels.

Best practices for running Make.com in production

When using Make.com for a production Kanban integration, keep these best practices in mind:

• Start with a pilot project: Test the scenarios on a limited set of SAP work items before scaling.
• Monitor runs: Use Make.com run history and error handling to detect failed calls early.
• Version your mappings: Keep your SAP-to-GitHub field mappings under version control or documentation so changes are traceable.
• Respect API limits: Configure scheduling and pagination in Make.com to stay within SAP and GitHub rate limits.
• Secure credentials: Store API keys and tokens securely within Make.com and rotate them according to your security policies.

With these guidelines, your integration remains robust and maintainable over the long term.

Further resources for Make.com and SAP Focused Build

To see the original use case description and deeper technical background, review the official guide here: Open-source Kanban board for SAP Focused Build.

If you need consulting support to extend your automations beyond this Make.com scenario, you can explore services from specialized partners such as Consultevo.

By combining SAP Focused Build, GitHub Projects, and Make.com, organizations can achieve a flexible, open-source Kanban solution that keeps development teams aligned with SAP-driven processes while retaining full control over visualization and collaboration.

Need Help With Make.com?

If you want expert help building, automating, or scaling your Make scenarios, work with ConsultEvo — certified workflow and automation specialists.

Get Help