Easy Azure DevOps Backup - Visual Studio Marketplace

Azure DevOps Backup & Restore Extension

Enterprise-grade protection for Azure DevOps.

Automate backup and restore for repositories, pipelines, work tracking data, and team configurations. Recover quickly from incidents, human error, or migration issues.

🚀 Why Choose This Extension?

✅ Complete Protection - Cover your most critical Azure DevOps assets in one run
✅ Lightning Fast - Incremental mode captures only what changed
✅ Disaster Recovery Ready - Restore full projects or selected components
✅ Pipeline Native - Run natively in Azure Pipelines
✅ Your Storage, Your Control - Keep backups in infrastructure you control

📦 What Gets Backed Up?

Resource	Backup Coverage	Highlights
Git Repositories	Full repository history	Branches, tags, and commits
Pull Requests	PR metadata and discussions	Comments, reviews, status, and votes
Build Definitions	Pipeline definitions and settings	Complete build pipeline configurations
Build History	Build records (up to 100 per definition/run)	Preserved for audit and reporting; restore is not supported by Azure DevOps APIs
Release Definitions	Classic release definitions	Stages, approvals, gates, and environments
Service Connections	Connection metadata and configuration	Connection setup is preserved; secret values must be re-entered due to Azure DevOps API limitations
Work Items	Fields, links, revisions, and attachments	Detailed history, relationships, and attachments preserved; cross-project and cross-organization restore supported via two-phase ID mapping
Pipeline Variables	Variable groups and non-secret values	Variable structure is preserved; secret values must be re-entered due to Azure DevOps API limitations
Shared Queries	Query folders and definitions	Team query structure is preserved
Task Groups	Task group definitions and parameters	Cross-project restore supported
Boards	Board settings, columns, and swimlanes	Team board setup is preserved; some custom columns may require manual updates due to Azure DevOps API limitations
Dashboards	Dashboard layouts and widget configurations	Dashboard layout restores reliably; some advanced widgets may need manual tuning due to Azure DevOps API limitations
Wiki	Wiki content and page hierarchy	Structure and pages restored as backed up
Areas & Iterations	Classification nodes (area paths and iteration paths)	Team area hierarchy and sprint/iteration schedules; restore is additive (never deletes); supports cross-project and cross-organization restore; selective restore of areas-only or iterations-only available

🎯 Key Features

Incremental Backups

Run daily backups that capture only new or changed data. Reduce backup time by up to 80% without sacrificing coverage.

Dry-Run Mode

Preview exactly what will change before restore. Ideal for validation, approvals, and compliance workflows.

Selective Operations

Back up or restore only what you need. Select Git only, Builds only, or any custom combination.

Enterprise Logging

Get detailed logs for troubleshooting, audits, and operational reviews.

📋 Available Pipeline Tasks

1. Azure DevOps Backup Task

Back up all resources or only selected components with flexible filters.

Key Parameters:

Incremental Mode - Only backup new/changed resources
Project Filter - Backup specific projects only
Component Selection - Choose all components or select specific ones (Git, Pull Requests, Builds, Releases, Service Connections, Work Items, Variables, Queries, Task Groups, Boards, Dashboards, Wiki)
Verbose Logging - Detailed operation logs

2. Azure DevOps Restore Task

Restore all resources or selected components with granular control.

Key Parameters:

Project Filter - Restore specific projects only
Component Selection - Choose all components or select specific ones (Git, Pull Requests, Builds, Releases, Service Connections, Work Items, Variables, Queries, Task Groups, Boards, Dashboards, Wiki)
Resource Filtering - Restore specific repositories, build definitions, release definitions, work item IDs, or query folders
Target Project - Optionally restore to a different project or organization (single source project only)
Cross-Organization Restore - Set TargetOrganizationUrl and TargetPat to restore work items to a different Azure DevOps organization; work item relations automatically relinked via two-phase ID mapping
Dry Run - Preview changes without applying them
Verbose Logging - Detailed operation logs

🔧 Quick Start

Step 1: Set Up Variable Group

Create a variable group named "ADO Backup Restore":

Backup.LicenseKey     [Secret]  Your license key
Backup.AdoPat.RO      [Secret]  Read-only PAT for backups
Backup.AdoPat.RW      [Secret]  Read-write PAT for restores
Backup.Root           [Plain]   Backup directory path

Step 2: Add Backup Task to Pipeline

