SAP CPQ Performance: When Quoting Is Slow

Configurations lag, quote refreshes take too long and reps start avoiding the refresh button. We trace the delay to the script, formula, query or outside call behind it, and we fix that one thing instead of guessing.

Slow SAP CPQ Is Almost Always Measurable

Short answer: SAP CPQ is usually slow for one of four reasons: a script, a formula, a database query or a call to an outside system. The Developer Console breaks a slow action down into exactly those four buckets, so the cause can be measured on your own tenant instead of argued about.

SAP is direct about why this happens. Its own performance troubleshooting guidance says that SAP CPQ is highly flexible, but extensive modelling can affect the performance. That is not a defect but the cost of one system running your product rules, pricing and approvals together. A tenant that was quick at go-live drifts as scripts, rules and integrations accumulate, and nobody notices until sales reps stop trusting the screen. Slow quotes and script timeouts sit next to the other patterns in our list of recurring SAP CPQ issues and how each one is traced, and they are the ones where guessing costs the most, because a change made in the wrong layer takes days to test and fixes nothing.

The rest of this page follows the order we work in: measure first, isolate the layer, then change the one thing that is actually slow. If you want the wider argument about why performance decays over time, we cover it in our longer article on why CPQ performance decays and how to tune it. This page is the diagnostic side of that story.

The Delay Is in a Script

Iron Python scripts run inside the request, so a slow script means a slow click. Script Performance under Developer Tools lists scripts by longest and average execution time over the last thirty days and highlights the ones approaching the time limit. Typical causes are loops placed in events that run for every item, and time consuming work hooked to an event that fires on every quote change.

The Delay Is in a Formula or a Query

The Developer Console reports how many formulas were evaluated, how long they took in total and which ten were slowest, and it does the same for database queries. A formula that is cheap once can be expensive when it runs for every item on a large quote. Custom tables add their own factor, since SAP notes that nonclustered indexes on them are requested through an incident ticket.

The Delay Is in an Outside Call

Calls to other systems through helpers such as RestHelper, SFCommunicator and VCCommunicator are counted separately in the Developer Console, with their number and duration. A quote that waits for an ERP, CRM or pricing service is only as fast as that service, and a call placed in an event that fires on every change is repeated on every change.

The Delay Is in the Browser or the Network

The Developer Console measures server side processing only, and SAP says so explicitly. If the server time is small and the user still waits, the remaining suspects are UI customizations, the number of columns in the quote item list and the network between the user and the tenant. Switching customizations off in the console and repeating the measurement separates them quickly.

How We Trace a Slow Quote on Your Tenant

We start by making the slowness repeatable. Someone has to name the action, because slow is not a measurement: opening a quote, adding a product, changing a quantity, refreshing and saving each run different parts of the pipeline. With the action fixed, we open the Developer Console from the Setup side menu, press Clear, repeat the action once and read the result. The console captures up to 100,000 traces per request, where a request is one click in the application, and every action is listed with its duration. Two cautions from SAP's own documentation shape how we read it. The time shown is server side processing time only, not what the user experiences in total, and having the console open can itself add overhead. It tells us where the server spent its time. It is not a stopwatch for the whole screen.


Then we use the breakdown SAP recommends: database, scripting, formulas and external API calls. Each shows a count, a total time and the slowest entries, and usually one of the four dominates. If scripting dominates, we move to Script Performance, which covers the last thirty days and shows each script's longest and average run time and how many times it ran. SAP documents a script execution limit of 900 seconds for existing tenants and 300 seconds for new ones, and scripts that come close are highlighted. A script does not have to approach that limit to be a problem for a user waiting on a click, though. One that takes a few seconds on every quote change is slow long before anything turns yellow. To test whether scripting is responsible at all, we use the Disable Iron Python Script Execution option, which stops both global and local scripts for as long as the console is open.


Inside a slow script, the same few patterns keep turning up. SAP advises if and else over try and except for performance reasons, and its own example of a loop running 100,000 times shows roughly half a second for the first against five and a half seconds for the second. SAP also advises avoiding the OnEveryTimeQuoteChanged event for time consuming work such as querying Custom Tables or calling a web service, and notes that the AddNewRow method of a container triggers rules by default unless you tell it not to. Loops placed in OnItemAdded deserve suspicion for a simple reason: that event runs for every item separately. None of this is exotic. It is ordinary scripting done under deadline, and it adds up. When a tenant needs that cleanup done next to other changes, it usually falls under customization and optimization work on the existing setup.


