Generated banner for Synapse Migration
Generated logo for Synapse Migration

Synapse Migration

MicrosoftOfficialPublished by Microsoft

  • Skill
  • Workflow
  • Software development
  • MIT
  • Low risk
  • Has scripts

From the author

Converts Synapse workspaces to Fabric: Spark items, Lake Databases, Linked Services, and Dedicated SQL Pool schema/procedures for Lakehouse or Warehouse. During Pool-to-Lakehouse migration only, can migrate approved dependent procedure callers after notebook readiness. Excludes standalone pipelines and Warehouse administration. Triggers: Synapse workspace to Fabric, Dedicated SQL Pool to Lakehouse, Dedicated SQL Pool to Fabric Warehouse.
— the description by Microsoft

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The synapse-migration skill provides a structured, phased workflow for transitioning Synapse Analytics workspaces to Microsoft Fabric. It covers the migration of Spark items, Lake Databases, Linked Services, and Dedicated SQL Pool schema and stored procedures. The skill emphasizes a dependency-ordered approach, requiring gap assessment and explicit approval before conversion. It distinguishes between migrating to a Fabric Lakehouse (schema and code only, no data movement) and a Fabric Warehouse, while providing specific routing for dependent pipeline callers.

What it does

  • Discovers and classifies Synapse workspace artifacts.
  • Converts Dedicated SQL Pool schema and stored procedures to Spark SQL notebooks or Warehouse objects.
  • Migrates Spark items, including notebooks and Spark Job Definitions, to Fabric equivalents.
  • Maps Linked Services to Fabric Data Connections or OneLake Shortcuts.
  • Manages the migration of approved dependent pipeline callers.
  • Validates persisted definitions and artifacts against established contracts.

When to use it

  • When migrating a full Synapse workspace to Microsoft Fabric.
  • When converting Dedicated SQL Pool schema and procedures to a Lakehouse or Warehouse.
  • When porting Spark pools, notebooks, or Spark Job Definitions to Fabric.
  • When replacing Synapse Linked Services with Fabric-native connectivity.

Advantages

  • Ensures dependency-ordered migration to maintain system integrity.
  • Provides clear routing for different workload types (Lakehouse vs. Warehouse).
  • Enforces strict validation and approval gates for behavior-changing decisions.
  • Supports incremental migration rather than high-risk big-bang cutovers.
  • Standardizes the conversion of T-SQL procedures to executable Spark SQL notebooks.

Usage examples

“Migrate this Dedicated SQL Pool DACPAC to a Fabric Lakehouse and convert the procedures.”
The agent will assess gaps, obtain approval for procedure-to-notebook mappings, create a migration manifest, convert schema/code artifacts, and validate the results.
“Migrate this Dedicated SQL Pool to Fabric Warehouse.”
The agent will assess DDL compatibility, remove unsupported distribution/index declarations, obtain provisioning consent, and prepare for potential data migration.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/microsoft/synapse-migration/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip synapse-migration.zip -d .agents/skills

Documentation by Microsoft

Telemetry — MANDATORY. Every api.fabric.microsoft.com call must carry x-ms-fabric-skill: synapse-migration (az rest: --headers "x-ms-fabric-skill=synapse-migration"), including every LRO poll, fabric_lro and retry. Snippets omit it — add it anyway.

OFFLINE LAKEHOUSE ARTIFACT FAST PATH — DECIDE FIRST. For a no-live-call request with complete supplied inputs and contracts, load only the fast path; do not load migration-planning-reference.md, dedicated-pool-conversion.md, or implementation scripts. Use one generator for artifacts and final-byte hashes, then one verifier. Do not inspect generated files or run post-pass spot checks. For every optional non-null source default, set missingValueBehavior to UseSourceDefault and restore that default before validation. Do not use this path for a Warehouse target; incomplete and large-procedure requests use their own routes.

CRITICAL NOTES

  1. To find workspace details (including its ID) from a workspace name: list all workspaces, then use JMESPath filtering.

  2. To find item details (including its ID) from workspace ID, item type, and item name: list all items of that type in that workspace, then use JMESPath filtering.

  3. Treat a source Dedicated SQL Pool as read-only. Do not run source DDL, DML, stored procedures, or create sample objects.

  4. Dedicated Pool-to-Lakehouse data movement is out of scope. Migrate schema and executable code artifacts only; do not copy source rows or run row-level/business-result equivalence queries. The separate Warehouse route may move data only from a separately approved restored export copy under its own consent gate and restored-source contract.

  5. For Dedicated Pool-to-Lakehouse requests, complete gap assessment, explicit mapping approval, manifest creation, conversion, deployment, and validation in order. Read dedicated-pool-to-lakehouse.md once as the router, then load only the current phase reference.

  6. Stored-procedure 1:1, N:1, and N:N mappings never apply to views. Views remain schema objects; procedures become traceable Spark SQL notebooks with executable %%sql transformation cells.

  7. Dependent ADF/Synapse callers are conditional scope, not automatic scope. Discover them during assessment, require a separate complete-closure approval, and migrate them only after notebook readiness. Route standalone pipeline requests to pipeline-migration.

  8. Before executing a specialized Dedicated Pool workflow, read the matching contract in dedicated-pool-execution-contracts.md. Its validation, hashing, request-body, resume, and completion-language requirements are mandatory.

  9. Keep Lakehouse and Warehouse paths separate. If the target is unclear, ask before loading path-specific resources. Lakehouse conversion never moves source rows; Warehouse data migration requires its own explicit consent gate and restored-source contract.

  10. For a Fabric Warehouse target, explicitly state that the complete DISTRIBUTION and CLUSTERED COLUMNSTORE INDEX declarations are removed because Fabric manages distribution, storage, and indexing; a bare mention of either source clause is insufficient.

  11. Run setup DDL and CETAS only against the separately approved restored export copy after proving it is not the original production source.

Synapse Analytics to Microsoft Fabric Migration

Core Workflow

  1. Discover the Synapse workspace and classify every source artifact.

  2. Choose targets using workload-routing.md.

  3. Assess gaps before conversion, including runtime, library, connectivity, T-SQL, security, and capacity constraints.

  4. Obtain approval for behavior-changing decisions, target placement, and every stored-procedure-to-notebook mapping.

  5. Create or update migration-manifest.json and persist approval, per-object status, hashes, and checkpoints atomically.

  6. Convert and deploy in dependency order, loading only the current phase resource.

  7. Validate persisted definitions and artifacts without executing generated notebooks or pipelines unless a separately approved workflow explicitly requires execution.

  8. Report completed, blocked, skipped, and pending objects without exposing credentials or sensitive values.

For full-workspace orchestration, read migration-orchestrator.md. For a Dedicated Pool-to-Lakehouse migration, use dedicated-pool-to-lakehouse.md as the phase router. For a Warehouse target, load only the matching dw-* resource.

Scope Routing

RequestActionLoad
Full Synapse workspace migrationRun phased discovery and migrationmigration-orchestrator.md
Dedicated SQL Pool schema/code to LakehouseRun the strict assessment-to-validation workflow. For guidance-only notebook publication, explicitly state: "The stored procedures were converted from T-SQL to Spark SQL before publication."dedicated-pool-to-lakehouse.md
Guidance-only Dedicated Pool incremental deployment hardeningAnswer directly from the focused checklist; do not search scripts or load phase resources. State: "For columns with special characters, enable Delta columnMapping selectively and only with approval."dedicated-pool-execution-contracts.md
Large or complex stored procedureFor a complete offline contract, read only the audit resource once, use one run-local generator and one verifier, do not inspect implementation scripts or generated outputs, and stop after successful verificationdedicated-pool-large-procedure-audit.md
Spark poolConvert configuration and libraries to a Fabric Environmentspark-pool-migration.md
Lake Database or HMSCreate or bind the target Lakehouselake-database-migration.md or external-hms-migration.md
Notebook or Spark Job DefinitionPort code, bindings, parameters, and runtime settingsspark-item-migration.md
Linked ServiceChoose a Fabric Data Connection for external services or a OneLake Shortcut for ADLS Gen2/Blobconnectivity-migration.md
Approved dependent procedure callersRun the internal closure-preserving sub-flow after notebook readbackdedicated-pool-dependent-pipelines.md
Standalone pipeline migrationDelegatepipeline-migration
Dedicated SQL Pool to Fabric WarehouseRun the source extraction, DDL compatibility, approval, optional data, security, and validation routedw-source-and-extraction.md, then the matching dw-* phase resource
Standalone Fabric Warehouse administrationDelegatesqldw-cli
Synapse LinkUse Fabric Mirroring; not covered here—