Add the backup task to your pipeline:

- task: AzureDevOpsBackupTask@0
  displayName: 'Daily Incremental Backup'
  env:
    ADOBACKUP_LICENSE_KEY: $(Backup.LicenseKey)
  inputs:
    Pat: '$(Backup.AdoPat.RO)'
    BackupRoot: '$(Backup.Root)'
    Verbose: true
    BackupMode: 'Incremental'

Step 3: Schedule Automated Backups

Schedule automated backups:

schedules:
  - cron: "0 2 * * *"
    displayName: Daily Backup at 2 AM
    branches:
      include:
        - main

🔄 Component Selection

Use include-based flags for simple component selection:

BackupAll / RestoreAll checkbox (default: ✅ checked) - Backup/restore all components
When unchecked, use Include checkboxes to select specific components:
- ✅ Include Git Repositories
- ✅ Include Pull Requests
- ✅ Include Build Definitions
- ✅ Include Release Definitions
- ✅ Include Service Connections
- ✅ Include Work Items
- ✅ Include Pipeline Variables
- ✅ Include Shared Queries
- ✅ Include Task Groups
- ✅ Include Boards
- ✅ Include Dashboards
- ✅ Include Wikis
- ✅ Include Areas & Iterations
  - Selective Restore (Restore Only):
    - ☑️ Restore Areas Only - Restore only area paths
    - ☑️ Restore Iterations Only - Restore only iteration paths

Benefits

Intuitive: Select exactly what to protect
Simple: Run Git-only, pipeline-only, or full backups
Flexible: Restore only areas or only iterations when needed
Clear: Configuration intent is obvious at a glance

💡 Usage Examples

Example 1: Complete Daily Backup

Backup everything with incremental mode for fast, efficient backups:

name: DailyBackup_$(Date:yyyyMMdd)
trigger: none

schedules:
  - cron: "0 2 * * *"
    displayName: Daily Backup
    branches:
      include:
        - main

pool:
  vmImage: 'windows-latest'

variables:
  - group: 'ADO Backup Restore'

jobs:
- job: BackupJob
  displayName: 'Backup Azure DevOps'
  timeoutInMinutes: 120

  steps:
    - task: AzureDevOpsBackupTask@0
      displayName: 'Incremental Backup'
      env:
        ADOBACKUP_LICENSE_KEY: $(Backup.LicenseKey)
      inputs:
        Pat: '$(Backup.AdoPat.RO)'
        BackupRoot: '$(Backup.Root)'
        Projects: ''  # Empty = all projects
        Verbose: true
        BackupMode: 'Incremental'
        BackupAll: true  # Backup all components (default)

    - task: PublishBuildArtifacts@1
      displayName: 'Upload Backup Logs'
      condition: always()
      inputs:
        PathtoPublish: '$(Backup.Root)/logs'
        ArtifactName: 'BackupLogs-$(Build.BuildNumber)'
      continueOnError: true

Example 2: Selective Backup (Git Repositories Only)

Backup only Git repositories when you have separate solutions for other resources:

- task: AzureDevOpsBackupTask@0
  displayName: 'Backup Git Repositories Only'
  env:
    ADOBACKUP_LICENSE_KEY: $(Backup.LicenseKey)
  inputs:
    Pat: '$(Backup.AdoPat.RO)'
    BackupRoot: '$(Backup.Root)'
    Projects: 'Project1,Project2'  # Specific projects
    Verbose: true
    BackupMode: 'Full'
    BackupAll: false  # Selective backup
    IncludeGit: true  # Only include Git repositories
    GitRepositories: 'Repo1,Repo2'  # Specific repositories

Example 3: Disaster Recovery - Dry Run

Preview restore operations before executing for disaster recovery validation:

- task: AzureDevOpsRestoreTask@0
  displayName: 'Disaster Recovery Dry Run'
  env:
    ADOBACKUP_LICENSE_KEY: $(Backup.LicenseKey)
  inputs:
    Pat: '$(Backup.AdoPat.RW)'
    BackupRoot: '$(Backup.Root)'
    Projects: 'CriticalProject'
    DryRun: true  # Preview only, no changes
    Verbose: true
    RestoreAll: true  # Restore all components (default)

Example 4: Selective Restore (Builds Only)

Restore only build definitions after configuration changes:

