Power Platform Solutions: A Complete Guide

Introduction

If you’ve worked with Power Platform for any length of time, you’ve likely run into Solutions. They are the backbone of Application Lifecycle Management (ALM) in Power Platform — the mechanism that packages, moves, and governs your apps, flows, tables, and configurations across environments.

Yet, many developers and makers treat solutions as an afterthought — building straight into the Default solution and then struggling when it’s time to promote their work to production.

This guide covers everything you need to know about Solutions: what they are, the different types, how to move them across environments, and best practices.

What Is a Solution?

A Solution in Power Platform is a container — a zip package — that holds components like:

• Canvas Apps and Model-Driven Apps
• Power Automate Cloud Flows
• Dataverse Tables, Columns, Views, Forms, Charts
• Business Rules, Business Process Flows
• Dashboards, Reports
• Environment Variables, Connection References
• Chatbots (Copilot Studio bots)
• Security Roles, Site Maps

Think of a Solution as a deployment unit. Instead of manually recreating everything in each environment, you export a solution from Dev, import it into Test, and then into Production — cleanly and repeatably.

Key Insight: Solutions are how Microsoft expects you to do ALM on Power Platform. If you bypass them, you’ll pay the price later.

The Default Solution vs. the Common Data Services (CDS) Default Solution

This is one of the most commonly confused areas for new Power Platform developers.

The Default Solution

The Default Solution is an unmanaged solution that acts as a catch-all bucket. When you:

• Navigate to make.powerapps.com
• Click on Solutions → Default Solution

…you’ll see everything in the environment — apps, flows, tables, and components — whether they were built inside a solution or not. The Default Solution is essentially a lens into the entire environment.

Key characteristics:

• It cannot be exported — so you can’t use it for ALM/deployment
• It contains both managed and unmanaged components
• It’s a useful debugging/discovery tool, but not a development home

The CDS Default Solution (Common Data Services Default Solution)

The CDS Default Solution (also called the Common Data Service Default Solution) is a special managed solution published by Microsoft. It contains:

• The standard Dataverse tables (Account, Contact, Lead, Opportunity, etc.)
• The core Dataverse schema that ships out of the box

It is not something you customize directly. Your customizations — whether extending standard tables or creating new ones — should live in your own solution.

Rule of thumb: Your organization’s IP lives in your custom solution, not Default or CDS Default.

What Happens When You Create Apps/Flows Outside Any Solution?

This is the #1 mistake new Power Platform makers make.

When you build a Canvas App or a Cloud Flow from the home screen (not from within a solution), the component is created directly in the environment and only shows up in the Default Solution.

The Hidden Risk: “Can I just add it to a solution later?”

Yes — Microsoft allows you to add existing components to a solution. However:

1. Dependencies won’t always follow. If your flow uses a connection not tracked in the solution, those connections won’t migrate.
2. Environment Variables and Connection References — if not used from the start, are painful to wire in after the fact.
3. Other components referencing your app/flow won’t know they’re part of the same package.

Best Practice: Always create your components from within a solution. Create the solution first, then build everything inside it.

Managed vs. Unmanaged Solutions

This is the most critical distinction to understand in Power Platform ALM.

Unmanaged Solutions — Your Dev Workspace

When you create a solution, it starts as unmanaged. In an unmanaged solution:

• You can add, edit, and delete all components
• You can see the source/implementation of everything
• You can export it either as Unmanaged or Managed
• Deleting the solution keeps the components in the environment (only the container is removed)

Managed Solutions — Your Deployment Package

When you export an unmanaged solution as Managed and import it into another environment:

• The components are locked — end-users cannot directly edit them
• The solution publisher controls what (if anything) can be customized via Managed Properties
• Deleting the managed solution removes all its components and associated data cleanly
• You upgrade by importing a newer version

The Golden Rule of ALM

Dev Environment    →    Test Environment    →    Production Environment
(Unmanaged)             (Managed import)         (Managed import)

Never import an unmanaged solution into Test or Production. This breaks the separation of concerns and makes rollbacks nearly impossible.

Exporting and Importing Solutions

Exporting a Solution

To export a solution:

1. Go to make.powerapps.com → Solutions
2. Select your solution → click Export solution
3. Choose Publish (to include latest changes)
4. Select export type:
   • Unmanaged — for backup or source control of your dev work
   • Managed — for deploying to Test/Production

