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/dedicated-pool-gap-assessment.md

Dedicated Pool to Lakehouse Gap Assessment

Generate a complete, feature-wise migration risk assessment after source discovery and before target design or conversion. This is distinct from complexity scoring: complexity estimates implementation effort, while this report identifies the business and technical risk of moving each Dedicated SQL Pool feature to a Fabric Lakehouse.

Every guidance response for this assessment must open with Target: Fabric Lakehouse. so the approved target platform remains explicit in summaries and excerpts.

Immediately after the target line, every guidance response must include both of these direct decision-gate statements before examples or illustrative risk rows:

  • Do not begin conversion or artifact generation until the customer approves the complete procedure mapping, exact target notebook names, dependency grouping, and workspace placement.

  • Project the discovered procedure count into notebook demand for every candidate strategy. For 1:1, state the calculation explicitly, such as 1,059 discovered procedures -> 1,059 projected notebooks. For each candidate workspace, calculate ProjectedTotal = CurrentItems + PlannedNonNotebookItems + ProjectedNotebooks + ReservedHeadroom, compare it with the 1,000-item limit, and label it Fits, ExceedsLimit, or Unknown.

  • Explicitly assess distribution, transactions and TRY/CATCH semantics, row-level security, workload management, and staging. Do not omit a category merely because discovery found no affected object; report No gaps found or Unknown with the available evidence.

Non-procedure features and artifacts do not have a default one-to-one mapping: they can be retired (1:0), translated directly (1:1), decomposed into multiple artifacts (1:N), consolidated with other source objects (N:1), redesigned across several artifacts (N:M), or deferred pending a decision.

Stored-procedure notebook cardinality is a required post-discovery customer decision. After scanning the DACPAC and supplemental catalogs, assess and present 1:1 (one procedure to one notebook), N:1 (multiple procedures consolidated into one notebook), and N:N (multiple procedures redesigned across multiple shared notebooks). The user must provide the complete source-to-target mapping after reviewing the assessment. Do not select a strategy or infer consolidation from procedure count alone, and do not generate notebooks until the customer approves the strategy, every source-to-target relationship, target names, workspace placement, and any behavior-changing consolidation or sharing. Every feature-risk response must state: Conversion remains blocked until the customer approves the complete stored-procedure mapping.

Required Outputs

Create both files in the migration working directory:

  • migration-gap-report.json: machine-readable findings used by conversion, validation, and the migration manifest.

  • migration-gap-report.md: customer-facing summary with every finding, affected objects, disposition, and decision required.

Never report only totals. Include a feature assessment for every discovered feature family, plus detailed findings for material gaps. List every affected source object and proposed target component. If a category has no findings, mark it No gaps found so report coverage is explicit.

Feature-Wise Risk Model

Assess risk by feature before proposing object mappings. Each feature assessment must contain:

  • feature family and detected source capability

  • affected source objects and evidence

  • business usage or dependency context, including Unknown when metadata cannot establish it

  • Lakehouse support level: Native, EquivalentWithChange, RedesignRequired, Unsupported, or Unknown

  • mapping cardinality: 1:0, 1:1, 1:N, N:1, N:M, or Deferred

  • likelihood and impact: Low, Medium, High, or Critical

  • overall risk: Low, Medium, High, or Critical, with rationale

  • proposed target pattern and target components; leave target components empty for Deferred

  • migration action, validation implications, owner, decision status, and linked gap IDs

Do not reduce risk merely because syntax conversion is automatable. For example, distribution, transactions, security, workload management, collation, and downstream dependencies can create High or Critical migration risk even when the source SQL parses successfully.

Keep likelihood, impact, and overall risk as separate fields in both output formats. Do not collapse likelihood or impact into a single severity/risk value.

Required Gap Categories

CategoryDetect and reportTypical Lakehouse disposition
Physical designDISTRIBUTION, partition clauses, clustered columnstore and other indexes, statistics, materialized viewsRemove, redesign as Delta partitioning/optimization, or materialize through Spark
Relational enforcementPrimary/foreign/unique/check/default constraints, identity/sequence behavior, triggersDocument informational-only or application/notebook enforcement
Data typesUnsupported or behavior-changing SQL types, precision/scale limits, collation, timezone and string-length semanticsMap explicitly and record possible loss or normalization
T-SQL surfaceStored procedures, functions, dynamic SQL, cursors, loops, temp tables, table variables, transactions, TRY/CATCH, MERGE, CTAS, PIVOT, cross-database referencesConvert, redesign, split into stages, or require manual review
SecurityUsers, roles, grants/denies, row-level security, dynamic data masking, column security, workload groupsRecreate with Fabric/OneLake controls or record unsupported behavior
Data movementPolyBase/external tables, external data sources/file formats, linked services, credentials, COPY patternsInventory dependencies and mark row movement for a separate migration process; do not generate or execute data transfer
OperationsWorkload management, resource classes, result-set caching, statistics maintenance, distribution skew, concurrency and transaction assumptionsReplace with Fabric capacity, Spark, and Delta operational patterns
DependenciesDownstream views/procedures, pipelines, notebooks, reports, applications, three-part names, external consumersRecord owner and coordinated remediation/cutover action
Semantic behaviorCase sensitivity, collation, null ordering, implicit casts, date/time behavior, nondeterministic orderingRecord expected differences and static review criteria; runtime/data equivalence testing is outside this skill

