Manage cookies
We use cookies to provide the best site experience.
Manage cookies
Cookie Settings
Cookies necessary for the correct operation of the site are always enabled.
Other cookies are configurable.
Essential cookies
Always On. These cookies are essential so that you can use the website and use its functions. They cannot be turned off. They're set in response to requests made by you, such as setting your privacy preferences, logging in or filling in forms.
Analytics cookies
Disabled
These cookies collect information to help us understand how our Websites are being used or how effective our marketing campaigns are, or to help us customise our Websites for you. See a list of the analytics cookies we use here.
Advertising cookies
Disabled
These cookies provide advertising companies with information about your online activity to help them deliver more relevant online advertising to you or to limit how many times you see an ad. This information may be shared with other advertising companies. See a list of the advertising cookies we use here.

Incoplax platform · April 2026

Load testing: 31.7 million calls in 72 hours

We ran the Incoplax contact center on a seven-server cluster for three days without a break: 4,000 agents, 10 inbound and 125 outbound calls every second, and 2,500 conversations at once.

The test passed. Every agent operation met its response-time target, recordings stayed clean, and the servers never went above 50% CPU or 45% memory, enough headroom to double the load on the same hardware.

How the test was set up

The test bench was a full Incoplax cluster surrounded by emulators: thousands of simulated customers on the phone lines and thousands of simulated agents with desk phones and web applications.

Customer emulators
Inbound callersOutbound call targets
SIP
Test utilities
Inbound call generator HTTPBench setup tools WebSocketMetrics and counters SQL
Incoplax cluster7 servers · contact-center product layer
Monitoring
Dashboards, reports, recordings HTTP, WSServer and service performance HTTP, WSPhones for test calls SIP
SIP · HTTP · WebSocketAgent emulators
Desk phonesAgent web applications
Customers reach the cluster over SIP; emulated agents use SIP phones and the real agent web application over HTTP and WebSocket.

Agents

Inbound1,000
Outbound1,000
Blended1,000
Second line1,000
Test10
Total4,010

Load

Inbound calls10 per second
Outbound calls (predictive campaign)125 per second
Call list375,000 contacts
Contact rate of the listunder 20%
Wrap-up after each call10 seconds

Agent behaviour

Agent apps driven by emulators200, 50 per group
Status changeevery 30 seconds
Agents in “Not ready”10%
Test log-on / log-offevery 60 seconds

Target cluster

Seven servers, each an Intel Core i7-13700 with 16 GB RAM and a 290 GB SSD. PostgreSQL ran outside the cluster as two instances: one for the call list and settings, one for archives (calls, conversations, queue and campaign records, statistics). No external storage: recordings stayed on a local disk and were checked and cleared several times a day.

Auxiliary cluster

Three servers of the same configuration ran the SIP emulators for carriers and agent devices. The database servers were added to it so that all performance data could be watched in one place.

Where each role ran

The cluster was laid out by job: SIP and voice services on two servers, media on three, the product layer on one and data on one. What each role does is explained on the architecture page.

  • ASIP edge
    • sg
    • esg
    • b2b×2

    Also: mdc, mic, ic, rpci, rpco, rsv

  • BVoice services
    • ivr×4
    • b2b×2
    • conf
    • prompt
  • CMedia
    • mgc
    • mg×8
    • mix×4
  • DMedia
    • mgc
    • mg×8
    • mix×4
  • EMedia
    • mgc
    • mg×8
    • mix×4
  • FProduct layer and API
    • msvc×2
    • mware
    • wssubscr

    Node.js product services: contact center, ACD, outbound, statistics

  • GData and state
    • dms×7
    • reg
    • sts
    • callstore
    • huntq
    • recmover
    • broker

    Also: usr, svc, fs, st, logstore, ap, sel, vmail, email, im

On every serverws web server and API · msvc microservice starter · dfsync file sync · performance monitor
24 media gates, 12 recording mixers and 3 media controllers carried the audio of 2,500 simultaneous conversations.

Procedure

The test followed a written methodology with fixed response-time targets for every agent operation. A short rehearsal checked the bench; the main run then held full load for three days.

  1. 13 April 2026 · about 50 minutes

    Preliminary run

    One pass of the outbound campaign through all 375,000 contacts plus 30,000 inbound calls. Dashboards and performance monitors were captured, recordings spot-checked, counters and metrics analysed.

    Result: no deviations; the bench was ready for the main run.

  2. 16–19 April 2026 · 72 hours

    Main run

    Continuous load of 10 inbound and 125 outbound calls per second. The outbound campaign restarted every 30 minutes so that it never idled while waiting for scheduled callbacks, and the recordings folder was cleared periodically.

    Result: test passed; two database bottlenecks were fixed without stopping the load.

How results were checked

  • Built-in monitoring only. The standard supervisor dashboards of the working domain and the performance monitor of the platform administrator application.
  • Two independent counts. Counters and metrics were stored in a database and compared with the emulators' own counts.
  • Listening to calls. Recordings from every agent group were sampled, inspected and listened to during and after each run.