- task: AzureDevOpsRestoreTask@0
  displayName: 'Restore Build Definitions'
  env:
    ADOBACKUP_LICENSE_KEY: $(Backup.LicenseKey)
  inputs:
    Pat: '$(Backup.AdoPat.RW)'
    BackupRoot: '$(Backup.Root)'
    Projects: 'MyProject'
    
    # Selective restore - only builds
    RestoreAll: false
    IncludeBuilds: true  # Only include builds
    
    BuildDefinitions: '1,2,5'  # Specific build definition IDs
    DryRun: false
    Verbose: true

Example 5: Weekly Full + Daily Incremental Strategy

Combine full and incremental backups for optimal protection:

schedules:
  # Full backup every Sunday
  - cron: "0 1 * * 0"
    displayName: Weekly Full Backup
    branches:
      include:
        - main
  
  # Incremental backup weekdays
  - cron: "0 2 * * 1-6"
    displayName: Daily Incremental Backup
    branches:
      include:
        - main

jobs:
- job: BackupJob
  steps:
    - powershell: |
        $isFullBackup = (Get-Date).DayOfWeek -eq 'Sunday'
        Write-Host "##vso[task.setvariable variable=BackupMode]$(if ($isFullBackup) {'Full'} else {'Incremental'})"
      displayName: 'Determine Backup Mode'
    
    - task: AzureDevOpsBackupTask@0
      displayName: '$(BackupMode) Backup'
      env:
        ADOBACKUP_LICENSE_KEY: $(Backup.LicenseKey)
      inputs:
        Pat: '$(Backup.AdoPat.RO)'
        BackupRoot: '$(Backup.Root)'
        BackupMode: '$(BackupMode)'
        Verbose: true

Example 6: Selective Restore - Areas & Iterations Only

Restore only classification nodes (area paths and iteration paths) to replicate team structure:

- task: AzureDevOpsRestoreTask@0
  displayName: 'Restore Areas & Iterations'
  env:
    ADOBACKUP_LICENSE_KEY: $(Backup.LicenseKey)
  inputs:
    Pat: '$(Backup.AdoPat.RW)'
    BackupRoot: '$(Backup.Root)'
    Projects: 'SourceProject'
    TargetProject: 'TargetProject'  # Cross-project restore

    # Selective restore - only areas & iterations
    RestoreAll: false
    IncludeAreasAndIterations: true

    DryRun: true  # Preview first
    Verbose: true

Example 7: Restore Areas Only (Selective)

Restore only area paths without iteration paths:

- task: AzureDevOpsRestoreTask@0
  displayName: 'Restore Area Paths Only'
  env:
    ADOBACKUP_LICENSE_KEY: $(Backup.LicenseKey)
  inputs:
    Pat: '$(Backup.AdoPat.RW)'
    BackupRoot: '$(Backup.Root)'
    Projects: 'SourceProject'
    TargetProject: 'TargetProject'

    # Selective restore - areas only
    RestoreAll: false
    IncludeAreasAndIterations: true
    RestoreAreasOnly: true  # Only area paths

    DryRun: false
    Verbose: true

Example 8: Restore Iterations Only (Sprint Schedules)

Restore only iteration paths (sprint schedules) without area paths:

- task: AzureDevOpsRestoreTask@0
  displayName: 'Restore Sprint Schedules'
  env:
    ADOBACKUP_LICENSE_KEY: $(Backup.LicenseKey)
  inputs:
    Pat: '$(Backup.AdoPat.RW)'
    BackupRoot: '$(Backup.Root)'
    Projects: 'SourceProject'
    TargetProject: 'TargetProject'

    # Selective restore - iterations only
    RestoreAll: false
    IncludeAreasAndIterations: true
    RestoreIterationsOnly: true  # Only iteration paths

    DryRun: false
    Verbose: true

Example 9: Cross-Organization Work Items Restore

Restore work items to a different Azure DevOps organization with automatic relation relinking:

- task: AzureDevOpsRestoreTask@0
  displayName: 'Restore Work Items to Different Organization'
  env:
    ADOBACKUP_LICENSE_KEY: $(Backup.LicenseKey)
  inputs:
    Pat: '$(Backup.AdoPat.RW)'           # Source organization PAT
    BackupRoot: '$(Backup.Root)'
    Projects: 'SourceProject'            # Single source project required
    TargetOrganizationUrl: 'https://dev.azure.com/TargetOrg'
    TargetPat: '$(Target.AdoPat.RW)'     # Target organization PAT
    TargetProject: 'TargetProject'       # Target project in target org

    # Selective restore - work items only
    RestoreAll: false
    IncludeWorkItems: true

    DryRun: true  # Preview first, then set to false
    Verbose: true

