Capacity and Scaling

Worker capacity determines how many concurrent SIP endpoints can run on a single worker. Getting capacity right is essential --- under-provision and tests will fail to start, over-provision and you waste resources.

This guide covers everything from understanding what capacity means, through license tiers and resource planning, to scaling from 50 to thousands of concurrent endpoints.

What Capacity Means

Capacity is the maximum number of concurrent SIP endpoints a single worker can handle. Each endpoint represents one SIP registration and one active call, including SIP signaling, RTP media transmission, and metric collection.

When you create a worker in CallMeter, you set its capacity. During test execution, the scheduler allocates endpoints to workers that have available capacity. If a worker has capacity 100 and 65 endpoints are currently active, it can accept 35 more.

Effective Capacity

The actual number of endpoints a worker can handle is the lower of two limits:

Effective Capacity = MIN(Configured Capacity, Licensed Endpoints)

• Configured capacity --- The capacity value you set when creating the worker, based on the host machine's resources
• Licensed endpoints --- The maximum endpoints allowed by your worker license tier

If you set capacity to 200 on a Standard license (50 endpoints), the effective capacity is 50. You can increase the configured capacity, but the license gate limits actual usage.

Worker License Tiers

User-owned workers require a worker license. Each license tier determines the maximum endpoints per worker and the features available.

What Each Tier Includes

Standard ($299/mo, 50 endpoints):

• Full SIP signaling (all transport protocols)
• All audio codecs (PCMA, PCMU, G.722, Opus)
• All video codecs (H.264, VP8)
• Core VoIP quality metrics (jitter, packet loss, RTT, SIP timing, and more)
• SIP message capture and analysis
• Health monitoring and status reporting

Professional ($599/mo, 200 endpoints):

• Everything in Standard
• Extended metrics (60+ VoIP quality indicators)
• Webhook notifications for test events
• API access for programmatic test execution
• Priority support response times

Enterprise ($999/mo, unlimited endpoints):

• Everything in Professional
• No per-worker endpoint limit (limited only by hardware)
• Custom media file formats
• Dedicated support engineer
• Custom integration assistance
• SLA guarantees

Choosing the Right Tier

Resource Requirements

Each concurrent endpoint consumes CPU, memory, and network resources. Use these guidelines to size your Docker host.

Audio-Only Calls

Audio + Video Calls

Video significantly increases resource requirements. H.264 at 720p is the most demanding:

Per-Endpoint Resource Estimates

These are approximate values under normal conditions. Actual usage varies based on codec, bitrate settings, media file complexity, and SIP server behavior.

Multi-Worker Deployment

A single worker has hardware limits. To test beyond those limits, deploy multiple workers and distribute endpoints across them.

Why Multiple Workers

• Scale beyond single-machine limits --- 1,000 endpoints across 4 workers is more practical than 1,000 on one machine
• Geographic distribution --- Place workers in different locations to test from multiple points of presence
• Fault isolation --- If one worker fails, others continue operating
• Incremental growth --- Add workers as testing needs increase

Horizontal Scaling Patterns

Pattern 1: Scale on a single host

Deploy multiple worker containers on one powerful machine:

version: "3.8"
services:
  worker-1:
    image: registry.callmeter.io/worker:latest
    environment:
      WORKER_TOKEN: "${TOKEN_1}"
      CLOUD_URL: "wg.callmeter.io:443"
      WORKER_NAME: "host-a-worker-1"
    ports:
      - "3031:3030"
    deploy:
      resources:
        limits:
          cpus: "4.0"
          memory: 4G

  worker-2:
    image: registry.callmeter.io/worker:latest
    environment:
      WORKER_TOKEN: "${TOKEN_2}"
      CLOUD_URL: "wg.callmeter.io:443"
      WORKER_NAME: "host-a-worker-2"
    ports:
      - "3032:3030"
    deploy:
      resources:
        limits:
          cpus: "4.0"
          memory: 4G

Divide the host's resources between workers. Two workers with 100-endpoint capacity each give you 200 endpoints total.

Pattern 2: Scale across hosts

Deploy one worker per host across multiple machines:

Host A (Frankfurt)    → worker-fra-01 (200 endpoints)
Host B (New York)     → worker-nyc-01 (200 endpoints)
Host C (Singapore)    → worker-sgp-01 (200 endpoints)
                                    Total: 600 endpoints

