Team Co-Authoring for Power Apps Canvas Apps: A Hands-On Walkthrough

Reviewing a single developer editing a canvas app is like having one person type on a shared document while everyone else watches. For years, Power Apps enforced a strict “lock” model: if a colleague opened the app, you saw an “editing locked” message and could only open the file in read-only mode. That bottleneck has finally been removed. Co-authoring uses a Git repository to let multiple people work on the same canvas app at the same time, each in their own copy of the studio, merging their work when they save.

This walkthrough covers the entire setup—from creating a private Git repository to syncing changes as a team—using a realistic example based on a small IT Support Hub app. You’ll learn how to enable the feature, connect it to GitHub, and avoid common pitfalls. By the end, your team will be able to work in parallel without stepping on each other’s toes.

Our Scenario: The “IT Assist” App

Imagine a small team—Priya, Jordan, and Sam—building a canvas app called IT Assist. The app lets employees submit support tickets, track status, and view a knowledge base. Before co-authoring, they had to take turns editing or create separate copies of the app, making merging changes a nightmare. With Git-based co-authoring, each developer opens the same app from the same environment, and their changes are saved to a shared repository.

How Git-Based Co‑Authoring Works

When Git version control is enabled, Power Apps does not open a single, locked app file. Instead:

Each developer gets their own studio instance of the app.
When a developer presses Save (the sync button), a commit is pushed to the connected Git repository.
The repository merges the commit with changes from other developers, then pulls the merged version back into the studio.
If conflicts arise (e.g., two people edited the same screen property), Power Apps attempts an automatic merge. If it cannot resolve the conflict, the developer must manually decide which change to keep.

This is not real-time collaboration like Google Docs. It is an asynchronous, branchless workflow where everyone commits to the main branch.

Prerequisites

A Power Apps per‑user license for each developer (Plan 1 or higher).
A GitHub account (free tier is sufficient) or an Azure DevOps organization.
Each developer must be a user in the same Microsoft 365 tenant.

Power Apps co‑authoring is now generally available. The steps below use the current Power Apps maker portal (make.powerapps.com).

Setting Up a Co‑Authoring Workspace

1. Create a Private Git Repository on GitHub

Repository name: it-assist-coauth (no spaces)
Description: “Private repository for the IT Assist canvas app co‑authoring demo.”
Visibility: Private – do not use public, as the app’s source code is stored here.

Do not initialize the repository with a README, .gitignore, or license. Power Apps will handle the initial structure.

After creation, you will see the repository URL, for example:

plaintextGitHub repository URL

https://github.com/your-org/it-assist-coauth

2. Activate Git Version Control in Power Apps

In the maker portal, go to Settings (gear icon) → General → Git version control.

Turn on the toggle Enable Git version control. This exposes the connection form used in the next step.

3. Connect the Repository to Your App

Open the app IT Assist (or create a new canvas app) and navigate to Settings → Git version control → Connect.

Fill in the form with the following values:

Git repository URL: paste the full GitHub URL from step 1, for example https://github.com/your-org/it-assist-coauth. Do not append .git to the URL.
Branch: main (Power Apps only works with the main branch)
Directory name: app (the source code must be stored in a subfolder, not the root)

Click Apply.

Power Apps will ask for credentials. Use your GitHub username and a personal access token (PAT) as the password.

4. Generate and Store a Personal Access Token

A PAT is required for Power Apps to authenticate with GitHub. Share this token securely among the team because it will be needed every time a developer opens the app.

To create a new token:

On GitHub, go to Settings → Developer settings → Personal access tokens → Tokens (classic).
Click Generate new token (classic).
Give the token a descriptive name, set a sensible expiration (e.g., 90 days), and select the repo scope (Full control of private repositories).
Click Generate token and copy the token immediately. You won’t be able to see it again.

Back in Power Apps, when prompted, enter your GitHub username and the PAT for the password field. Power Apps will connect to the repository and create an initial set of branches.

Token Security

Treat the PAT like a password. Store it in a secure vault or a password manager shared only with the team. Rotate it periodically, especially when a developer leaves the project.

Each developer must be a co-owner of the Power Apps app and a collaborator on the GitHub repository.

In Power Apps:

From the list of apps in make.powerapps.com, find IT Assist, click … → Share.
Add the team members and check Co-owner. They need this role to open the app for editing.

On GitHub:

Go to your repository → Settings → Collaborators and teams.
Add each developer’s GitHub account (they must first accept the invitation).

The Daily Collaboration Rhythm

Once everything is connected, each developer opens the app from the maker portal. They see the same app but can edit independently.

Editing flow: One person adds a new screen, another modifies a gallery. They both press Save (the sync icon) to commit their work.
Syncing: When you press Save, you commit your changes, pull the latest from the repo, and merge. The studio then reloads with the merged result.
Merge conflicts: If two developers change the same control property, a conflict occurs. Power Apps highlights the conflicting files and asks you to resolve—usually by keeping one version.

Tip

Encourage your team to communicate about which screens or components they are working on. Use the “Refresh” button in the studio to pull the latest version from the repo without saving your own changes.

Important Boundaries and Limitations

Branch‑locked to main: Power Apps co‑authoring only works with the main branch. Feature branches must be merged manually outside of Power Apps.
No real‑time cursors: You won’t see another developer moving controls. Changes appear only after a save and sync.
File conflicts: The automatic merge is coarse. If you change the same formula expression, you might need to resolve by editing the .msapp file manually (not recommended for beginners).
Private repositories required: Public repositories are not supported for co‑authoring.
Token expiration: Every developer must re‑enter a valid PAT when the token expires.

Troubleshooting Common Problems

Symptom	Likely cause	Solution
“App locked for editing” still appears	Git version control not enabled, or not connected for this app	Check that the toggle is on and the repository URL is correct
can’t connect to repository	PAT is expired or has wrong scopes	Generate a new PAT with `repo` scope
Changes by another developer missing	They have not pressed Save (sync) or you haven’t pressed the sync/refresh button	Ensure everyone saves frequently and refreshes before editing
Merge conflict error after save	Two developers changed the same property/control	Open the conflict viewer, choose which version to keep, and save again
Cannot open app after connecting repo	The repository’s directory is not `app` or the branch is not `main`	Disconnect and reconnect with correct parameters

Recommendations for a Smooth Experience

Set up a regular sync cadence – Save and sync every 15–20 minutes to minimize conflicts.
Use a shared naming convention – Prefix screens with the owner’s initials (PS_TicketList, JM_TicketDetail) to avoid accidental overlaps.
Keep the repo access up‑to‑date – When a new developer joins, grant them co‑owner rights in Power Apps and collaborator rights on GitHub right away.
Test non‑main branches outside of Power Apps – If you need to experiment without affecting others, create a copy of the app and work on that, then merge manually.
Document the PAT rotation process – Add a recurring calendar reminder to renew tokens before they expire.

Conclusion

Git co‑authoring transforms Power Apps from a single‑player tool into a team platform. With this guide, your team can now build, test, and maintain canvas apps together, reducing wait times and improving code quality. The setup takes less than an hour and pays off the first time two developers avoid a merge headache.

If you prefer Azure DevOps, the same concepts apply—the only differences are the repository URL format and the location of the PAT. The rest of the workflow remains identical.

References

Original article by Matthew Devaney: Allow Multiple Power Apps Developers To Simultaneously Edit Canvas Apps
Microsoft Learn – Set up Git version control for canvas apps (placeholder): https://learn.microsoft.com/en-us/power-apps/maker/canvas-apps/co-authoring-canvas-apps
GitHub documentation – Personal access tokens: https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens