End-to-end process of building, validating, and distributing custom apps and add-ins across Microsoft 365 platforms
Yes. The pattern described matches the source-control conflict scenario for shared solution components: when multiple developers or teams change the same component, changes can collide if they end up in the same underlying file or metadata artifact.
Best practices to reduce overwrites on a shared entity like Case:
- Use unmanaged solutions only in development environments Keep active customization in development as unmanaged, and deploy to non-development environments as managed. This helps keep development flexible while protecting higher environments from direct edits.
- Move to managed deployments for test and production A documented ALM anti-pattern is allowing unmanaged solutions into test and production. That creates layering and integrity problems and makes it easier for teams to overwrite each other’s work.
- Treat DevGrp as the controlled integration environment Instead of having each team independently re-add the full Case entity and push back broad metadata, use DevGrp as the place where changes are consolidated through a build/deployment process. The case study shows that a build process from development to test to production, with restricted developer access to higher environments, improves reliability.
- Use source control for solution files
The documented team-development model is:
- each team gets the latest source,
- works in independent environments,
- exports and extracts the solution,
- submits only the changed files when possible.
- Minimize broad entity-level changes in separate team solutions The main problem in the scenario is that both teams are packaging the same shared entity metadata. If both teams include the full Case entity in separate solutions, each import can carry an older version of shared metadata and overwrite the other team’s updates. Reduce the scope of what is added to each solution so only the required components are included.
- Adopt automation and validation in the pipeline The documented guidance recommends partially automated ALM with Azure Pipelines, automated build deployments, and solution checker reports. This reduces manual packaging/import mistakes and improves traceability.
- Establish governance for shared components For a common entity owned functionally by multiple teams, define a governance process for who can change shared Case metadata, how conflicts are triaged, and how fixes are promoted. The case study specifically calls out governance, bug triage, and restricting direct access as key improvements.
- Keep publishers to a minimum Multiple publishers increase complexity when moving components between solutions. Keeping the number of publishers low is a documented best practice.
A practical approach for the scenario:
- Keep team work in separate development environments.
- Store solution files in source control.
- Before either team starts Case changes, sync to the latest source from DevGrp.
- Avoid exporting/importing a broad Case entity package unless necessary.
- If both teams changed the same Case metadata, reconcile those changes in source control before importing back to DevGrp.
- Use an automated pipeline to build and deploy the consolidated solution forward.
- Deploy managed solutions to downstream environments.
The core issue is not only collaboration; it is that both teams are modifying and redeploying the same shared entity metadata. The documented fix is a stronger ALM model: source control, controlled merge/reconciliation, managed downstream deployments, automation, and governance around shared components.
References: