Skip to content

18 Migration from ALM Accelerator

RemyDuijkeren edited this page Nov 1, 2026 · 5 revisions

Migration from ALM Accelerator for Power Platform

The ALM Accelerator for Power Platform was deprecated in 2025. This guide moves its export and deploy pipeline, plus plugins and web resources, to Flowline.


Deployment model: what changes

ALM Accelerator was designed for environments with multiple makers you do not fully control. Makers shared DEV, and the PR pipeline was the gatekeeper.

Flowline assumes your team owns the DEV environment. You pull when DEV is ready, then deploy when the commit is tested. There is no PR-based promotion.

ALM Accelerator Flowline
DEV environment Shared, multiple makers Team-owned
Source of truth Source control (after export) DEV environment
Promotion trigger Pull request + pipeline flowline deploy {env}
Code-first ALM Delegates to developer's existing tooling First-class (push, generate)

If your team does not own the DEV environment (shared maker environment, ISV model, AppSource distribution), Flowline is not the right fit. Use Pipelines for Power Platform for the no-code pipeline and manage code-first components separately.


What maps to what

ALM Accelerator Flowline Notes
Solution export → ADO branch commit flowline pull Exports from DEV, unpacks to Solution/src/, git-ready
Solution import to Test flowline deploy test Packs from source, imports unmanaged
Solution import to UAT flowline deploy uat With DTAP version-check gate
Solution import to Prod flowline deploy prod With DTAP version-check gate
Plugin assembly deployment flowline push plugins
Web resource deployment flowline push webresources
Plugin + web resource deployment flowline push
Solution version increment flowline pull --bump patch Auto before export
Early-bound type generation flowline generate
Bootstrap from existing solution flowline clone
Create a brand-new publisher + solution flowline init DEV-only (Sandbox/Developer); ALM Accelerator has no equivalent, since it assumes the solution exists
Verify connection flowline status
Service principal auth (CI/CD) pac auth create --kind ServicePrincipal
Per-env deployment settings (conn refs, env vars) flowline settings apply <target> Run after deploy. Reads the pac solution create-settings format. See 09-Settings
Solution Checker in pipeline flowline deploy (built-in gate) Blocks on Critical findings automatically. See 08-Deploy#solution-checker-gate
PR / ADO approval gate Partial: DTAP version-check See DTAP gates
Azure Pipelines YAML templates Manual, see Step 5 No generator yet
Deployment history No equivalent
Teams / email notifications No equivalent
Canvas admin app (maker portal) No equivalent, Flowline is CLI-only

Before you start

  • Install PAC CLI: dotnet tool install --global Microsoft.PowerApps.CLI.Tool
  • Install Flowline: dotnet tool install --global Flowline
  • Authenticate to your DEV environment: pac auth create --environment https://your-dev.crm4.dynamics.com
  • Verify: flowline status

Two-phase migration strategy

You can do it in one pass, but two phases change one thing at a time.

Phase 1, code-first components only (ALM Acc pipeline stays running)

Replace plugin registration and web resource sync using standalone mode. flowline push only touches plugins and web resources, so your ALM Acc pipeline keeps running unchanged.

# Plugins only
flowline push plugins --path ./bin/Release/MyPlugins.dll --solution-name MySolution --env https://your-dev.crm4.dynamics.com

# Web resources only
flowline push webresources --path ./WebResources/dist --solution-name MySolution --env https://your-dev.crm4.dynamics.com

Run with --dry-run first.

Plugin registration attributes: if you use spkl, Daxif, or PACX attributes, see that tool's migration guide for replacing them.

Phase 2, full pipeline replacement (retire ALM Acc)

Set up the Flowline project structure and replace ALM Acc's export and deploy pipeline stages with flowline pull and flowline deploy.


Step 1: bootstrap the project

Bootstrap the project structure from the existing solution in your DEV environment, then register each other environment by passing its URL via --env; Flowline infers the role from the URL or asks interactively:

flowline clone MySolution --env https://your-dev.crm4.dynamics.com
flowline clone MySolution --env https://your-test.crm4.dynamics.com
flowline clone MySolution --env https://your-prod.crm4.dynamics.com

This creates:

  • .flowline holds environment URLs and solution config
  • Solution/ holds <SolutionName>.cdsproj and the unpacked solution XML
  • Plugins/ holds <SolutionName>.Plugins.csproj
  • WebResources/ holds <SolutionName>.WebResources.csproj