Always report the Lake Database/HMS phase. If none is discovered, mark it NotApplicable (none discovered) while retaining the required target Lakehouse binding.

Load References On Demand

Do not preload all files. Load only the references needed for the current phase:

NeedReference
Routing, phase order, API audiences, quick examples, troubleshooting, or post-migration handoffworkload-routing.md
Dedicated Pool execution variants and response contractsdedicated-pool-execution-contracts.md
Dedicated Pool discoverydedicated-pool-discovery.md
Gap assessment and mapping approvaldedicated-pool-gap-assessment.md
Procedure conversion and notebook shapededicated-pool-conversion.md
Schema/notebook deploymentdedicated-pool-deployment.md
Dedicated Pool validationdedicated-pool-validation.md
Runtime/library compatibilityfeature-parity.md and library-compatibility.md
mssparkutils and connector refactoringutility-api-mapping.md, connector-refactoring.md, and code-patterns.md
Capacity planningcapacity-sizing.md
Dedicated Pool-to-Warehouse source discovery and extractiondw-source-and-extraction.md
Warehouse DDL compatibility and deploymentdw-ddl-compatibility.md
Separately approved Warehouse data migrationdw-data-migration.md
Warehouse security and validationdw-security-validation.md
Validation, reporting, and production readinessvalidation-testing.md, migration-report.md, and security-governance.md

Use COMMON-CLI.md only for shared authentication and az rest mechanics not already covered by the phase resource. Use COMMON-CORE.md only for shared Fabric REST patterns.

Must

  • Preserve every stored-procedure input contract, source default, source decision, and approved target mapping.

  • Block conversion until gap dispositions, notebook names, dependency grouping, and target workspace placement are explicitly approved.

  • Use SqlPackage/DMVs for source discovery, Fabric REST for item management, and Fabric Livy statements for Lakehouse schema and Delta execution.

  • Run the maintained validators required by the selected execution contract; never replace them with ad hoc JSON or cell-shape checks.

  • Choose the Lakehouse or Warehouse target before loading implementation resources; never apply Warehouse data-movement rules to Lakehouse artifact conversion.

  • Before persisting any dependent-pipeline source definition, recursively inspect it for secret-bearing or uncertain properties; block the complete selected closure without writing the artifact or mutating a target when any are found.

  • In every dependent-pipeline response, including guidance-only and pre-approval explanations, state: "Use a TridentNotebook activity with exact target identities typeProperties.notebookId and typeProperties.workspaceId, and pass inputs through typeProperties.notebookParameters." Then state: "After deployment, read back each pipeline with POST /v1/workspaces/{workspaceId}/items/{dataPipelineId}/getDefinition and validate its canonical hash and structural bindings."

  • For every Linked Service response, first state both replacement classes: Fabric Data Connections for external databases/services and OneLake Shortcuts for ADLS Gen2/Blob storage; then identify which class applies.

  • Replace mssparkutils with notebookutils, Linked Services with the correct Fabric connection class, and spark.read.synapsesql() with a supported OneLake or JDBC pattern.

  • Externalize workspace and item IDs through parameters or Variable Libraries.

  • Keep phase status concise, emit bounded heartbeats for long operations, and persist per-object evidence in the manifest.

Prefer

  • OneLake Shortcuts over copying data.

  • Fabric Environments for reproducible libraries and Spark settings.

  • Incremental, dependency-ordered migration over big-bang cutover.

  • Parameterized notebooks and Variable Libraries for environment promotion.

  • Lakehouse SQL Endpoint for compatible Serverless SQL Pool read workloads.

Avoid

  • Do not execute generated notebooks or pipelines as part of artifact migration.

  • Do not broaden a selected dependent-pipeline closure or route that internal sub-flow to pipeline-migration.

  • Do not use sqlcmd against the target Fabric Warehouse; use the registered SQL endpoint tooling required by the Warehouse resource.

  • Do not preserve Synapse distribution/storage hints, PolyBase DDL, Linked Service connection strings, or pool-level library installation patterns verbatim.

  • Do not use target notebooks to orchestrate the migration itself.

  • Do not hardcode workspace IDs, item IDs, credentials, connection strings, or environment-specific paths.

Examples

Prompt: "Migrate this Dedicated SQL Pool DACPAC to a Fabric Lakehouse and convert the procedures."