If the console points at formulas or queries rather than scripts, the question becomes what the quote is being asked to compute. Formula time grows with the number of items it touches, which is why a large quote exposes problems that a small test quote never showed. In Quote 2.0 there is a discounts option that calculates discounts only for changed items, and an option to make Variant Configuration and Pricing calls on demand instead of on every configurator change. For quotes that use SAP Variant Configuration and Pricing, SAP recommends restricting a quote to 100 items and finding a balance between the number of items and the complexity of the pricing procedure. That figure belongs to that service, and we treat it that way rather than as a general limit for every SAP CPQ tenant. SAP also notes that audit data tables are large because they log every activity, and that querying them directly should be avoided, which is worth remembering when a custom report or script reads from them.


Sometimes the measurements point outside SAP CPQ, and that is a legitimate finding. When the external API section carries most of the time, the fix belongs with the connected system or with the place in the flow where the call is made, and our SAP CPQ integration work is the natural place to review it. Tax calculation is a common example of a service that a quote ends up waiting on, and where that call sits in the architecture is covered in our article on tax calculation patterns in CPQ architecture.


When a slowdown will not yield, or when it is intermittent, we prepare the case for SAP support the way SAP asks for it: the exact user action with screenshots and the data used, the ID of the user who saw the problem, the timestamp, an HTTP trace from the browser in HAR format and the Developer Console trace exported as an XLSX file. A report with those attached moves faster than one that says quoting is slow. If you would rather learn first whether your setup has structural problems, an SAP CPQ health check reviews the configuration before it turns into an incident, and the same method can be handed to your own team through training built for internal administrators.

What We Check When SAP CPQ Feels Slow

  • The slowest user actions, reproduced with the Developer Console open and cleared between runs
  • Scripts ranked by longest and average execution time in Script Performance over the last 30 days
  • Events that run for every item or every quote change and do more work than they need to
  • Try and except blocks inside loops, which SAP advises replacing with if and else
  • Formulas and database queries, starting from the ten slowest in the Developer Console breakdown
  • Outside calls made through RestHelper, SFCommunicator or VCCommunicator, and where in the flow they fire
  • Trace and Log output left switched on, since writing to the log can slow scripts down
  • Quote size, the columns in the item list and the Page items parameter on quotes with many items
  • UI customizations and the network path, isolated by repeating the measurement with customizations off
  • The catalog parsing application parameter, which SAP asks you to check is set to FAST
SAP CPQ for sales teams improving sales quoting process and CPQ sales efficiency

What Changes Once the Slow Step Is Found

1.

A named cause

You get the specific script, formula, query or call that is slow, with the measurement next to it, instead of a list of general possibilities.

2.

A change in one place

The fix goes into the layer that is actually slow. Rules, pricing and integrations that were fine are left alone, which keeps regression testing small.

3.

A real before and after

We measure the same user action before and after the change, on realistic quotes, so the improvement is something you can see and not something we assert.

4.

A method your team can repeat

We document the sequence we followed, so the next complaint from a sales rep starts with your administrators opening the right tool.

SAP CPQ Performance Questions We Get Asked

Why is SAP CPQ slow?
Usually because of one of four things: scripts, formulas, database queries or calls to external systems. SAP's own guidance says that SAP CPQ is highly flexible, but extensive modelling can affect the performance. The Developer Console shows which of the four is responsible for a specific slow action.


How do I find out what is slowing down SAP CPQ?
Open the Developer Console from the Setup side menu, press Clear, repeat the slow action once and read the breakdown into database, scripting, formulas and external API calls. Then open Script Performance under Developer Tools to see the slowest scripts of the last thirty days.


Does the Developer Console show the total time a user waits?
No. SAP states that the execution time it shows reflects server side processing only, and that having the console enabled can add overhead. Browser rendering, UI customizations and network time have to be checked separately, and the Disable UI Customizations option helps isolate the first of those.


Can a script make SAP CPQ slow without ever timing out?
Yes. SAP documents an execution limit of 900 seconds for existing tenants and 300 seconds for new ones, but a script that takes a few seconds and runs on every quote change is slow for the user long before it nears that limit. Causes SAP points to include try and except blocks in loops and time consuming work in events that fire on every change.


Does the number of quote items affect SAP CPQ performance?
It can. SAP tells administrators to measure with meaningful data, including quotes with exceedingly high numbers of items or quote item custom fields, and for SAP Variant Configuration and Pricing it recommends restricting a quote to 100 items. Quote 2.0 also has an option to calculate discounts only for changed items.


What should I send SAP when I report a performance problem?
SAP asks for the specific user action with screenshots and the data used, the ID of the user who experienced the issue, the timestamp, an HTTP trace from the browser as a HAR file and a Developer Console trace exported as an XLSX file.

Is Your Quote Screen Slower Than It Should Be?

Tell us which action is slow, for which user type, and roughly how large the quotes are. We will start with the measurements SAP CPQ already gives you and tell you where the time is going.

WHAT OUR CLIENTS HAVE TO SAY ABOUT US

Recent testimonials from our clients

Need help with your SAP CPQ project?