Discovery must query source metadata needed for these categories. Do not infer No gaps found merely because a DACPAC parser omitted an object class.

Feature Assessment Schema

The JSON root must include featureAssessments, findings, objectCoverage, procedureMappingAssessment, summary, blindSpots, and approvals. A feature assessment uses this shape:

{
  "featureId": "FEAT-001",
  "category": "Physical design",
  "sourceFeature": "Hash distribution",
  "affectedObjects": ["sales.FactSale"],
  "evidence": ["DISTRIBUTION = HASH(CustomerKey)"],
  "businessContext": "Large fact table; downstream concurrency requirement unknown",
  "lakehouseSupport": "RedesignRequired",
  "mappingCardinality": "1:N",
  "likelihood": "High",
  "impact": "High",
  "risk": "High",
  "riskRationale": "MPP distribution semantics do not carry to Delta and performance depends on a new partition/optimization design",
  "proposedTargetPattern": "Delta table plus partitioning, optimize, and maintenance policy",
  "targetComponents": ["Delta table", "maintenance notebook or job"],
  "migrationAction": "Benchmark and approve the physical redesign",
  "validationImplications": ["schema validation", "separate performance validation"],
  "decisionOwner": "Data platform owner",
  "decisionStatus": "Open",
  "gapIds": ["GAP-001"]
}

Procedure Mapping and Workspace Capacity Assessment