🔐 Security Best Practices

Use Separate PAT Tokens

For Backups (Read-Only):

Code: Read
Build: Read
Work Items: Read
Variable Groups: Read
Service Connections: Read
Project and Team: Read

For Restores (Read-Write):

Code: Read & Write
Build: Read & Write
Work Items: Read & Write
Variable Groups: Read & Write
Service Connections: Read & Write
Project and Team: Read & Write

For Cross-Organization Restores (Target Organization PAT):

Work Items: Read & Write
Project and Team: Read

Secure Storage

Store PAT tokens as secret variables in variable groups
Use Azure Key Vault for enterprise credential management
Rotate tokens regularly (90-day expiration recommended)
Never commit credentials to source control

Backup Encryption

Use encrypted storage for backup directories
Enable BitLocker on backup drives (Windows)
Use Azure Blob Storage with encryption at rest
Implement access controls on backup locations

🛠️ Prerequisites

Azure DevOps organization with appropriate permissions
Personal Access Token (PAT) with required scopes
.NET 10 runtime installed on the Azure DevOps agent used for backup and restore operations
Backup storage location (local path, network share)
Valid license key for production use

⚠️ Limitations & Known Issues

Understanding the limitations helps you plan your backup and restore strategy effectively. Most limitations are due to Azure DevOps API constraints or Git protocol requirements.

API & Platform Limitations

Component	Limitation	Impact	Workaround/Notes
Work Items	Cross-project and cross-organization restore supported; requires single source project when specifying TargetProject or TargetOrganizationUrl	Work items recreated in target with new IDs; relations automatically relinked via two-phase ID mapping	Set TargetOrganizationUrl + TargetPat for cross-org; source-to-target ID mapping saved to .metadata/id-mapping.json
Work Items	Restore updates existing work items without adding comments	No audit trail of restore operation	Work item history shows field changes but not restore event
Work Items	Incremental backup uses daily granularity, not exact timestamp	May backup some items twice if run multiple times per day	Incremental mode tracks last backup date (YYYY-MM-DD), not time
Work Items	Deleted work items are recreated with new IDs during restore	Original IDs cannot be preserved	Links and relationships are recreated with new IDs
Queries	Query definitions restored/updated as-is	Existing queries are updated with backup data	Verify area paths and iteration paths exist in project before restore
Pull Requests	Full PR record is restored (title, description, comments, reviews, status, votes)	Code changes already exist in Git history from merge	PRs are recreated with all discussion and review data
Pull Requests	PR IDs preserved only when restoring to same project	Cross-project restore may create new IDs	Work item links in PRs are preserved if work items exist
Service Connections	Secrets/credentials are NOT backed up	Credentials will be lost	Must manually re-enter secrets after restore
Service Connections	Pipeline authorizations must be reconfigured	Pipelines won't have access until reauthorized	Manually authorize pipelines to use connections after restore
Git Repositories	Non-fast-forward pushes fail if remote history diverged	Restore fails if repository changed after backup	See Git-specific limitations below
Azure DevOps API	Rate limiting varies by organization tier	Backup may be throttled on high-volume operations	Reduce `MaxParallelism`, space out backups, or contact Microsoft for limit increase
Build History	Maximum 100 builds per definition per backup run	Can't backup more than 100 builds in single run	Use `--days` parameter with incremental mode to capture builds over time, build history is kept locally for reference and cannot be restored due to Azure DevOps limitations
Build Definitions	Existing definitions are updated during restore	Definition configuration is overwritten	Review changes before restore; use `--dry-run` to preview
Variable Groups	Passwords/secrets are NOT backed up	Secret values will be lost	Document secret variables separately; re-enter after restore
Variable Groups	Existing variable groups are updated during restore	Variable group values are overwritten (except secrets)	Secrets must be manually re-entered after restore
Boards	Custom columns may not restore correctly	Azure DevOps API rejects certain column configurations	Board is restored but some columns may be missing; verify after restore
Boards	Board auto-creation not supported	Board must exist in target project before restore	Boards are updated, not created; ensure target boards exist
Boards	Column state mappings may be rejected by API	API returns "Value cannot be null. Parameter name: options"	Backup preserved for reference; manual board configuration may be needed
Boards	WIP limits may not be preserved	Column WIP limits may revert to defaults	Verify WIP limits after restore; adjust manually if needed
Boards	Card styling/colors may not be preserved	Custom card styles may revert to defaults	Cosmetic only; reconfigure card styles after restore if needed
Dashboards	Widget configurations may not restore fully	Some widget types have API limitations	Dashboard created but some widgets may need manual reconfiguration
Wiki	Empty wikis restore as empty	Wiki structure restored but no pages if backup had none	Expected behavior; add pages as needed
Areas & Iterations	Restore is additive only	Never deletes existing nodes	Restore adds/updates nodes but doesn't remove nodes that aren't in backup; manually delete unwanted nodes if needed
Areas & Iterations	Node IDs may change during restore	New nodes created if original doesn't exist	Node structure preserved but IDs may differ; paths remain the same
Areas & Iterations	Iteration dates preserved as-is	Sprint dates restored exactly as backed up	Verify iteration dates match target project timeline; adjust manually if needed