Commit the unpacked solution XML in Solution/src/.


Step 2: replace solution export

flowline pull replaces the export-and-commit step:

# ALM Accelerator flow:
# Canvas app → Export → commit to ADO branch → open PR

# Flowline
flowline pull

flowline pull exports from DEV, bumps the patch version, and unpacks to Solution/src/. Commits, branches and PRs are yours.

# Typical pull → commit flow
flowline pull
git add Solution/src
git commit -m "pull: MySolution patch bump"

To skip the auto-bump (re-pull without incrementing the version):

flowline pull --bump none

Step 3: replace solution deployment

flowline deploy replaces the pack and import stages:

# ALM Accelerator pipeline:
# Pack → solution checker → import to Test → (PR approval) → import to UAT/Prod

# Flowline
flowline deploy test
flowline deploy uat
flowline deploy prod

It packs from Solution/src/, imports to the target, and cleans up orphans. The target must be authenticated (see Step 4).


Step 4: replace authentication

Flowline uses PAC CLI auth profiles instead of variable groups and service connections.

For interactive use (DEV, daily work):

pac auth create --environment https://your-dev.crm4.dynamics.com

For CI/CD (service principal per environment):

# Test
pac auth create --kind ServicePrincipal \
  --applicationId $CLIENT_ID \
  --clientSecret $CLIENT_SECRET \
  --tenant $TENANT_ID \
  --environment https://your-test.crm4.dynamics.com

# Prod (repeat for each additional environment)
pac auth create --kind ServicePrincipal \
  --applicationId $CLIENT_ID \
  --clientSecret $CLIENT_SECRET \
  --tenant $TENANT_ID \
  --environment https://your-prod.crm4.dynamics.com

Run flowline status to verify all environment connections are active.


Step 5: wire up CI/CD

Flowline has no generated pipeline templates. Adapt these to your repo.

GitHub Actions

name: Flowline Deploy
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install tools
        run: |
          dotnet tool install --global Microsoft.PowerApps.CLI.Tool
          dotnet tool install --global Flowline

      - name: Authenticate to Test
        run: |
          pac auth create --kind ServicePrincipal `
            --applicationId ${{ secrets.CLIENT_ID }} `
            --clientSecret ${{ secrets.CLIENT_SECRET }} `
            --tenant ${{ secrets.TENANT_ID }} `
            --environment ${{ secrets.TEST_ENV_URL }}

      - name: Build plugins
        run: dotnet build Plugins/MySolution.Plugins.csproj -c Release

      - name: Push plugins
        run: flowline push plugins

      - name: Deploy to Test
        run: flowline deploy test

Add a separate job (or workflow) gated on the Test job for UAT/Prod promotion.

Azure Pipelines

trigger:
  - main

pool:
  vmImage: windows-latest

steps:
  - task: PowerShell@2
    displayName: Install tools
    inputs:
      targetType: inline
      script: |
        dotnet tool install --global Microsoft.PowerApps.CLI.Tool
        dotnet tool install --global Flowline

  - task: PowerShell@2
    displayName: Authenticate to Test
    inputs:
      targetType: inline
      script: |
        pac auth create --kind ServicePrincipal `
          --applicationId $(ClientId) `
          --clientSecret $(ClientSecret) `
          --tenant $(TenantId) `
          --environment $(TestEnvUrl)

  - task: DotNetCoreCLI@2
    displayName: Build plugins
    inputs:
      command: build
      projects: Plugins/MySolution.Plugins.csproj
      arguments: -c Release

  - task: PowerShell@2
    displayName: Push plugins
    inputs:
      targetType: inline
      script: flowline push plugins

  - task: PowerShell@2
    displayName: Deploy to Test
    inputs:
      targetType: inline
      script: flowline deploy test

Use Environments in Azure Pipelines to gate UAT and Prod stages behind manual approvals.


DTAP gates

Flowline gates promotion like this:

  • DEV block: flowline deploy refuses a DEV target.
  • Version check: deploying to UAT or Prod checks that the predecessor environment already carries the version being deployed, so you cannot skip environments. Deploying v1.2 to Prod fails if UAT is still on v1.1; promote to UAT first.

There's no approval gate. Restrict who can trigger flowline deploy prod with Azure DevOps Environments approvals or GitHub Actions environment: production protection rules.

Clone this wiki locally