This pattern provides both scale and geographic distribution. Each worker connects independently to wg.callmeter.io:443.

Pattern 3: Mixed cloud and user-owned

Combine cloud workers for internet-facing tests with user-owned workers for private infrastructure tests. In a single test, different groups can target different workers:

• Group A: 100 endpoints on cloud workers (testing external SIP trunk)
• Group B: 100 endpoints on your worker (testing internal PBX)

Load Distribution Across Workers

When you create a test and select multiple workers, CallMeter distributes endpoints across them based on available capacity:

1. The scheduler examines each selected worker's available capacity (configured capacity minus currently used)
2. Endpoints are allocated proportionally to available capacity
3. If total available capacity across selected workers is insufficient, the test fails to start with a capacity error

You can also target specific workers by selecting them explicitly in the test's group configuration.

Capacity Monitoring

From the CallMeter Dashboard

The Workers page shows real-time capacity information for each worker:

From the Worker Host

Monitor resource utilization to determine if the configured capacity matches actual resource consumption:

# Container resource usage
docker stats callmeter-worker

# Health endpoint
curl -s http://localhost:3030/health | jq .

Capacity Alerts

Watch for these warning signs:

Scaling Example: From 50 to 1,000 Endpoints

Here is a concrete example of scaling a CallMeter deployment for a growing testing program.

Phase 1: Getting Started (50 endpoints)

Setup: 1 worker, Standard license ($299/mo) Hardware: 2 CPU cores, 1 GB RAM, 25 Mbps network Use case: Basic SIP registration testing, audio quality validation

# Single worker, modest capacity
services:
  callmeter-worker:
    image: registry.callmeter.io/worker:latest
    environment:
      WORKER_TOKEN: "${WORKER_TOKEN}"
      CLOUD_URL: "wg.callmeter.io:443"
      WORKER_NAME: "lab-worker"
    deploy:
      resources:
        limits:
          cpus: "2.0"
          memory: 1G

Monthly cost: $299 (1 Standard license)

Phase 2: Regular Load Testing (200 endpoints)

Setup: 1 worker, Professional license ($599/mo) Hardware: 4 CPU cores, 4 GB RAM, 50 Mbps network Use case: Weekly load tests, CI/CD integration, webhook alerts

services:
  callmeter-worker:
    image: registry.callmeter.io/worker:latest
    environment:
      WORKER_TOKEN: "${WORKER_TOKEN}"
      CLOUD_URL: "wg.callmeter.io:443"
      WORKER_NAME: "loadtest-worker"
    deploy:
      resources:
        limits:
          cpus: "4.0"
          memory: 4G

Monthly cost: $599 (1 Professional license)

Phase 3: Multi-Site Testing (500 endpoints)

Setup: 3 workers across locations, mix of Professional and Enterprise Hardware: Varies by location

Monthly cost: $999 + $599 + $299 = $1,897

Phase 4: Enterprise Scale (1,000 endpoints)

Setup: 5 Enterprise workers, centralized management Hardware: Dedicated servers or cloud VMs

Monthly cost: 5 x $999 = $4,995

Capacity Planning Best Practices

1. Start conservative --- Set capacity lower than theoretical maximum and increase based on observed resource usage during actual tests.

2. Account for video --- A single video endpoint uses 10x the resources of an audio-only endpoint. If your test plan includes video, reduce the endpoint count accordingly.

3. Leave headroom --- Do not configure capacity at 100% of hardware capability. Leave 20-30% headroom for operating system overhead, metric processing, and burst handling.

4. Monitor before scaling --- Before adding workers, check if existing workers are actually resource-constrained. If CPU and memory are well below limits, you may be able to increase capacity on existing workers.

5. Use dedicated hardware for stress tests --- Shared VMs or containers competing for resources produce inconsistent results. For reliable stress testing, use dedicated hosts.

6. Plan for peak usage --- Size for your maximum concurrent test load, not average. If you run weekly 500-endpoint stress tests but daily 50-endpoint validation tests, size for 500.

7. Test your capacity --- Run a calibration test at maximum capacity and monitor host resources. If the system is stressed, reduce capacity or upgrade hardware before running production tests.

Next Steps

• Deploying Your Own Workers --- Docker deployment guide
• Configuration --- Resource limits and performance tuning options
• Networking --- Bandwidth requirements by endpoint count
• Plans and Pricing --- Plan tiers and included cloud capacity