SQL Server to Dataverse Migration: Should the App Move?
SQL Server to Dataverse migration: decide if the app should move at all, then pick the method by size and complexity and plan for keys and API limits.
If your in-house app runs on SQL Server 2016 or 2017, support has ended or is ending. In a SQL Server to Dataverse migration, the first question is not which tool moves the rows. It is whether the app should move to Dataverse at all.
Our reading marks how we apply a Microsoft line to a SQL Server app; Our view marks our recommendation.
| Product | Support ends |
|---|---|
| SQL Server 2016 | July 14, 2026 (ended) |
| Windows Server 2016 (if it hosts the database) | January 12, 2027 |
| SQL Server 2017 | October 12, 2027 |
| SQL Server 2016 ESU (paid) | Year 1 to July 13, 2027; Year 2 to July 18, 2028; Year 3 to July 17, 2029; Critical security updates only |
Dates are from the SQL Server ESU FAQ and Ending Support in 2027. On November 15, 2026, SQL Server 2016 has been out of support for four months; Windows Server 2016 ends in under two months, ESU Year 1 in just under eight, and SQL Server 2017 in just under eleven.
Microsoft’s definition: “Upon retirement or end of support, there will be no new security updates, non-security updates, free or paid assisted support options or online technical content updates.” ESUs are a paid last resort, and “The ESU program does not extend the product’s lifecycle and does not provide technical support beyond the original support timeline.”
Is there a Microsoft guide for SQL Server to Dataverse migration?
No dedicated SQL Server to Dataverse guide turned up in the Microsoft Learn pages we checked on November 10, 2026; the closest is Data migration approaches: “The right approach for migrating data from an external CRM system to Microsoft Dataverse depends on your data’s size and complexity.” We use its size tiers below, though Microsoft wrote them for CRM moves; only a trial load shows how your move behaves. We also found no SQL Server to Dataverse data type mapping table.
Should you move a SQL Server app to Dataverse?
Our view: move a table only if people will work on its records in Power Apps, Power Automate or Power Pages, and none of the four signals applies to it: a writer that must stay on T-SQL, raw query power, heavy batch jobs, or multi-step transactions in stored procedures. If some tables show one, the answer is Split (some tables move, some stay); if all do, Leave (nothing moves to Dataverse) or Orchestrate (Leave plus an intake and routing layer in front), defined in the table below.
| Branch | Where records live, who writes | What gets rebuilt |
|---|---|---|
| Migrate | Dataverse; apps write through the Dataverse APIs | Screens, reports, and the logic in stored procedures, triggers and jobs |
| Orchestrate | SQL Server, upgraded or on Azure SQL; writes unchanged | A new intake and routing layer in front |
| Leave | SQL Server, upgraded or on Azure SQL; writes unchanged | Nothing required; new screens can use connectors and the data gateway |
| Split | Dataverse for records people work on; SQL Server, upgraded, or Azure SQL for batch and heavy queries | The Dataverse half, plus an integration per shared table |
Microsoft’s modernization guidance starts wider than migration: “Modernization doesn’t always mean rebuilding a legacy app from the ground up. Other options are retiring it, replacing it, rehosting it, refactoring it, and rearchitecting it.” For data, it offers leaving it in place or migrating it to Dataverse, plus a data lake for history. Our reading: those become Leave and Migrate, with the data lake as a side store; Orchestrate is our addition.
Migrate, Leave and Split decide where records live; Orchestrate is Leave with an intake and routing layer added in front of the existing app. Our AI orchestration reference architecture for legacy systems describes the layer. Our view: it fits when requests arrive from several channels or cross more than one system. The SQL Server underneath keeps its own support dates, and the layer need not use AI.
Microsoft’s modernization page also notes that some organizations leave old data in place and create new data in Dataverse, migrating as more apps move. Our view: that is Migrate for new records and Leave for old ones, so until the old store is retired, the app runs on two stores.
Keeping SQL Server: Azure SQL, Power Apps and virtual tables
Our view: staying on a supported SQL Server version is a valid choice, not a failure to modernize. Microsoft’s end of support options are to upgrade, move to Azure SQL, or buy ESUs until you can upgrade or migrate.
Our reading: these routes sit under every branch. Leave and Orchestrate end on an upgraded or Azure SQL instance; Migrate needs one of them, or ESUs, until cutover. Microsoft on ESUs: “They are not intended as a long-term solution, but rather as a temporary bridge to stay secure while one migrates to a newer, supported platform.”
Two ways to keep SQL Server under Power Platform; both are Leave, because the records stay on SQL Server:
- Power Apps over SQL Server. Microsoft’s reference architecture backs keeping the database: when the data can’t move or SQL Server is required, it says to consider Power Apps over SQL Server.
- Virtual tables, so SQL Server rows show up as Dataverse tables; the rows stay on SQL Server. Microsoft’s limits include “Virtual table queries are limited to returning 1,000 records.” Views give read operations only, and rollups and calculated fields don’t compute. SQL virtual tables take a GUID or integer key. Our reading: int keys can stay as keys; bigint columns arrive as decimal, so test a bigint key first. We found no write-volume figure, so trial yours.
Our reading: Dataverse is not among Microsoft’s database routes. Moving to it is a decision to rebuild the app, not a way to upgrade the database.
Dataverse vs SQL Server: when Dataverse is the wrong target
Four signals that Dataverse is the wrong home for all or part of the app; a table that shows one stays on SQL Server, upgraded, or Azure SQL:
- Something must keep writing through T-SQL. Dataverse’s own SQL connection, which lets tools query Dataverse data with SQL, is read-only: INSERT and UPDATE don’t work through it. Our reading: every write path moves to the Dataverse APIs, so a writer you cannot rewrite keeps its tables off Dataverse.
- The app needs raw query power. Azure’s data store guidance says access primarily through the Dataverse APIs limits query flexibility and throughput compared to Azure-native database services. Our reading: tables behind heavy queries and reports may stay off Dataverse.
- Heavy batch jobs carry the business. For large nightly, weekly or monthly jobs, the API limits page suggests real-time integration instead. Our reading: jobs that must stay batch stay off Dataverse.
- Multi-step transactions live in stored procedures. For canvas apps, Microsoft notes that each Power Fx operation is independent, not an atomic transaction, and advises “Use SQL Server stored procedures with transaction support.” Our reading: the pages we checked do not say how that logic moves into Dataverse, so a procedure that must stay atomic stays put until a rebuild is designed.
Microsoft’s migration method starts after the destination is chosen: “This example assumes that process analysis and solution evaluation have already been conducted, and that Dataverse has been identified as the appropriate destination for the data.” The same note says to check first whether one of Microsoft’s own business applications fits. Our reading: if your app tracks customers, sales or service, run that check first.
Microsoft’s Azure guidance allows a split answer: “Evaluate Dataverse for the portions of your solution that use Power Apps, Power Automate, Power Pages, or Dynamics 365.” It sends parts that need high-throughput processing, complex analytical queries or direct database control to an Azure-native database alongside Dataverse. Our view: each shared table has one system of record, the store that runs its transactions; the other store gets a copy through the integration.
How do you migrate SQL Server data to Dataverse?
Once Dataverse is the target, size and complexity point to the starting method. Microsoft’s data migration tiers, written for CRM moves, use the import wizard for up to 1 GB or fewer than 50,000 records, ETL tools such as Azure Data Factory up to 50 GB or 500,000 records, and staged pilots above that.
- Pick the method from the highest tier any measure points to.
- Map keys and columns.
- Stage and fix the data where the source needs it.
- Load with retries within the API limits.
- Check, then cut over.
| Tier (Microsoft) | Microsoft's method | SQL Server adds |
|---|---|---|
| Simple: up to 1 GB or under 50,000 records; flat, no intricate relationships | Import wizard | The wizard takes files; a dataflow reads the database itself, not a file export |
| Medium: 1 GB to 50 GB or 50,000 to 500,000 records; related tables | ETL such as Azure Data Factory, with test migrations | Decide keys, owners and dates in staging; confirm the loader writes them |
| Complex: over 50 GB or 500,000 records; custom tables and workflows | Data Factory, SSIS, Synapse, Fabric or code, with pilots | Stored procedures, triggers and jobs are rebuilt, not copied |
The tiers page gives no rule when size, record count and complexity disagree. Our view:
- Highest tier wins for the load. Plan the load for the highest tier any of them points to.
- Logic is a rebuild, not a load. Stored procedures, triggers and SQL Agent jobs do not move as data. Logic that moves into Dataverse is rebuilt, so plan pilots for it whatever the data size; logic that stays on SQL Server under Split does not set the tier.
- A trial load proves the method. A tier picks a tool, not an outcome. Microsoft: “Run test migrations in a staging environment to validate accuracy and relationships.”
Microsoft’s staging environment, where test migrations run, is not the staging database below, where data is fixed.
Alternate keys and mapping limits in the import wizard and dataflows
Start the mapping review with keys.
- Outside virtual tables, a Dataverse table’s primary key is a GUID, a globally unique identifier (field mapping considerations).
- In a dataflow, the unique identifier takes only GUID strings, and only on existing tables.
- Our reading: integer identity values cannot become the primary key through a dataflow, so carry them in an alternate key. Microsoft: “Use Dataverse to define alternate keys that uniquely identify a row in place of the primary key.”
- In a dataflow, a key column makes reloads upsert and no key creates new rows; single-table lookups map through the alternate key of the table they point to.
Our view: build the tables and alternate keys first, ship them through a solution to the target environment, confirm there that each alternate key exists, then run a trial load. Keys and duplicates are the identity problem in our piece on the data-prep tax.
These limits are Microsoft’s for the import wizard and standard dataflows. The pages we checked do not say whether Azure Data Factory, SSIS or code share them; check your loader’s Dataverse connector documentation.
- System columns, dataflows. Dataflow field mapping excludes 18, among them
OwnerId,CreatedBy,CreatedOn,ModifiedBy,ModifiedOn,OverriddenCreatedOn,StateCodeandStatusCode. - System fields, file import. “The following fields are system fields and aren’t supported for import and export.” That list includes
Ownerid,CreatedonandOverriddencreatedon(casing as on each Microsoft page). - Lookups. In a dataflow, polymorphic and multilevel lookups can’t be mapped.
- Line breaks. In a dataflow, multi-line text loses them.
When to use a staging database before the Dataverse load
When the source needs fixing before the load, Microsoft’s staging database approach adds a step: “Rather than transferring data directly from the source system to the target environment, the process introduces an intermediate staging layer.” Data is transformed and validated in a temporary staging database, then loaded.
Our view, on the staging step:
- Staging is where alternate keys, owners, created and modified dates and status get decided. Deciding is not loading: dataflow mapping skips owners, created and modified dates and status, and file import skips owners and those dates. If any of them must carry over, pick a loader beyond the two and confirm in a trial load which of them it writes. If no loader you trial writes them, carry the source values in your own columns, such as a source created-on date and a source owner, so audit or retention evidence survives the move; no page we checked says one loader writes them all.
- The staging database is a copy of production data. Keep it in your own environment under the source’s access rules, and set its deletion date before the first load.
Dataverse API limits are defaults, not a load speed
Dataverse throttles API traffic, and its published numbers are a guide, not a promise. Its service protection API limits page gives these defaults per web server:
| Limit | Default per web server | Window |
|---|---|---|
| Requests | 6,000 | Five-minute sliding window |
| Execution time | 20 minutes (1,200 seconds) | Five-minute sliding window |
| Concurrent requests | 52 or higher | None given |
The limits are scoped narrowly:
- Per user. Dataverse evaluates them for each user, and each web server enforces them independently.
- Trial environments. “Trial environments allocate only a single web server.”
Do not multiply them into a load time or a tenant ceiling. “Don’t try to calculate how many requests to send at a time.”
What to build instead:
- Retries. Loaders must handle service protection errors and retry. Microsoft’s complex migration workflow guidance: “If you write your own code and use the Dataverse Web API, make sure you retry 429 errors as described in Service protection API limits. If you use the Dataverse SDK, it manages these errors for you.”
- Parallel single requests first. “Most scenarios are fastest sending single requests with a high degree of parallelism.” If you batch, Microsoft says to start at 10 and raise concurrency until limit errors appear. Microsoft’s migration workflow page suggests larger batches for some tables; we follow the API limits page, which is product documentation updated in October 2026.
Load order, validation and cutover
Plan the checks before the first trial load. Our view: a trial load is where the failures Microsoft names below are cheapest to find.
- Dataflow route. Competing writes can make some rows fail on a constraint in the destination table. If the dataflow’s delete option is on: “If any row fails to load into a table, the entire deletion step for that table is skipped for that refresh.”
- ETL route. Microsoft’s staging guidance asks for retry logic and checkpointing, and to “Validate data completeness and integrity before loading data into Dataverse to avoid partial or corrupt migrations.”
Our view, for a SQL Server source:
- Load referenced tables before the tables whose lookups point at them.
- Compare row counts per table between staging and Dataverse after every trial load.
- Decide how changes made during the move are caught up.
- Set a rollback point before cutover.
Illustrative example: a SQL Server 2016 order app, table by table
Illustrative example, not a client: an order tracker on SQL Server 2016, keyed on an int identity OrderID. Staff enter orders on screens, two transactional stored procedures post them, a nightly SQL Agent job rolls them up, and a report queries Orders directly.
- Orders and their screens: Migrate; Dataverse is the system of record for Orders, since the rebuilt screens are Power Apps.
- Posting logic: the two transactional procedures are rebuilt on the Dataverse side, not copied; the pages we checked give no conversion path. Our view: this is the trade-off the fourth signal names. If posting must stay one atomic transaction, Orders and the procedures stay on SQL Server or Azure SQL, and the result is Leave.
- Nightly roll-up: stays a batch job on SQL Server, upgraded, or Azure SQL, reading a copy of posted orders; that copy is the one integration to design, and it runs after cutover.
- The report: re-pointed to the roll-up copy, since it runs heavy queries.
- OrderID: an alternate key, since a Dataverse table’s primary key is a GUID, and Orders is not a virtual table.
- CreatedBy, CreatedOn and StatusCode: decided in staging; dataflow mapping skips all three, so a trial load confirms the loader writes them.
The result is Split, with Orders as its one shared table.
SQL Server to Dataverse migration checklist
Answer these before you pick a branch or a tool.
- Versions and dates under the app.
- How the app writes: every write path, stored procedure, trigger and SQL Agent job, and whether each runs a multi-step transaction and how often.
- Who reads the database directly: reports, integrations, spreadsheets.
- Who uses which part: Microsoft says to evaluate Dataverse for the Power Platform parts; batch and heavy-query parts may stay off Dataverse.
- Size and complexity: take the highest tier.
- Keys: alternate keys for integer identity values.
- Columns the wizard and dataflows skip: owners and created and modified dates on both; status, some lookups and line breaks on dataflows. Check whether your loader writes them.
- Capacity, licensing and security model: priced and mapped before choosing Migrate or Split.
- Retry behavior: tested outside a trial environment.
- Validation and cutover: the checks under Load order, validation and cutover.
What this page does not cover
Beyond the limits above, you still own:
- Licensing and Dataverse storage capacity, including how database size turns into storage.
- The security model, from SQL Server logins, roles and row-level rules to Dataverse security roles and owners.
- Rebuilding screens, reports and logic.
- The integration on every table both halves of a Split touch: how it is built, who runs it after cutover, and which side wins when both change a row.
- A Cloudflare Workers front end, for commercial Microsoft cloud tenants: as of November 2026, Cloudflare’s Hyperdrive supported databases table lists SQL Server as “Not currently supported.” We checked Hyperdrive only.
- Network access from an on-premises SQL Server to the load tool.
- The Windows Server 2016 host, if your SQL Server runs on one: this page covers the database, not the operating system move.
- Clouds other than commercial Microsoft tenants.
Talk through your SQL Server app before you commit
If your app sits on SQL Server 2016 or 2017, a short call with Citizen Development Academy can walk through which branch to look at first and what to measure before you spend on a method; the decision stays with your team.
Book a free 1:1 migration consultation with Citizen Development Academy
Stay in the loop
Get new posts delivered to your inbox. No spam, unsubscribe anytime.
Related articles
Dataverse MCP Server: Tool Shape Is Your New Security Perimeter
Microsoft's Dataverse MCP Server turns your system of record into agent-callable tools. The contract you define, not the platform, decides what an LLM can do.
Spec-Driven Power Automate: Parallel Flow Generation From a Single Spec
How a precise markdown spec, tag-based architecture, and parallel AI agents turn a batch of notification flows into a clean Dataverse solution import. Pattern walkthrough.
XrmToolBox Schema Export to ERD with Claude - 5-Minute Visual Documentation
Export your Dataverse schema from XrmToolBox and use Claude to generate a Draw.io ERD in minutes. No manual diagramming required.