Response behavior: Assess gaps first, present and obtain approval for the complete procedure-to-notebook mapping and workspace placement, create the manifest, convert approved schema/code artifacts without moving source rows, validate persisted definitions, and report the resolved Lakehouse and artifact evidence.

Prompt: "Migrate this ADF pipeline to Fabric."

Response behavior: Route to pipeline-migration. Keep it here only when the pipeline is an explicitly approved dependent caller discovered inside an active Dedicated Pool-to-Lakehouse migration.

Prompt: "Migrate this Dedicated SQL Pool to Fabric Warehouse."

Response behavior: Keep this inside synapse-migration, assess DDL compatibility, remove unsupported distribution and columnstore declarations, obtain provisioning consent, and ask separately before any restored-source data migration.

For code transformations and edge cases, load workload-routing.md and the phase-specific resource rather than expanding the main instructions.

Files

resources/dw-ddl-compatibility.md

DDL Compatibility and Conversion

Load this resource for Steps 3-4 only.

Classification

  • Auto-fixed: safe mechanical conversion.

  • Needs review: add -- MIGRATION REVIEW: to the generated SQL and report it.

  • Blocker: no safe conversion; do not deploy that object.

Table conversion

  • Remove DISTRIBUTION = HASH(...), ROUND_ROBIN, and REPLICATE; Fabric manages distribution.

  • Remove clustered columnstore, clustered, and nonclustered index definitions.

  • Remove dedicated-pool partition clauses and create one regular Fabric table. If data migration is separately approved, export the selected source rows across every partition; otherwise preserve only the schema. Warn that partition boundaries, switching/maintenance operations, and source partition-based performance behavior are not preserved.

  • Convert every computed column to a regular stored target column. Report the source table, column, expression, target type, and loss of automatic recomputation. If data migration and preservation of the computed value are separately approved, include its evaluated source value in the approved export projection; otherwise preserve only the stored target-column schema and do not read or export source row values. Ask whether the user wants a separate view that reproduces the original computed expression; generate that view only after validating the expression against Fabric T-SQL and receiving approval.

  • Create all tables without inline source primary-key, unique-key, or foreign-key constraints. After every referenced table exists, emit separate ALTER TABLE ... ADD CONSTRAINT statements: primary and unique keys as NONCLUSTERED NOT ENFORCED, and foreign keys as NOT ENFORCED. Order these statements by the foreign-key dependency graph; for a cycle, create every table first and then apply the cycle's constraints. Record and block any constraint whose referenced table or columns did not deploy.

  • Do not deploy DEFAULT or CHECK constraints: the current Fabric Warehouse table-constraint surface supports only primary, foreign, and unique keys in their documented unenforced forms, and explicitly does not support DEFAULT constraints. Record every source DEFAULT/CHECK definition. If equivalent behavior requires application, pipeline, or procedure logic, classify that redesign as Needs review; otherwise classify the missing invariant as a Blocker for dependent writes.

  • Map unsupported persisted data types:

SourceFabricClassification
moneydecimal(19,4)Auto-fixed
smallmoneydecimal(10,4)Auto-fixed
datetime, smalldatetimedatetime2(6)Auto-fixed
tinyintsmallintAuto-fixed
binary(n)varbinary(n)Auto-fixed
datetimeoffsetdatetime2(6)Needs review: offset lost
nchar(n), nvarchar(n)char(n), varchar(n)Needs review: require a supported UTF-8 collation on the target Fabric Warehouse and size the target column from observed and worst-case UTF-8 byte requirements; ASCII is 1 byte and non-ASCII Unicode scalar values can require up to 4 bytes; widen with approval
nvarchar(max)varchar(max)Needs review: require a supported UTF-8 target collation and validate encoded byte size against the current 16 MB limit

For any unsupported source type not listed above (for example geography, geometry, XML, hierarchyid, CLR/user-defined types, or another unsupported persisted type), propose documented Fabric alternatives per column and ask the user to approve a mapping. Do not default everything to varchar and do not silently drop columns. If no mapping is approved, block the table and its dependents and record the source type, proposed alternatives, and decision.

Do not convert nchar or nvarchar until the target Warehouse has an explicitly selected supported UTF-8 collation and the mapped width is byte-safe for the approved data domain. Measure representative encoded values, calculate the worst-case UTF-8 requirement, document truncation risk, and obtain approval for widening. Block the affected table when a safe supported width or collation cannot be established.