The export produces a .zip file.

Importing a Solution

To import into a target environment:

1. Switch to your target environment
2. Go to Solutions → Import solution
3. Browse and select your .zip file
4. Review the import options:
   • Update — updates existing components (default for same version)
   • Upgrade — replaces the old solution version (removes deleted components)
   • Stage for Upgrade — stages the new version alongside the old (allows testing before finalizing)

Import Options Explained

Allow Customization (Managed Properties)

When you distribute a Managed solution, you can control what customizers in the target environment can change. This is done through Managed Properties.

Setting Managed Properties

Before exporting as Managed:

1. Open your solution in the Dev environment
2. Select a component (e.g., a table or field)
3. Click Managed Properties (or the ... menu → Managed Properties)
4. Configure the properties

Common Managed Properties

The “Allow Customizations” Toggle

The Allow customizations property is a master override:

• ON (default): The target environment can extend and customize the component (add columns to a table, modify views, etc.)
• OFF: The component is completely locked. No changes allowed whatsoever.

Use Case: If you’re an ISV (Independent Software Vendor) distributing your solution to customers, you’d turn Allow customizations OFF to protect your IP and ensure stability.

Publisher ISV builds solution
        ↓
Sets "Allow Customizations" = OFF on core tables
        ↓
Exports as Managed
        ↓
Customer imports — cannot touch those tables

Patch Options

Solution Patches are a way to ship incremental updates to an existing managed solution without releasing an entirely new full version. Think of them as delta packages.

How Patches Work

1. Create a patch from an existing solution (Solutions → select solution → ... → Clone a Patch)
2. The patch gets a sub-version number (e.g., 1.0.0.0 → 1.0.1.0)
3. Add only the changed components to the patch
4. Export the patch as Managed → Import to target environments
5. The patch only contains what changed — it’s smaller and faster to deploy

Important Patch Rules

• A patch cannot remove components from a solution — only add or modify
• Patches must be imported on top of the base solution in the same version
• You can have multiple patches on the same base version (P1, P2, P3…)
• Eventually, you should clone the solution (not patch) to create a new full version that consolidates all patches

Clone a Solution vs. Clone a Patch

Applying the Upgrade (Merging Patches)

When you’re ready to clean up and release a full new version:

1. Create a new Clone Solution (e.g., version 2.0.0.0) that includes all patch changes
2. Export as Managed
3. Import into target environment with Upgrade option
4. The system merges the patches with the base, removes the old version cleanly

Solution Publisher

Every solution has a Publisher — essentially metadata that identifies who built the solution. The Publisher defines:

• Display Name: e.g., “Contoso Corporation”
• Name (prefix): e.g., contoso
• Option value prefix: A number prefix for choice columns (e.g., 10000)

The prefix is applied to all custom components: contoso_MyTable, contoso_MyColumn, etc.

Best Practice: Create a custom publisher for your organization before building solutions. The default publisher has the prefix cr + a random number — ugly and confusing.

Environment Variables & Connection References

These two concepts are solution-aware features that make solutions portable:

Environment Variables

Environment variables let you store configuration values (URLs, settings, keys) outside the app/flow logic, so they can be set differently per environment.

Dev:  SharePoint URL = "https://contoso.sharepoint.com/sites/dev"
Test: SharePoint URL = "https://contoso.sharepoint.com/sites/test"
Prod: SharePoint URL = "https://contoso.sharepoint.com/sites/prod"

When you import a solution, you’re prompted to set environment variable values — your flow automatically uses the right URL without editing.

Connection References

Connection References are pointers to connections (SharePoint, Outlook, Dataverse) stored in the solution. When you import, you map the connection reference to a real connection in the target environment — keeping the flow itself unchanged.

Best Practices Summary

Quick Reference Cheat Sheet

Conclusion

Solutions are the heart of disciplined Power Platform development. Whether you’re building for a single team or distributing an app to thousands of customers, understanding the difference between managed and unmanaged solutions, how patches work, and what allow customization means will save you enormous headaches down the road.

The key takeaways:

• Always build inside a solution with a proper publisher
• Dev is unmanaged, Test/Prod are managed — no exceptions
• Patches for hotfixes, Clone Solution for new versions
• Environment Variables + Connection References make solutions portable
• Managed Properties protect your IP when distributing