Best Of
Feature Request: Model Copy API Endpoint
1. The Problem
Currently, there is no API endpoint available to programmatically copy an Anaplan model. This is a critical gap for workspace administrators who need to back up models before making changes. The only available method is a manual, UI-driven process — requiring an administrator to navigate to the Model Management dialog, select the model, and manually trigger a copy each time.
This creates a significant bottleneck in our workflow. Before any meaningful change is made to a model, a backup copy must be created to safeguard against unintended consequences. Without an API, this step cannot be automated or integrated into our existing deployment and change management pipelines, forcing administrators to perform this repetitive task by hand.
2. Frequency and Impact
Every change cycle requires a manual backup, meaning administrators are spending valuable time on a repetitive operational task that could and should be automated. At scale, this compounds significantly — the more active the development cycle, the greater the burden on the team.
3. Ideal Solution
We would like Anaplan to introduce a REST API endpoint for model copy, such as:
POST /workspaces/{workspaceId}/models/{modelId}/copy
With a request body accepting a target model name and optionally a target workspace ID. This would allow workspace administrators and integration teams to:
- Automate pre-change backups as part of a pipeline
- Integrate model backup into CI/CD or change management workflows
- Eliminate manual intervention for a routine but critical operational task
This would meaningfully reduce administrative overhead, improve consistency of backup practices, and bring model management in line with the automation capabilities already available elsewhere in the Anaplan API.
Enable Export of New UX Pages and Module Metadata from New Model Experience
In as much detail as possible, describe the problem or experience related to your idea. Please provide the context of what you were trying to do and include specific examples or workarounds:
We are trying to export and document Anaplan New UX pages and model metadata for governance, audit, impact analysis, and knowledge management purposes.
Currently, there is no native option to export New UX page configurations, layouts, cards/components, context selectors, synchronization settings, linked modules/views, actions, or navigation details. This creates a documentation gap because important UX configuration details exist only inside the Anaplan interface and cannot be extracted in a structured format.
Specific examples include:
- Identifying which pages are connected to which models, modules, and saved views
- Reviewing which cards/components are used on each page
- Documenting filters, selectors, and context synchronization
- Comparing UX page configuration across development, test, and production apps
- Performing impact analysis before changing modules, views, actions, or lists
- Creating audit-ready documentation of UX design and configuration
For module metadata, there is a partial workaround by switching back to the Classic/Old Model Experience to export module information. However, this does not address New UX page metadata and does not fully support governance needs in the New UX experience.
Workarounds:
Current workarounds are manual and time-consuming:
- Taking screenshots of UX pages
- Manually documenting page layouts and cards
- Opening each page one by one to review settings
- Manually tracing source modules, saved views, actions, and context selectors
- Maintaining external documentation in Excel, Word, or SharePoint
- Switching to the Old Model Experience for limited module export options
These workarounds are not scalable, are prone to human error, and become difficult to maintain as apps, pages, models, and business processes grow.
How often is this impacting your users?
This impacts us regularly, especially during:
- New model or app development
- Production release cycles
- Model changes and impact assessments
- Governance reviews
- Audit or compliance documentation
- Knowledge transfer
- Support and troubleshooting
- Migration or environment comparison activities
For large enterprise environments with multiple workspaces, models, apps, and UX pages, this can impact users weekly or during every major enhancement/release cycle.
Who is this impacting? (ex. model builders, solution architects, partners, admins, integration experts, business/end users, executive-level business users)
This impacts multiple Anaplan roles, including:
- Model builders
- Solution architects
- Workspace administrators
- Tenant administrators
- Integration experts
- Business analysts
- Support teams
- Governance teams
- Documentation owners
- Business process owners
- Partners and implementation consultants
Business/end users may also be indirectly impacted because manual documentation and impact analysis can delay enhancements, issue resolution, and release timelines.
What would your ideal solution be? How would it add value to your current experience?
The ideal solution would be a native export capability for New UX Pages and New Model Experience metadata.
This should allow administrators and model builders to export structured metadata for:
- Apps
- Pages
- Page types
- Page layouts
- Cards/components
- Source models
- Source modules
- Saved views
- Actions
- Context selectors
- Filters
- Synchronization settings
- Navigation links
- Page access/security information
- Last modified details
- Owners or administrators
Please include any images to help illustrate your experience.
1454884
Workspace hygiene recommendations: A readiness guide for Anaplan AI Gateway
Anaplan AI Gateway (“Gateway”) is a supported, governed MCP (Model Context Protocol) interface that connects external LLMs, assistants, and agents, such as Claude, Gemini, and Microsoft Copilot, to your Anaplan models. It lets your teams’ LLM clients query your Anaplan models directly. This means users can ask questions about their plans in natural language, or you can build custom agents or solutions using your LLM.
The AI Gateway supports both read and write (coming soon) access, so users can retrieve data from their models and update it from the AI tools they already use. The Gateway applies your existing Anaplan permissions to each request, so users can only read or write what they are authorized to.
Because the Gateway relies on native Anaplan permissions, the state of your workspaces matters. Before you turn it on, there are four things worth knowing:
- Available by request: Depending on your License edition, you can request that Gateway be made available in your Tenant through your Customer Success Business Partner.
- Enabled at the workspace level: Your AI Admin Role will select the workspaces that are Gateway-enabled from Agent Studio. Once Gateway is enabled for a workspace, any online model in that workspace (models that are not archived and not in offline mode) can be queried by your LLM client. Workspace Admins can also query models while they’re offline, just as they can access offline models in the modeling experience.
- Model access still applies: A user must still have access to a specific model before their LLM client can reach it.
- Hygiene is the key: Workspaces often hold models that were never meant for end users, and permissions on those models often aren’t reviewed regularly.
With AI Gateway, correct user permissions are more important than ever, so now is a great time to review the health of your workspaces. This guide gives Workspace Administrators, COE leads, Solutions Architects, and Model Builders a six-step review to run before enabling AI Gateway, plus many other resources to help maintain your Workspace hygiene over time. If your workspace allowance supports it, you can also reduce exposure by moving models into fit-for-purpose workspaces. For any live model you move, this guide walks through what to update so everything keeps working as intended.
How AI Gateway changes things
Many workspaces contain models that were never meant for end users; model copies used to test functionality, data hubs, or older versions kept “just in case,” to name a few. Additionally, Dev/Test/Prod models sometimes end up in the same workspace, even though that isn't considered best practice. Up to this point, it’s been easy to park models wherever and ignore them.
End users are unlikely to encounter these models if they aren’t exposed in a UX app or page, or if the model contents are turned off. As a result, builders rarely worry about verifying or updating user permissions. In practice, the lack of a UX has acted as protection: if users can’t view the data in an app, nobody sees it.
Gateway changes that. Because data access is enabled for the full workspace rather than for an App, it isn’t limited to what you’ve published. Any model a user has access to in that workspace is discoverable and queryable from their LLM client, whether or not that was ever intended.
The key takeaway for admins
“It isn’t in an App” is no longer a valid mitigation. If a user still has access to a model in a workspace where AI Gateway is enabled, their LLM client can reach it. Treat every model in the workspace as if it is one prompt away from the users who have access to it.
Workspace-level enablement also gives you a second lever. Beyond tightening permissions, you can group models into workspaces built for a specific purpose, so enabling AI Gateway on one workspace doesn’t put unintended models in reach.
The workspace review checklist
The steps below outline what to do before enabling AI Gateway on a workspace. Run them for each workspace you plan to enable, and repeat them periodically as your models and environment evolve.
The six steps at a glance:
Step | Action | Outcome |
|---|---|---|
1 | Audit your models | A clear list of which models are still needed, who uses them, and whether they belong in their current workspace. |
2 | Archive unused models | Fewer live models mean less to secure and maintain since archived models are not accessible via AI Gateway. |
3 | Perform a data access review of each model | Data permissions are set to protect any sensitive data within all models that will remain in the workspace. |
4 | Move models that belong elsewhere | Models grouped into workspaces by use case, user group, and lifecycle stage. |
5 | Follow the Moving models across workspaces guide (as needed) | Every moved model, integration, app, and report works as intended in its new workspace. |
6 | Check users in every model | Only the right users can see and query each model. |
Step 1: Audit your models
Start with an inventory of every model in the workspace. For each one, decide whether you need it to stay active and whether it belongs in this workspace.
Checking your inventory:
- Is the model still in use? Check when it was last used, and by whom.
- Does it need to be live? Some models only matter at certain points in the year, or for audit. Those may be better offline or archived, or moved to another workspace.
- Does it belong in this workspace? Consider its use case, its users, and its ALM role (Dev, UAT, or Production). Note: Production models should be the ONLY model in that workspace to simplify user access, enforce segregation of duties, streamline maintenance, and improve performance.
- Does it have an obvious owner? Models with no owner are the ones most likely to hold forgotten permissions.
- What is being used by the model? List target models, integrations, ADO pipelines, AXL workbooks, App pages, workflow tasks, and published links.
Record the answers in a register kept outside Anaplan, including the workspace ID and model ID for each model. It makes the next steps and any future audit much faster.
Step 2: Archive any unused models
Fewer live models mean less to secure, less to maintain, and less for Gateway to reach.
- Can the model be archived? Anything with no owner, no recent use, and no dependencies is a strong candidate.
- Is it a source for other models? If so, repoint the import data sources in those dependent models first.
- Would offline mode be a better fit? For models you need occasionally, taking them offline can be better than leaving them live.
- Is the model genuinely no longer needed? If so, delete it once you’re sure there is no reason to keep it.
Planning for archived models
You can bring archived models back online as needed, but doing so in a Gateway-enabled workspace requires a bit more caution. If you don’t intend for that model to be discoverable, there are a couple of things to consider:
- Are your archived models named consistently? You will want to apply a consistent naming convention to your models before putting them into an Archived state. This is a best practice anyway, but it is potentially more important for Gateway-enabled workspaces to create a clear signal to users and WSA that if they see something named ARCHIVE, for example, they should use caution before binding and querying that model. The recommended naming convention is a derivative of “ARCHIVE”_”Date of Archive”_”Model Name”, or a shortened version, as long as it is consistently applied. Example: ARCHIVE_Dec 26_FP&A Production.
- Are you restoring an archived model? To minimize discoverability to only WSA, it is recommended to bring the model out of the archived state and directly into offline mode. This allows you to perform any cleanup and data access checks before making it available, or to pull data without ever exposing it beyond the WSAs.
- Are users set to No Access? Another way to minimize accidental queries when you bring a model online is to ensure all users are set to No Access before archiving the model. However, you should verify No Access is set correctly anytime you unarchive models.
Step 3: Review data access in the models that remain
Every model that you plan to keep in a Gateway-enabled workspace should go through a data access review. Since AI Gateway can connect to all models in the workspace, you will want to verify that the data the user can access is as intended. Work through the model-level checklist in Anaplan Analyst & AI Gateway: A readiness guide for builders for each model.
Full model discovery
AI Gateway can discover the full model. As noted earlier, the assumption “if it isn’t published, users won’t see it” doesn’t hold for model data in Gateway-enabled workspaces. Gateway access isn’t limited to data published to a UX App or Page; it can access every line item users are permitted to see based on module-level permissions and every list member not restricted by Selective Access. The model layer, not the UX, determines what data is returned.
Checking data access:
- Are Model Role permissions set appropriately? Confirm no role has broader access than they need, including write access.
- Is Selective Access enabled where needed? Apply it wherever sensitive data is present.
- Is Dynamic Cell Access (DCA) in place where it is needed? Confirm data is restricted at the cell level where appropriate, and that the driver logic behind it is sound.
- Can you restrict access enough to protect the data in this model? If the answer is no, mark the model to move in Step 4.
If you can’t protect it, move it
A model whose data you can’t adequately restrict shouldn’t sit in a workspace where AI Gateway is enabled. Because enablement applies to every model in the workspace, relocating the model is often simpler and safer than trying to engineer around it.
Step 4: Move models that belong in a better workspace
Some models end up sitting in a workspace that has become a catch-all. If your workspace allowance allows, move models into workspaces designed for their purpose.
Planning your workspace ecosystem
- Are models grouped by use case or common user group? A workspace that serves one audience is easier to review and to secure.
- Do Dev, UAT, and Production each have their own workspace? This is already an ALM best practice, and it keeps AI Gateway exposure aligned with each environment.
- Are you stuffing everything into a few workspaces for simplicity? Convenience today becomes a wide access footprint later and can lead to performance issues.
To request new workspaces, reach out to your account team.
Step 5: Make sure moved models work as intended
Not all models you move will need these steps, but for any that will remain live, you will have a few additional items to verify and potentially action. Moving a model has real consequences; you will need to consider any impacts to integrations, users, ALM, etc., so read “Moving models across workspaces” later in this guide before you start.
Every model you move is a new model with a new workspace ID and model ID. Treat each move like a mini release: freeze changes in the original, validate the copy, then cut over. Lock or archive the original model once everything has been confirmed to be repointed and updated appropriately.
It is always easier to maintain a model in the original workspace, which is another reason to plan, review, and maintain your tenant ecosystem and to review your workspace hygiene periodically. You want to build your models where they will be used and retained.
Step 6: Check user permissions in each model
For each workspace that you plan to enable Gateway, review the user access permissions in every model that remains, confirming that only the appropriate users have access.
Checking your users
- Does anyone have access to a model they shouldn’t be able to discover? Set their access to No Access. This applies to all models, but may be more important to models that aren’t exposed in any App or Page.
- Are there users who don’t need access to any model in the workspace? Remove them from the workspace.
- Are users marked as workspace administrators (WSA) correct? Keep it to the users who genuinely manage or build models in this workspace. This should follow the recommendation that models should be added to fit-for-purpose workspaces whenever possible. Your WSA should also match the purpose of the models within as well. For example, for segregation of duties purposes, your Production Model environment should include only the WSA responsible for performing the model sync.
Note: These recommendations are focused only on the native Anaplan user access and do not include any additional permissions or access that may be applied via your LLM client.
Add new users with No Access
Whenever you add a new user to a model, add them without WSA access and with the Model Role set to No Access. That sets their permissions to No Access across all models in the workspace, and you can then apply WSA permissions and their role in each individual model as needed. If you add them with full access, that access applies across all models, including any new models added, and you will have to correct it in every model where it wasn’t intended.
Check WSA access for every new model
When you add a new model to a workspace, any user that is a WSA will automatically inherit the Full Access permission as their Role. This is also true for every new WSA added to a Workspace, they will be added to all existing models as WSA and Full Access by default. If this is not intended, you will need to update their Model Role to the appropriate role.
Build this into your routine
This isn’t a one-time exercise. Workspace reviews like this are good practice whether or not AI Gateway is enabled, and they keep working for you long after the first clean-up.
- Inventory your workspaces and models. Keep the register current, with an owner for every model and workspace.
- Work through the checklists with people who know the design. Workspace Administrators, COE leads, and Model Builders are best placed to confirm who should have access to what.
- Set a regular cadence. Pick an interval that fits your team, quarterly or aligned to your release cycle, and repeat the review.
- Revisit after changes. A new model, a new workspace, a new group of users, or AI Gateway being enabled on another workspace should all trigger another check.
- Keep sensitive models apart. If a model holds data that should never be queried through an LLM client, keep it in a workspace where AI Gateway isn’t enabled, or restrict access to it.
Design considerations
- AI Gateway follows the workspace, not the App. Review at the workspace and model level, even if your earlier checks focused on what’s exposed in UX Apps.
- Permissions are what decide reach. UX pages shape the experience, but a user’s access to a model within a workspace decides what their LLM client can reach.
- Clean workspaces narrow exposure; they don’t replace model security. For the models that remain, review Roles, Selective Access, and Dynamic Cell Access too. See Anaplan Analyst & AI Gateway: A readiness guide for builders for a model-level checklist.
- Make it routine. Add this review to your existing release testing and access reviews rather than treating it as a separate task.
Conclusion
Getting a workspace ready for AI Gateway is the same work that keeps any production environment healthy: knowing which models you have, keeping only what you need live, putting models in the workspaces they belong in, and making sure only the right users can reach each one. Because AI Gateway is enabled for the whole workspace, a tidy workspace is now part of your security boundary. Work through the six steps, make them a recurring check, and you’ll be in a strong position to enable AI Gateway with confidence.
Resources
Data access review
Workspace and model lifecycle
- The Model Lifecycle: Managing Anaplan Workspaces for Long-Term Success
- Beyond Production: Managing the Anaplan Model Lifecycle
- Workspace Management
- Model Modes and ALM (Anaplan Help)
- Start Here: Application Lifecycle Management, Part 1: The Basics
- What to Know When Moving Models Between Workspaces: A Practical Checklist
Contributors: Elizabeth Schera, Rob Marshall, Allison Slaught, Theresa Reid, Adam Trainer
Add YTD and YTG to Polaris engine
Hello,
It would be a significant advantage to have YTD and YTG calendar items in Polaris. Regardless of the calculation density, these are essential for our reporting requirements—whether supported natively or through a workaround.
Thanks in advance.
Single workflow supporting multiple Models
In as much detail as possible, describe the problem or experience related to your idea. Please provide the context of what you were trying to do and include specific examples or workarounds:
We have a singular workflow for budget monitoring that is identical across 20 models. Currently, we need to create a new workflow for each model, unique UX pages for each, and reiterate 20 times if there are changes.
How often is this impacting your users?
The workflow runs once a month, but maintenance and oversight occurs more frequently.
Who is this impacting? (ex. model builders, solution architects, partners, admins, integration experts, business/end users, executive-level business users)
This primarily effects our center of excellence, who are responsible for the upkeep on the workflows.
What would your ideal solution be? How would it add value to your current experience?
I would like one workflow on one UX page to be able to apply to multiple models.
Please include any images to help illustrate your experience.
Tiledos
Anaplan Polaris — Calculation Complexity
This article is part of a series on Polaris best practices. Click here for more Community content or visit Anapedia for detailed technical guidance.
What is the Calculation Complexity column?
The Calculation Complexity column is one of the Blueprint Insights in the blueprint view of a module (or the Line Items tab). It only exists in the Polaris calculation engine. It shows how the engine interprets a formula: how many cells it calculates, and potentially populates, for each populated source cell.
This matters because Polaris is efficient by doing work only for populated cells, meaning cells that hold something other than zero, blank or false. Reviewing the highest values against Planual and best practice guidelines can reveal where to optimize. A line item’s true complexity factor can’t be seen until lists are fully populated, so following Iterative Development is a must.
The Calculation Complexity column can have one of three values, or is blank when the line item has no formula, ranked from most efficient to least:
- One-to-One: the engine calculates the same number of cells as the source, or fewer, so sparsity is preserved. Example: Revenue = Units * Price. The engine multiplies only where Units is populated.
- One-to-Many (N): One-to-Many formulas decrease sparsity because they calculate results for a greater number of cells than make up the source data. N is the complexity factor.
- All Cells: All cells formulas decrease sparsity because they calculate results for all cells within the dimensionality of the resultant line item.
Where to find Calculation Complexity in a model
You can find the Calculation Complexity column in your model in two ways.
Blueprint view of an individual module:
Line Items tab in the Modules pane:
Why is Calculation Complexity important?
Calculation Complexity tells you how much a populated source cell will “fan out” into the target cells. In general, lower complexity means a smaller, faster line item. A line item with a very high Calculation Complexity factor or a value of All Cells at high Cell Count can take a very long time to calculate and take up a large amount of space. When source cells are populated, either via user input or data import, formulas like this can lead to long model open times and/or poor performance as users interact with the model.
How is the Calculation Complexity determined?
Calculation Complexity depends on the dimensionality of each source line item used in the target line item formula: the number of dimensions (including time and versions) and the number of members in each will affect the complexity factor. Compare the “Applies To” and Cell Count of the source and target line items to see why. The bigger the difference in dimensionality, the higher the complexity.
Calculation Complexity examples
A simple example is a calculation that pulls a value from the Year level to the Month level, with no other dimensions and all other things equal. One value at the year level creates 12 values at the month level, so the result is One-to-Many (12).
An extreme example is a source line item with a Cell Count of 99,099, with only one of them populated. The target line item has a Calculation Complexity of One-to-Many (36800000), thus the result of a single populated cell in the source is roughly 36.8 million populated cells and 1.06 GB of memory.
Downstream line items are One-to-One but inherit those populated cells, so the module reached 396,520,000 populated cells and 11.69 GB. Calculating it took 11 minutes with a single populated source cell. This is one observed case, not a threshold, and the cost grows with the number of populated source cells.
It's important to note that the complexity factor displayed is an estimate so the number in parenthesis may not match the cell count exactly. The true number depends on how the data is distributed, and cells that are calculated but end up being zero mean the populated cell count may be lower, but they still had to be calculated.
Using the Calculation Complexity column to optimize formulas
Review Calculation Complexity after loading full lists and before adding in-cell data, as outlined in Step 2 of the Iterative Development article. A line item with a low value in a small DEV model can have a very high factor at full size, which risks slow calculation and heavy memory use in PROD. Catching it before in-cell data is populated avoids size and performance hits in TEST and lets you work faster.
Review the complexity factor both on its own and alongside the other Blueprint Insights. Data populated in source line items can cause high Calculation Effort, high Populated Cell Count and high Memory Used in the target line item. When Populated Cell Count is zero, a high complexity factor at a high Cell Count may be the only sign that a line item should be optimized.
Techniques to lower Calculation Complexity:
- Calculate values at the smallest dimensionality that works, meaning the fewest dimensions. Move calculations to line items with fewer dimensions so values are calculated at the lowest cell count necessary.
- Apply formula guards. A guard is an IF THEN condition that tells the engine which cells to calculate. Polaris already skips zero, blank and false, so a guard helps only when it supplies something the engine can’t infer, such as which products an account sells.
- Keep the ELSE result at zero, blank or false. Anything else can turn the line item into All Cells.
- Keep the ELSE result at zero, blank or false. Anything else can turn the line item into All Cells.
- Populate data only where it is needed.
- Use SUM instead of LOOKUP where possible. At high dimensionality, SUM is more efficient.
Article links:
- Anaplan Polaris — Blueprint insights
- Anapedia | Polaris calculation complexity
- Planual | Polaris — Understanding Calculation Complexity
- Iterative Development in Polaris - Anaplan Community
- Anaplan Polaris — Calculation Effort
- Anaplan Polaris — Applying Formula Guards to Optimize Calculations
……………..
Authors: Anaplan’s Theresa Reid (@TheresaR)
Special thanks to Rob Marshall (@rob_marshall) and Jason Blinn (@jasonblinn) for their contributions.
Dynamic notifications in Workflows
Idea to have an ability to make the notifications dynamic. So lets say, particular workflow is supposed to send out notification that Person X has completed the task, the notification should dynamically mention that 'Person X has completed the task'. X should be dynamic for names X, Y etc.
Allow Page Selectors to reference 'Current Context' when filtering against other dimensions
In as much detail as possible, describe the problem or experience related to your idea.
When designing an App page, there is a need to have page selectors be filterable based on the current context in other page selectors. This is especially true with the adoption of Polaris, where natural dimensionality is more prevalent.
Say we have a page that is by Customer & by Product. If I select a customer in one page selector, I want the product page selector to be filtered to show only products related to that customer.
Right now, we cannot do this. If you were to attempt to filter the products page selector (the above example) using a Valid Combinations module, the product page selector filter prompts you to pick a customer context for the filter (with no 'current context' option). This makes the user experience much more poor when using natural dimensionality, which is becoming our standard with our more frequent adoption of Polaris models.
Who is this impacting?
Business/end users & executive-level business users
What would your ideal solution be? How would it add value to your current experience?
In a page selector's filter contest, allow 'current context' to be an option when it includes other dimensions
JeffreyG
"Model is busy" context
All End Users and Executives experience this issue. When the model locks up (from integrations, inputs, etc) in the UX, all users see is a "Model is busy" without any context. It would be great if:
- They can see who is making the update
- They can get an estimated time of the model being busy
- This is key - When they see “Model is busy”, they might assume it will take minutes like before and therefore it feels like the same slow model. However, it may just take a few seconds, and they can expect it to be quick (instead of walking away from their desk or doing something else).
- Any other information (data input, integration, etc) — not a priority
1 & 2 are available in the backend, so it should be available in the UX!
KevinB
Increase the Breakback Cell Limit in Polaris (or Make It Smarter)
The idea
Please raise the 1 million cell limit for breakback in Polaris, or rework how that limit is applied so it better fits what Polaris is designed for.
The problem
Polaris lets us build models with many more dimensions than Classic, and sparsity is no longer the constraint it used to be. That is a real strength, but it clashes with the current breakback limit. Once you combine several dimensions with sizeable lists, the number of cells affected by a single breakback can easily pass 1 million.
The result is that breakback loses much of its value in exactly the models where Polaris should shine. End users can only enter values at a more granular level, or with less dimensionality then what they would like.
Potential solutions
- Increase the cell limit. This is the simplest option. There is no change in functionality, only a higher threshold that reflects what Polaris can handle.
- Exclude blocked cells from the count. Cells that are blocked through Dynamic Cell Access (DCA) or Selective Access cannot be adjusted anyway, so they should not count toward the limit. This would let Modellers remove irrelevant intersections up front and stay within the limit by design. It also rewards good model governance, since it encourages to precisely define what can be adjusted.
- Rework the breakback logic. A more advanced alternative is the approach suggested in Constant Disaggregation for Breakback. It would address the underlying scalability challenge rather than just moving the threshold.
Why it matters
- Breakback is a core planning capability, and its usefulness should scale with the model rather than shrink as dimensionality grows.
- Polaris encourages more granular, multi-dimensional models, so the limit becomes more restrictive as adoption increases.
- Options 1 and 2 are relatively contained changes that would deliver immediate value to end users.
If you’ve hit this limit in your own Polaris models, please upvote and/or share your workarounds below.