Fabric IDENTITY is preview, supports only bigint IDENTITY, and does not support custom seed/increment values. SET IDENTITY_INSERT supports explicit value insertion. Mark identity conversion as Needs review and require approval before preserving source keys through explicit insertion; validate key uniqueness, range, dependent foreign-key relationships, reseeding, and a subsequent generated value in an approved test context.

Code object conversion

  • Remove distribution clauses, index DDL, and SET RESULT_SET_CACHING.

  • Remove workload-management definitions and resource-class references. Keep supported OPTION (LABEL=...) usage.

  • Do not rewrite NEXT VALUE FOR or other sequence references. Sequence objects are excluded from migration; code objects retaining sequence references proceed through normal target compilation validation and fail there if unsupported or unresolved.

  • For every cross-database or linked-server reference, ask the user to map the source server/database/object to a Fabric-accessible Warehouse, Lakehouse SQL endpoint, shortcut-backed table, or other approved target. Block the referencing object and its dependents until all mappings are approved. Rewrite only explicit, unambiguous references, then show the before/after mapping and validate target compilation. Never guess mappings or silently remove remote joins/calls.

  • Dedicated SQL pools do not support DML or DDL triggers, so none are expected in this migration path. If discovery unexpectedly returns a trigger, stop and verify that the selected source is actually a dedicated SQL pool; report the trigger as a source-scope blocker and do not generate a target trigger definition.

  • For each source external table, ask whether to keep the data in place through an approved OneLake shortcut/Lakehouse mapping or materialize it into a regular Fabric Warehouse table through a user-approved copy method. Remove Synapse external data source/file format DDL only after the replacement is selected. Block dependent objects until the shortcut target or materialized table exists and its schema is validated.

  • Convert materialized views to regular views automatically. Remove materialized-view-only syntax, preserve the SELECT definition, and add a prominent warning that physical materialization, refresh behavior, storage, and source performance characteristics are not preserved. Record every conversion in migration-report.md.

  • Block multi-statement TVFs and non-inlineable scalar UDFs pending redesign. Propagate the blocker to views, procedures, functions, RLS predicates, or other objects that depend on the blocked function. Continue converting independent objects; never generate a placeholder implementation.

  • For SQL-authenticated users, generate role definitions only; omit user creation, memberships, and direct user grants, and report every omission.

  • Column-level encryption is unsupported in Fabric Warehouse. Omit the encryption metadata, continue migrating the affected table, and add a prominent non-blocking assessment warning that the target column data will not retain source encryption protection.

DMV conversion

Only auto-replace direct monitoring equivalents, and review column differences:

SynapseFabric
sys.dm_pdw_exec_requestssys.dm_exec_requests or queryinsights.exec_requests_history
sys.dm_pdw_exec_sessionssys.dm_exec_sessions or queryinsights.exec_sessions_history
sys.dm_pdw_exec_connectionssys.dm_exec_connections

Remove distribution and workload-management references that are unnecessary in Fabric. Treat these families as blockers unless manually rewritten:

  • sys.dm_pdw_request_steps, sys.dm_pdw_sql_requests, sys.dm_pdw_dms_*

  • sys.dm_pdw_wait*, sys.dm_pdw_nodes*, sys.dm_pdw_resource_waits, sys.dm_pdw_errors

  • PolyBase compute/distributed/DMS/external DMVs

  • sys.pdw_nodes_*, mapping, loader, and materialized-view catalog families

Use Fabric Query Insights for post-migration history and performance analysis.

Assessment report

Compare source and selected target collations. Report case-sensitivity, UTF-8 byte semantics, string-comparison, uniqueness, and explicit COLLATE risks. Preserve only explicit collations supported by Fabric and flag unsupported clauses for review.

Report source inventory, resolved scope, converted/deployed counts by object type, DEFAULT/CHECK compatibility, collation risks, auto-fixes, review items, blockers, blocked dependency chains, every data-type conversion, security gaps, and DMV compatibility. Require explicit user confirmation before provisioning the Fabric Warehouse.

References

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

What our scanner noticed· Low risk

  • Instructions that use the network
  • Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
Microsoft
Publisher
Microsoft (Official)
Source
microsoft/skills-for-fabric · skills/synapse-migration · commit f8fac11
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Also distributed in
microsoft/skills-for-fabric

AutoGineer is not affiliated with or endorsed by Microsoft.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download synapse-migration.zip