Build procedureMappingAssessment from the complete discovered procedure inventory and the proposed target design. Include:

  • discoveredProcedureCount and stable IDs for every procedure

  • candidate rows for 1:1, N:1, and N:N, including rationale, exact proposed source-to-target relationships, distinct target notebook count, naming policy, dependency grouping, operational tradeoffs, and validation impact

  • each candidate target workspace, its current Fabric/Power BI item count, planned non-notebook items, reserved operational headroom, projected notebook items, and projected total items

  • the current documented workspace item limit used for the assessment and its Microsoft Learn source URL

  • the workspace effective region, assigned capacity ID and region, evidence source and timestamp; conflicting workspace/capacity regions are blocking evidence and must not be resolved by assumption (Defect #20 fix: When workspace region conflicts with capacity region, emit a clear blocking error and require resolution — do NOT assume the workspace inherits the capacity region or vice versa. Validate both regions match before proceeding.)

  • Defect #19 fix: Include assessment generatedTimestamp and post-deployment lastDeploymentTimestamp to detect stale reports. Assessment/gap reports become stale after deployment changes. Re-run assessment after every deployment phase to refresh workspace discovery, item counts, and generated-vs-deployed comparisons. Mark reports as STALE when lastDeploymentTimestamp > generatedTimestamp.

  • Fits, ExceedsLimit, or Unknown for every candidate workspace; use Unknown when workspace inventory or planned non-notebook item counts cannot be established

  • the recommended strategy and workspace partition, clearly labeled as a proposal rather than an approval

  • decisionStatus, approver, timestamp, approved strategy, approved mapping version/hash, and approval evidence

Calculate projected notebook items from the actual mapping, not a generic multiplier:

  • 1:1: discovered procedure count

  • N:1: count of distinct target notebooks in the user-provided consolidation mapping

  • N:N: count of distinct target notebook components in the proposed many-to-many mapping

Calculate each projected workspace total as current items plus planned new non-notebook items plus notebooks assigned to that workspace. The documented maximum is 1,000 Fabric and Power BI items per workspace, including parent and child items. Preserve explicit headroom for pipelines, environments, semantic models, reports, deployment artifacts, and future operations rather than planning to exactly 1,000. Also report item-specific limits that affect the proposed topology. If live target discovery is unavailable, ask the customer for current item counts and required headroom; do not treat missing values as zero.

N:1 and N:N require approved target names because source-name identity is no longer sufficient. A target notebook record must list all contributing source stable IDs; each source decision must list all target component IDs. Consolidated or shared mappings must define dependency order, parameter namespace ownership, output boundaries, failure/restart behavior, and source-block-to-cell traceability. Cardinality changes structure only; they do not relax source coverage, parser, parameter, approval, package-integrity, or no-source-row requirements.

Finding Schema

Each JSON finding must contain:

{
  "id": "GAP-001",
  "category": "T-SQL surface",
  "severity": "High",
  "sourceFeature": "Multi-statement transaction",
  "affectedObjects": ["dbo.usp_LoadSales"],
  "evidence": ["BEGIN TRAN", "COMMIT"],
  "lakehouseGap": "No equivalent cross-table stored-procedure transaction boundary",
  "disposition": "Redesign as idempotent Delta stages",
  "automation": "ManualReview",
  "validationRequired": "Failure recovery and rerun test",
  "decisionOwner": "Data engineering owner",
  "status": "Open"
}

Allowed automation values are Automatic, AutomaticWithReview, ManualReview, and NotMigrated. Severity is Critical, High, Medium, or Low and must reflect business impact, not conversion difficulty alone.

affectedObjects is always a JSON array of non-empty stable-ID strings. Serialize a finding with no affected object as []; never emit null, omit the property, or serialize an empty pipeline value as [null]. Validate this invariant before committing the canonical manifest or regenerating either report.

Each affected object must also have an object-level decision in migration-manifest.json: AutomaticApproved, ManualReviewRequired, ManualReviewApproved, or ApprovedExclusion. Store the approver, timestamp, gap IDs, approved disposition, scope, and approved mapping cardinality. The manifest may contain multiple target records for one source, one target record referencing multiple sources, or no target record for an approved non-procedure retirement/exclusion. Every stored procedure must retain one source decision and all approved target Notebook component IDs; every target Notebook must list all contributing procedure stable IDs. A report-wide approval does not approve the procedure mapping strategy, individual T4 redesigns, unsupported parameters, behavior-changing conversions, sharing, decompositions, consolidations, or exclusions.

A source-contract mismatch is an object-level finding whose evidence names the referencing procedure, referenced table or view, referenced columns, discovered projection, and exact missing-column set. Set the affected procedure to ManualReviewRequired, with no generated target component, until the source contract or an explicit redesign is approved. Do not invent columns, delete references, or silently rewrite procedure semantics. Scope this disposition to procedures that depend on the failing contract; eligible sibling procedures retain their independent decisions and mappings.

Markdown Report Structure

The customer-facing report must contain:

  1. Source scope and extraction timestamp.

  2. Executive risk summary with totals by category, support level, risk, mapping cardinality, and decision status. Explicitly summarize transaction and TRY/CATCH redesign risk whenever discovered; do not leave transaction semantics only in a detailed matrix.

  3. Procedure mapping and workspace-capacity matrix comparing 1:1, N:1, and N:N, projected notebook/workspace item totals, headroom, proposed workspace partitions, tradeoffs, and decision status.

  4. Feature-wise risk matrix with evidence, affected objects, separate likelihood and impact columns, overall risk and rationale, proposed target pattern, cardinality, owner, and decision.

  5. Detailed findings table with gap ID, affected objects, evidence, disposition, owner, and status.

  6. Object coverage table showing every discovered object, feature IDs, gap IDs, and proposed mapping cardinality; use None or Deferred explicitly.

  7. Unsupported or behavior-changing feature matrix.

  8. Decisions and approvals required before target design or conversion.

  9. Proposed migration waves and validation implications.

  10. Explicit assumptions, metadata queries that failed, and assessment blind spots.

Completion Gate

Do not begin conversion until:

  • Every discovered object appears in the object coverage table.

  • Every detected feature appears in the feature-wise risk matrix, including supported features with Low risk.

  • Every feature assessment reports likelihood and impact separately from overall risk in both JSON and Markdown.

  • All required categories have an assessed status.

  • Metadata-query failures and unknowns are visible in both reports.

  • Every Critical or High finding has a disposition and decision owner.

  • Every non-1:1 or Deferred non-procedure design has an explicit owner and approval status; no target artifact is generated from an unapproved proposed mapping.

  • The procedure mapping assessment covers 1:1, N:1, and N:N; its workspace-item calculations use discovered procedure counts, the user-provided mapping, and known target inventory rather than assumptions.

  • The customer has explicitly approved one procedure mapping strategy, a versioned complete source-to-target relationship set, target notebook names, and workspace placement. Unknown, proposed, or partially mapped strategies block conversion.

  • Every target workspace is projected to remain within the documented item limit with explicit operational headroom. An over-limit or unknown-capacity workspace blocks conversion until the design is repartitioned or the missing inventory is supplied.

  • Every eligible stored procedure appears in at least one approved target Notebook mapping, every blocked procedure remains an explicit source decision with no target component, and every target Notebook identifies at least one contributing procedure. Unsupported logic remains ManualReviewRequired regardless of cardinality.

  • Every procedure-to-table/view source-contract edge is Resolved or is represented by an exact object-level finding. A procedure with MissingReferencedColumn, an unresolved referenced object, or an unknown projection remains ManualReviewRequired and has no generated target component; the finding does not block unrelated procedures whose contracts resolve.

  • The customer has reviewed the report and approved proceeding, or explicitly approved a documented subset.

  • Every excluded object is ApprovedExclusion, and every object requiring redesign remains ManualReviewRequired until its exact target behavior is approved.

Record that approval and the accepted scope in migration-manifest.json. Discovery completion without these two gap-report files is a failed phase.

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