Getting Error: Failed to save Arm Templates. Error: { "message": "Sorry, your input was too large to process.

@PATEL, SACHIN KUMAR

Thanks for the detailed follow-up. Let me help clarify and guide you through the situation:

Why breaking into smaller PRs still causes the error

You're right, even when you merge just one pipeline, the template generation fails. This is because:

• The error is caused not by the number of PRs, but by the total size of the generated ARM templates (main + linked).
• Even a single complex pipeline can push the size beyond the limits that the GitHub REST API can accept.
• Synapse attempts to create linked templates automatically when the main template becomes large. However, if the combined size still exceeds GitHub's tree object limit (~8 MB), the publish process fails with the error you’re seeing.

You don't need to manage linked templates yourself, Synapse handles that internally.

What does "manually generate" mean?

When we say "manually generate ARM templates", it does not mean writing the template by hand. Instead, it refers to the process of generating the ARM templates outside of the GitHub-integrated publish flow, using Synapse Studio itself.

How to Generate ARM Templates without using the GitHub API

You can do this entirely within Synapse Studio, without relying on GitHub’s REST API. Here’s how:

Disconnect Git Integration Temporarily

• Go to Synapse Studio > Manage > Git configuration
• Click Disconnect (this won’t delete your repo — it just temporarily disables the GitHub sync)

Click “Publish All”

• This publishes your Synapse pipelines, datasets, etc., directly to the Synapse workspace without involving GitHub

Download the ARM Templates

• After publishing, go to Manage > ARM template in Synapse Studio
• Click Download all files
• This gives you a .zip containing:
  • template.json
  • template-parameters-definition.json
  • Any linked templates (if needed)

These templates are generated by Synapse, not by you, and they are exactly the same as what would have been pushed to GitHub, but without using the API.

Why this works

When you publish through GitHub integration, Synapse uses the GitHub REST API, which has strict size limits (especially for tree objects). By disconnecting Git and downloading templates directly, you bypass that limitation.

You can then push these downloaded templates manually to your GitHub repository using the Git CLI, which doesn’t have the same size restriction.

I hope this information helps.

Hi Chandra Boorla,

Thankyou for your response for my clarifications. I have few more questions on this one.

I am able to see Export Template option under automation tab in the synapse workspace settings.

I just want to confirm that the code in this template is the current version of Pipelines/datasets/dataflows in the synapse studio.

I am asking this question because when I was trying to publish all the changes which I did in just 1 branch and then tried to publish then step 1 was successful which published the latest code from "release" branch to the "workspace_publish" branch and it got failed at step 2 which is to generate the template at the github folder ___location using GITHUB REST API.

So if the step 1 publishing the changes is working fine and changes are published to the workspace_publish branch then the ARM template code which is generated at this ___location should be the same which would have generated at the github folder.

If I don't want to disconnect the Git repository and still download the ARM template from the export option under Automation tab on synapse workspace settings.

Will that option ( Manage> ARM Template) will be visible after we disconnected the GitHub repo, as currently I am not able to see this option. I even checked in higher environment to see if this option appears or not, but I cannot see this option anywhere.

Disconnecting repo will require higher access and it is not feasible to do this frequently.

Also I am not sure that whether the ARM template code under this Automation code is from "release" branch or "workspace_publish" branch.

@PATEL, SACHIN KUMAR Apologies for the delay in response.

Thanks for the detailed follow-up! You're asking exactly the right questions, and I’ll break it all down clearly, so you know exactly where the ARM template comes from, what version it reflects, and how Git integration affects this.

About the “Export Template” under Automation tab

The “Export Template” you see under Manage > Automation is intended for resource-level automation (like deploying the Synapse workspace itself), but it does not include all your Synapse artifacts (pipelines, datasets, dataflows, etc.).

So, this export option is not equivalent to the full deployable ARM templates used for CI/CD. It’s more focused on infrastructure and won't help for complete workspace deployments.

Version of code used when generating ARM templates

You're correct in understanding the two publish steps:

Step 1 - Publishes your Synapse code from your working branch (e.g., release) into the workspace_publish branch.

Step 2 - Attempts to generate and save the ARM templates using GitHub’s REST API from workspace_publish.

If Step 1 succeeds, then yes, the content in the workspace_publish branch does represent the deployed state of your workspace, and any ARM templates would be generated from this code. However, when Step 2 fails (like in your case, due to size limits), the templates aren't created or saved automatically.

Can I download the ARM templates without disconnecting Git?

Unfortunately, no. The full ARM template download option under Manage > ARM Template in Synapse Studio is only visible when Git integration is disconnected. While your repo remains intact during disconnection, this step does require elevated permissions and may not be feasible to do frequently in your environment.

If you want to download the full deployable ARM templates (which include all your pipelines, datasets, and other artifacts), you'd need to:

• Temporarily disconnect Git integration
• Go to Manage > ARM Template and use “Download All Files”
• Optionally reconnect Git afterward — no changes will be lost

This is currently the only supported way to download the actual workspace ARM templates outside the GitHub publishing mechanism.

What version of code is used in “Export Template” vs ARM Template (under Manage)?

Workaround suggestion

If disconnecting Git is a one-time possible option (e.g., during a release window), here’s a safe approach:

• Disconnect Git temporarily
• Publish All to deploy latest code
• Download full ARM templates
• Reconnect Git

You can then commit the templates manually to your repo using Git CLI or other Git tooling, this avoids hitting GitHub’s REST API size limits.

I hope this information helps.

Hi Chandra Boorla,

Thanks for the detailed explanations. But I would not go for the temporary delinking the GitHub repository from the Synapse Dev Workspace.

Here are the few developments from the past 1 day:

As per current CICD setup, the 2 ARM templates is consumed by the Azure Devops classic release pipeline for deploying the latest code to higher environments.

But to overcome the this GitHub REST API limitations, Microsoft Support Engineer suggested 2 methods:

1 - Use the YAML pipeline in GitHub Actions Workflow to validate the Artifacts in the "Release" branch and generate the 2 ARM templates to a folder inside the GitHub repository and then from this folder consume the ARM Templates.

2 - Use the YAML pipeline in the Azure Devops and use the "validate" operation Type to validate all the artifacts under the root directory of GitHub repository and generate the 2 ARM Templates in AzureDevOps Artifacts and then consume from these Artifacts.

From both the methods we are bypassing the GitHub Rest API limitations.

I am yet to implement any of the above two steps.

If I go with Method 1 then after every pull request is merged then a workflow will get triggered and the template will be generated and I need to manually verify if it is generated then trigger my classic release pipeline in Azure DevOps, so I was thinking to go with method 2 but I will require some guidance for the 2nd menthod.

@PATEL, SACHIN KUMAR

Thanks for the detailed update, it's great to hear you've already engaged with Microsoft Support and received two viable workarounds to address the GitHub REST API limitation during ARM template generation.

You're absolutely right that both approaches are valid, and each helps avoid the input size constraints by moving ARM template generation outside of Synapse Studio and GitHub REST API calls.

Your Summary Recap:

Method 1 - Use GitHub Actions to validate artifacts in the release branch and generate ARM templates into a folder within the repo.

Method 2 (Preferred by You) - Use an Azure DevOps YAML pipeline to validate Synapse artifacts and output ARM templates into Azure DevOps Artifacts, which can then be used by the existing Classic Release Pipeline.

Great decision to proceed with Method 2 - using an Azure DevOps YAML pipeline is a robust and automated way to bypass the GitHub REST API limitations while keeping everything within your existing DevOps infrastructure.

Here’s a step-by-step guide to help you get started:

Goal of Method 2:

Validate the Synapse workspace artifacts from your GitHub repository
Generate the two required ARM templates:

• template.json
• template-parameters-definition.json

Publish these templates as pipeline artifacts
Consume the artifacts in your Classic Release pipeline

Step-by-Step Setup in Azure DevOps

Create a New Pipeline

• Go to Pipelines > New pipeline.
• Choose your GitHub repo where Synapse artifacts live.
• Select YAML, and create a new pipeline (e.g., generate-arm-template.yml)

Use the following YAML (Template):

trigger:
  branches:
    include:
      - release  # or your deployment branch

pool:
  vmImage: 'windows-latest'

variables:
  resourceGroupName: '<your-resource-group>'
  workspaceName: '<your-synapse-workspace>'
  ___location: '<your-region>'  # e.g., eastus

steps:
- task: AzureCLI@2
  inputs:
    azureSubscription: '<your-service-connection>'
    scriptType: 'ps'
    scriptLocation: 'inlineScript'
    inlineScript: |
      $outputPath = "$(Build.ArtifactStagingDirectory)\templates"
      New-Item -ItemType Directory -Path $outputPath -Force

      az synapse workspace export `
        --name $env:workspaceName `
        --resource-group $env:resourceGroupName `
        --output-folder $outputPath `
        --___location $env:___location

    env:
      workspaceName: $(workspaceName)
      resourceGroupName: $(resourceGroupName)
      ___location: $(___location)

- task: PublishBuildArtifacts@1
  inputs:
    pathToPublish: '$(Build.ArtifactStagingDirectory)\templates'
    artifactName: 'synapse-arm-templates'
    publishLocation: 'Container'

Note: Replace placeholders like <your-service-connection>, <your-resource-group>, <your-synapse-workspace>, and <your-region> with your actual values.

Summary - This pipeline will automatically generate the ARM templates and publish them as a build artifact named synapse-arm-templates. In your Classic Release Pipeline, configure it to consume this artifact and use template.json and template-parameters-definition.json for deployment.

I hope this information helps.