Bibo Tran

Issue Description

When developers configure text field lengths in Dataverse through Power Apps, the visible MaxLength value does not clearly show how the field may be projected downstream through Azure Synapse Link.

In this scenario, a Dataverse field with a visible maximum length of 80 characters was projected into Synapse SQL as a much larger varchar length due to how Dataverse DBLength and Synapse Link schema generation are handled.

This can create confusion for developers and data architects because the field appears correctly sized in Dataverse, but downstream systems may receive a wider schema than expected. As a result, we may only discover the impact later when Data Warehouse updates, ADF pipelines, or other downstream processes encounter failures and require additional code or schema changes.

Current Pain Points

• We only see the business-level field length in Power Apps, not the effective storage length or downstream projection length used by Azure Synapse Link.
• We may assume that a field configured as MaxLength = 80 in Dataverse will remain equivalent to 80 characters in downstream SQL systems.
• The generated Synapse Link schema may appear incorrect or unexpected when external tables are created with larger varchar lengths than the value shown in Power Apps.
• The impact may only become visible after the downstream schema has already been generated and related pipelines or Data Warehouse processes begin failing.
• This can lead to operational impact, as we may need to review schemas, adjust downstream code, split wide tables, or redesign parts of the data model after implementation.
• The behavior may be perceived as a product defect because the Power Apps UI does not clearly explain why the downstream SQL schema is larger.

Key Confusions

MaxLength versus DBLength

Developers see MaxLength in Power Apps, but Azure Synapse Link uses the Dataverse database length rather than only the visible MaxLength value. This creates confusion when the downstream schema does not match what is expected from the Power Apps UI.

Unicode versus non-Unicode projection

Dataverse string fields are stored as nvarchar, while Synapse projections may use varchar. Because DBLength is byte-based and carried into the downstream projection, the generated SQL length may appear larger than expected.

Historical field length changes

If a field previously had a larger allocation, reducing the visible field length may not always result in the downstream schema matching the newly expected size.

Design-time versus runtime impact

The risk is not obvious during Dataverse table design. We may only see the impact later when downstream systems encounter failures related to wide rows or oversized variable-length columns.

Proposed Improvement

Improve Public Documentation for Dataverse Field Length and Downstream Schema Projection

Developers and architects may design Dataverse fields based on the values shown in Power Apps without clear public guidance on how those values may be translated downstream through Azure Synapse Link.

Although documentation and FAQ content exist, this scenario shows that the current guidance may not be clear enough for teams designing Dataverse tables for analytics, reporting, ADF pipelines, or Data Warehouse workloads.

The related public documentation and FAQ pages should be updated to clearly explain:

• The difference between Power Apps MaxLength and Dataverse DBLength.
• Why Dataverse string fields may have backend storage characteristics that differ from what is shown in Power Apps.
• Why Azure Synapse Link may project string fields into SQL with a larger varchar length than the visible MaxLength.
• What design considerations should be reviewed before using Dataverse as a source for downstream analytics or Data Warehouse workloads.
• Examples showing how a field configured in Power Apps may appear after Synapse Link projection.

Together, these improvements would help developers and architects make informed database design decisions earlier, reduce unexpected downstream failures, and improve transparency around Dataverse-to-Synapse schema behavior.