Git-Specific Limitations

Scenario	Issue	Error Message	Solution
Diverged History	Remote repository has commits not in backup	`NonFastForwardException: cannot push because a reference that you are trying to update on the remote contains commits that are not present locally`	Option 1: Force push (loses remote commits) Option 2: Manually merge changes Option 3: Delete remote repo and restore fresh
Branch Protection	Branch policies prevent force push	Push fails due to branch policies	Temporarily disable branch policies during restore
Large Repositories	Git clone/push timeout on repos >50GB	Operation timeout or memory errors	Increase timeout, use `--MaxParallelism 1` for large repos
LFS Objects	Git LFS files require separate authentication	LFS files may not restore correctly	Ensure LFS credentials are configured

Security Limitations

Feature	Limitation	Recommendation
Secret Variables	Pipeline variable secrets are NOT backed up	Document secrets separately; use Azure Key Vault
Service Connection Secrets	Service connection credentials/secrets are NOT backed up	Document secrets separately; re-enter after restore
PAT Tokens	PAT tokens used in pipelines are NOT backed up	Re-configure service connections after restore
SSH Keys	Git SSH keys are NOT backed up	Re-upload SSH keys to target organization

Restore Behavior & Important Notes

Component	Behavior	Important Notes
Work Items	Updates existing work item if found by ID	No comments added to work item history about restore operation
Work Items	Creates new work item if original was deleted	New ID assigned; relationships recreated
Work Items	Cross-organization restore uses two-phase approach	Phase 1 creates all items and builds source-to-target ID mapping; Phase 2 relinks relations and links with new target IDs
Work Items	Work item IDs change when restoring cross-organization	Source-to-target ID mapping persisted in .metadata/id-mapping.json; all relations rewritten with new IDs
Work Items	Idempotent cross-organization restore (safe to re-run)	Re-runs detect already-mapped items and skip duplicate relation creation
Build Definitions	Updates existing definition if found by ID	Definition is updated with backup data
Build Definitions	Creates new definition if doesn't exist	New definition created with original configuration
Variable Groups	Updates existing group if found by name	Group is updated with backup data (except secrets)
Variable Groups	Creates new group if doesn't exist	New variable group created
Variable Groups	Secret values are NOT restored	Passwords/secrets are not backed up; must be re-entered manually
Service Connections	Updates existing connection if found by name	Connection metadata updated (except secrets)
Service Connections	Secret values/credentials are NOT restored	Must manually re-enter passwords, keys, certificates after restore
Service Connections	Pipeline authorizations are NOT restored	Must manually authorize pipelines to use connections
Pull Requests	Restores complete PR with title, description, comments, reviews, status, votes	Code changes already in Git from original merge
Pull Requests	Work item links preserved if work items exist	Broken links if work items not restored
Pull Requests	PR IDs preserved when restoring to same project	Cross-project restore may assign new IDs
Queries	Updates existing query if found by ID	Query definition is overwritten with backup data
Queries	Creates new query if doesn't exist	New query created with original structure
Git Repositories	Uses force push by default	Warning: Overwrites remote history; ensure backup is correct version
Boards	Updates existing board if found	Board structure updated but custom columns may fail due to API limitations
Boards	Boards are NOT auto-created	Board must exist in target project; cannot create new boards via API
Boards	Column configurations may be partially restored	Standard columns restore OK; custom columns may be rejected by Azure DevOps API
Boards	Swimlanes (rows) restore more reliably than columns	Rows have fewer API constraints than columns
Dashboards	Updates existing dashboard if found	Dashboard structure updated; some widget types may have limitations
Dashboards	Dashboards are NOT auto-created	Dashboard must exist in target; cannot create new dashboards via API
Dashboards	Widget counts may differ after restore	Some complex widget configurations may not be supported by API
Wiki	Updates existing wiki if found	Wiki pages restored with content
Wiki	Empty wikis restore as empty	Wikis with zero pages remain empty after restore
Wiki	Page hierarchy preserved	Page paths and structure maintained during restore
Areas & Iterations	Additive restore - creates/updates nodes only	Never deletes existing nodes; safe to restore multiple times
Areas & Iterations	Updates existing nodes if found by path	Node attributes (e.g., iteration dates) updated with backup data
Areas & Iterations	Creates new nodes if path doesn't exist	Node created with same path and attributes as backup
Areas & Iterations	Selective restore available	Can restore areas-only, iterations-only, or both (default)
Areas & Iterations	Cross-project and cross-organization restore supported	Source and target projects can be different; node structure copied
Areas & Iterations	Dry-run mode verifies no duplicate nodes	Preview shows what will be created/updated without making changes
Areas & Iterations	Idempotent restore (safe to run multiple times)	Running restore multiple times creates same result; no duplicates