Response times under full load

Each figure is measured on the agent side: from the moment the agent application sends a command to the moment it receives the resulting event. Every operation met the methodology's targets.

OperationTargetAverage, as a share of the 90% targetMaxWithin targetMeasurements
Agent log-onagent.logonTarget 90% ≤ 3 s, rest ≤ 6 s90% ≤ 3 s, rest ≤ 6 s2,269 ms3,033 ms98.5%15,058
Agent log-offagent.logoffTarget 90% ≤ 3 s, rest ≤ 6 s90% ≤ 3 s, rest ≤ 6 s4.8 ms217 ms100%15,054
Answer a callcall.answerTarget 90% ≤ 1 s, rest ≤ 2 s90% ≤ 1 s, rest ≤ 2 s7.3 ms178 ms100%91,195
Hang upcall.dropTarget 90% ≤ 1 s, rest ≤ 2 s90% ≤ 1 s, rest ≤ 2 s1.4 ms45 ms100%89,453
Blind transfercall.transfer.blindTarget 90% ≤ 2 s, rest ≤ 3 s90% ≤ 2 s, rest ≤ 3 s41 ms509 ms100%111,131
Outgoing callcall.makeTarget 90% ≤ 2 s, rest ≤ 3 s90% ≤ 2 s, rest ≤ 3 s77 ms913 ms100%113,259
Start consultative transfercall.transfer.startTarget 90% ≤ 2 s, rest ≤ 3 s90% ≤ 2 s, rest ≤ 3 s78 ms901 ms100%91,699
Complete consultative transfercall.transfer.finishTarget 90% ≤ 1 s, rest ≤ 2 s90% ≤ 1 s, rest ≤ 2 s170 ms1,767 ms98.3%90,205
The bar shows the average response time against the target that 90% of operations must meet; a full bar would mean the average sits exactly on the target.

Other operations

OperationAverageMaxResultMeasurements
Assemble a conference1,030 ms1,137 ms100% within 2 s45,293
Place a call in a queue17 ms757 ms100% within 1 s198,879
Route a queued call to a free agent0.3 ms8 ms100% within 1 s125,654

Voice quality

RTP delay, side A / side B
50 / 53 ms average
Worst RTP delay
379 / 389 ms
Packet loss
0% average, 0.03% worst
RTP samples
over 424,000 per side

Sampled recordings of every agent group were clean on both channels: no dropouts, crackle or other distortion.

Resource usage: half the capacity left unused

The methodology sets the ceiling at 70% CPU and 80% memory. Throughout the test the cluster stayed well below both, with even curves and no spikes.

Peak CPU per server, rehearsal run at the same load

70% ceiling
  • ASIP edge
  • BVoice services
  • CMedia
  • DMedia
  • EMedia
  • FProduct layer
  • GData
CPU load stayed even, without spikes: up to 35% on servers A–E and up to 50% on F and G. Over the 72-hour run it stayed within 25–50% across the cluster. When the load stopped, CPU fell back to 3–5% within minutes, once the mixers had finished the last recordings.
CPU across the cluster
25–50%

against a 70% ceiling

Memory across the cluster
20–45%

against an 80% ceiling

Network per media server
≤ 300 Mbit/s

about 250 Mbit/s between the product layer and the data model

Disks
Minimal load

mostly recordings on the media and data servers, thanks to the external databases

What three days at full load showed

A long run finds what a short one cannot. Both issues it surfaced sat in the external PostgreSQL databases, not in the platform, and both were fixed on a live system without lowering the load.

Fixed under load

The call-list database fell behind

The predictive campaign updates the call list twice per call: 250 updates a second. After six hours the database queue overflowed and the outbound service restarted once. The call-list class was switched to work through the platform's message broker, applied on the fly. The warnings stopped and there were no further restarts.

Fixed under load

Archive queries grew heavy

After a day the call archive held more than 10 million rows, and several parallel aggregate queries from the full supervisor dashboard overloaded it. A lightweight dashboard (current state and last hour) was added, and a patch that queues heavy queries was built and installed during the test. For archives of this size the recommended setup is Kafka with ClickHouse.

Every call accounted for

  • Outbound 29,099,761
  • Inbound 2,599,849
  • Internal 12,762
  • Total 31,712,372
Internal calls were test calls from a control phone and extra legs created when emulators assembled conferences through an IVR script. In the preliminary run the emulators' counters matched the dashboard exactly for inbound (30,000) and outbound (375,233) calls; calls delivered to agents differed by 0.001%, a race between simultaneous time-outs.

Test passed

No limits to scaling found

With CPU at 25–50% and memory at 20–45%, the same seven servers could take twice the load after a minor reshuffle of microservices and stay within 70% CPU and 80% memory. What drives resource use is the number of simultaneous conversations, IVR sessions and calls per second, and the microservice architecture scales all three horizontally.

The run also proved in practice that individual components can be patched under heavy load without interrupting calls in progress.