Best Practices to Avoid Issues

✅ DO:

Test restores regularly to verify backup integrity
Use --dry-run before actual restore to preview changes
Document all secret variables and service connections separately
Disable branch policies temporarily during Git restore
Understand that restore OVERWRITES existing resources - backup important configurations before restore

❌ DON'T:

Restore to repositories that have diverged from backup without planning
Rely on backup for secret variables - they are NOT backed up
Expect work item restore to add comments about the restore operation
Run incremental work items backup more than once per day (redundant)
Assume existing build definitions or variable groups will be preserved - they will be overwritten with backup data
Restore without using --dry-run first to understand what will be changed

Getting Help with Limitations

If you encounter issues related to these limitations:

Review this table for known workarounds
Check the Troubleshooting Guide
Contact support@lamdat.com with:
- Specific limitation you're facing
- Your use case and requirements
- Logs showing the error (if applicable)

Note: Some limitations are Azure DevOps API constraints that cannot be worked around by the extension. We're actively working with Microsoft and the community to improve these capabilities where possible.

📈 Performance & Limits

Backup Performance

Small organization (1-5 projects): 5-30 minutes
Medium organization (5-20 projects): 30-120 minutes
Large organization (20+ projects): 2-8 hours
Incremental backups: 50-80% faster than full backups

Azure DevOps API Limits

Maximum 100 builds per definition per backup run (API limitation)
Rate limiting automatically handled with retry logic
Configurable parallelism (default: 4, max recommended: 12)

Storage Requirements

Git repositories: ~1.2x current size
Build history: ~1-5 MB per build
Work items: ~10-50 KB per item
Plan for 2x estimated size for growth

🎓 Additional Resources

Documentation

Getting Started Guide - Step-by-step tutorial
Command Reference - Complete task parameter reference
Best Practices - Backup strategies and recommendations
Troubleshooting Guide - Common issues and solutions
Use Cases - Real-world scenarios

Support

Email: support@lamdat.com
Repository: Azure DevOps Backup & Restore
License Information: Contact Lamdat for enterprise licensing

🗺️ Roadmap

We're committed to continuously improving the Azure DevOps Backup & Restore Extension. Here's what's available and coming next:

✅ Version 0.9 - Now Available!

Boards & Backlogs Backup & Restore

Complete backup and restore of Azure Boards configurations:

✅ Board columns and definitions
✅ Swimlanes (Rows)
✅ Card styles and rules
✅ Board settings and permissions
✅ Team-scoped board configurations

Use Case: Preserve complex board configurations, replicate team processes across projects, recover from accidental configuration changes.

Task Groups Backup & Restore

Complete backup and restore of pipeline task groups:

✅ Task group definitions and metadata
✅ Task steps and configurations
✅ Input parameters and variables
✅ Cross-project restore support
✅ Update existing task groups by name
⚠️ Note: Task group IDs change during restore

Pull Request Backup & Restore

Complete backup of pull request data including:

✅ PR metadata (title, description, source/target branches)
✅ PR comments and discussions
✅ Code review comments with file/line context
✅ PR status and completion history
✅ Reviewer information and vote history
✅ Associated work items and commits

Use Case: Preserve code review history, maintain compliance records, restore PR discussions after accidental deletions.

Service Connection Backup & Restore

Backup of service connection configurations:

✅ Service connection metadata and settings
✅ Connection type and configuration
✅ Project associations
⚠️ Note: Credentials/secrets must be re-entered manually after restore

Use Case: Document service connection configurations, restore connection settings after migration or disaster recovery.

Dashboard Backup & Restore

Complete backup and restore of Azure DevOps dashboards:

✅ Dashboard definitions and layouts
✅ Widget configurations
✅ Chart settings and queries
✅ Team and project dashboards
⚠️ Note: Some complex widget types may have API limitations

Use Case: Preserve dashboard configurations, replicate team dashboards across projects, recover from accidental deletions.

Release Definitions Backup & Restore

Complete backup and restore of Classic Release pipelines:

✅ Release pipeline definitions (Classic)
✅ Stage configurations and approvals
✅ Release gates and conditions
✅ Environment configurations
⚠️ Note: Release history and deployment logs are not backed up

Use Case: Preserve release pipeline configurations, replicate deployment strategies across projects, recover from accidental configuration changes.

Areas & Iterations Backup & Restore

Complete backup and restore of classification nodes (area paths and iteration paths):

✅ Area path hierarchy and structure
✅ Iteration path hierarchy and dates
✅ Team area assignments
✅ Sprint/iteration schedules
✅ Cross-project and cross-organization restore support
✅ Selective restore: areas-only or iterations-only
✅ Additive restore (never deletes existing nodes)
✅ Idempotent restore (safe to run multiple times)
✅ Dry-run mode for preview

Use Case: Replicate team structures across projects, migrate organizational hierarchy to new projects, recover from accidental deletions, copy sprint schedules between teams, preserve area path configurations during project migrations.

Selective Restore Options:

Restore both areas and iterations (default)
Restore only area paths (--areas-only)
Restore only iteration paths (--iterations-only)

Cross-Organization Work Items Restore

Complete work items restore to different Azure DevOps organizations and projects:

✅ Two-phase restore (Phase 1: create items, Phase 2: relink relations)
✅ Automatic source-to-target ID mapping
✅ Work item relations and parent-child links rewritten with new IDs
✅ Area and iteration paths rewritten for cross-project restores
✅ Idempotent restore (safe to re-run; no duplicate items or relations created)
✅ Dry-run mode for cross-org preview
⚠️ Note: Single source project required; specify TargetProject and/or TargetOrganizationUrl

Use Case: Migrate work items between Azure DevOps organizations, copy work item hierarchies to new projects, disaster recovery to a different collection.

🔮 Future Releases

Test Plans & Suites

✨ Test plans and test suites
✨ Test cases with steps and attachments
✨ Test runs and results
✨ Test configurations
✨ Manual and automated test associations
✨ Test parameters and shared steps

Artifacts & Packages

✨ Azure Artifacts feed configurations
✨ Package metadata and versions
✨ Feed permissions and views
✨ Upstream sources
✨ Retention policies

💬 Feature Requests

We value your feedback! Help us prioritize the roadmap:

Vote on features: Contact support@lamdat.com with your top priorities
Request new features: Describe your use case and we'll consider it for the roadmap

🎯 Commitment to Excellence

Our roadmap is driven by:

Customer feedback - Your needs shape our priorities
Best practices - Industry-standard disaster recovery patterns
Performance - Continuous optimization for large organizations
Security - Enterprise-grade security and encryption

💼 License

This extension requires a valid license key for production use. Trial licenses available for evaluation.

Contact: Lamdat
Email: support@lamdat.com
Website: https://www.lamdat.com

🌟 Why Lamdat?

Lamdat specializes in enterprise Azure DevOps solutions, providing tools that protect your investment and ensure business continuity. Our backup and restore extension is trusted by organizations worldwide to safeguard their most critical development assets.

Ready to protect your Azure DevOps organization?

Install the extension from the marketplace
Configure your variable group with credentials
Add backup task to your pipeline
Schedule automated backups
Sleep better knowing your data is safe

Questions? Contact support@lamdat.com

Azure DevOps and Visual Studio are trademarks of Microsoft Corporation.