A scalability evidence schedule is the controlled record behind one buyer-facing capacity claim. It fixes the requested workload, useful unit of work, demand shape, data profile, service boundary, tested release, environment relationship, load steps, success criteria, measured results, limiting condition, safe operating envelope, overload behavior, scale response, monitoring signal, expansion trigger, lead time, evidence location and approval. Each result is labelled as observed, derived, modelled, proposed, dependent on the buyer or still unknown. The schedule supports a proposal answer without publishing confidential topology, security-sensitive thresholds or operational access details.

The fictional Northmere Examinations Agency asks whether a candidate service can support 120,000 concurrent users and four million submissions during results week. The draft response says that its cloud-native architecture scales automatically without limit. No one has defined whether a submission means opening a results page, filing an appeal, uploading evidence or completing a payment. The last performance test used a smaller data set, short text requests and no document scanning. Its graph shows average response time, stops before saturation and counts retried requests as throughput. The architecture may be sound, but the sentence gives the evaluator no inspectable reason to believe the promised workload is deliverable.

Begin with demand, not infrastructure. Convert the buyer statement into business operations, arrival rates, concurrency, payload and data distributions, geographic conditions, background work and dependency behavior. Test the exact offered release in a representative environment, or state the remaining differences. Report useful completions, latency distributions, errors, correctness and resource pressure together. Find the point where service behavior bends, not merely the largest load that produced a screenshot. Then give the evaluator a bounded operating envelope, the evidence date, the conditions that sustain it and the approved route for demand beyond it.

Turn the buyer number into work the service must finish

Copy the scalability question and every number attached to it. Then find the definitions, service scope, transaction descriptions, forecast periods and performance criteria elsewhere in the procurement pack. Northmere uses 120,000 concurrent users as a headline, but the useful question is what those candidates do at the same time. Viewing a cached result, submitting an appeal with documents and paying a fee place different demands on the service. A single virtual-user count cannot represent all three.

Build a workload from completed business operations. Give each operation a start and successful end, its share of demand, expected arrival rate, active concurrency, think time, payload range, data access pattern and dependency calls. Add background work such as virus scanning, document conversion, notifications, reconciliation and reporting. Keep registered accounts, logged-in sessions, open connections, requests and successful outcomes as separate units. The relationship between them depends on user behavior and system design.

Demand also has a shape. Results publication may create a steep opening burst, while appeals arrive over several hours and attachments continue processing after the browser confirms receipt. State the ramp, peak duration, geographic distribution and expected growth horizon. If the buyer has supplied only a user count, mark the missing arrival and operation mix as buyer facts to clarify or approved sizing assumptions. Do not hide them inside a test script.

Northmere workload record before performance testing
Workload fieldRecorded basisEffect on the test
Candidate result viewBuyer forecast for the first publication hourHigh read arrival rate with realistic identity and cache state
Appeal submissionCompleted form plus zero to eight evidence filesWrite, validation, storage and asynchronous scanning work
Payment confirmationOnly appeal types for which the buyer requires a feeExternal call, callback and reconciliation path
Peak profileFast ramp after release followed by a lower sustained periodSpike and endurance stages rather than one flat load

Keep a measured result separate from a forecast or design claim

A proposal usually draws on several kinds of capacity information. A completed test is an observation about one release, environment, workload and time. A calculation derives another value from stated inputs. A forecast estimates later demand. A design statement explains how capacity can change. A supplier quota or buyer interface may condition the result. Give each statement a state before using it. A measured 18,000-session run cannot become proof of 120,000 sessions merely because the architecture allows more instances.

Derived evidence can still be useful when its relationship is honest. If a component was tested separately, show which complete service path it represents and what remains untested. If a smaller environment is used, document the dimensions that scale proportionally and those that do not. Stateful data, shared queues, rate limits, coordination work and fixed dependencies often break a simple multiplication. A model should expose those terms and a validation point rather than turn them into an exact-looking total.

ISO/IEC 25030 provides a framework for defining and governing quality requirements, including their use in a call for tender. ISO/IEC 25040 provides an evaluation framework but does not prescribe one test method. That distinction matters here. A standard can support the structure of the evidence, yet it does not certify Northmere capacity or choose the buyer target. The current product and test records must do that work.

Capacity statements and what they permit
StateRequired recordBuyer-facing use
ObservedRelease, workload, environment, result, date and retained evidenceReport the measured envelope with its conditions
DerivedInputs, formula, proportionality limits and validation statusExplain the bounded inference, not a measured maximum
Modelled or forecastDemand source, uncertainty range, scenarios and decision dateDescribe a planning basis with explicit verification
Proposed expansionApproved action, lead time, dependencies, price and acceptance testCommit only within the authorized offer

Describe test equivalence without publishing the system map

Freeze the software release, enabled functions, data model, dependency versions and configuration class before the run. Record how the test environment relates to the offered service in capacity, network path, regional placement, storage state and scaling policy. The buyer does not need hostnames, addresses, administrative endpoints or a component-by-component resource inventory. It does need to know whether the evidence came from the offered product and whether any difference could change the result.

Test data must exercise the same work. Use representative account relationships, authorization checks, search cardinality, document counts, file-size distribution, validation failures and historical records. Preserve privacy by using approved synthetic or de-identified data and by testing the properties that affect performance rather than copying a customer database. Warm caches and empty stores can both be valid scenarios, but neither should be passed off as the only production state.

Check the load generator separately. Confirm that it can produce the planned arrival curve without exhausting its own processors, network or connection pools. Synchronised test clients can also create an artificial burst unlike the buyer pattern. Retain client-side timings, service-side observations and completed business counts. Disagreement between them is evidence to investigate, not a reason to publish the faster graph.

  • Name the release and offered functions under test.
  • Record material environment similarities and differences.
  • Use representative data shape, volume, permissions and state.
  • Include external calls and background work that affect completion.
  • Prove that the test client can generate and observe the intended load.
  • Remove credentials, addresses, defensive thresholds and exploitable topology from the release copy.

Count finished work and show what happened to the slow requests

Throughput should count the useful outcome named in the workload model. Ten thousand accepted upload requests are not ten thousand stored, scanned and retrievable appeal files. Define completion and verify it with a downstream record. Separate success, business rejection, technical failure, timeout, abandonment, retry and duplicate. If a client retries after a slow response, raw request rate rises while useful throughput may remain flat or fall.

Report a distribution rather than one average. At each load step, retain at least the chosen median and tail percentiles for every critical operation, together with errors and correctness failures. Averages can improve when the service rejects difficult work early. A percentile can also look healthy if failed operations disappear from the timing population. State the eligible population for each measure and reconcile submitted, accepted, completed and failed totals.

Observe queues and constrained resources alongside user results. Queue depth alone is incomplete, because a stable count can hide increasingly old work. Track oldest-item age, processing delay and drain time. Record resource pressure at a safe level of abstraction, such as compute, memory, connection, storage, external quota or serialized work. OpenTelemetry defines a stable HTTP server request-duration metric; its active-request metric is opt-in and still marked Development. Both describe protocol activity. The proposal still needs business completion measures for the buyer journey.

Stop calling the last green point a maximum

Increase load in controlled steps and hold each step long enough to reach the relevant state. Plot demand, useful completions, latency, errors, queue age and resource pressure on the same timeline. The important point is often the knee where additional demand produces less useful throughput, longer tails or accumulating work. If the test ends while every curve remains stable, it has shown a tested lower bound, not a maximum capacity.

Define the offered operating envelope below the observed instability. The margin should account for forecast uncertainty, failover or maintenance states, noisy dependencies, uneven partitioning, scaling delay and normal change. It is a decision supported by evidence, not a universal percentage. Record the first limiting condition and whether it belongs to the service, a supplier, the buyer, the test harness or an unresolved interaction.

Go beyond the intended range under controlled conditions. Observe whether the service queues, rejects, slows, drops optional work or corrupts state. Verify retry treatment and recovery after demand falls. Google SRE guidance recommends testing capacity limits and overload behavior because resource exhaustion can create cascading failure. That is useful engineering guidance, not proof of a particular product. Northmere evidence must show what this offered service did.

Illustrative Northmere test interpretation
StageObserved relationshipPermitted conclusion
Expected mixUseful completions track demand and tail latency remains within the test criterionStable for this release, workload and environment
Peak holdCapacity action completes and queues return to their earlier age bandExpansion path observed under the stated conditions
Step above peakUpload queue age grows before request errors riseAsynchronous processing is the first observed limit
RecoveryAccepted work drains without duplicates and result reads remain correctRecovery behavior is evidenced for this overload episode

Measure the delay between a scale trigger and useful capacity

Automatic scaling is a sequence, not a binary feature. Record the signal, observation window, decision rule, requested change, provisioning delay, readiness condition, traffic distribution and point at which useful throughput increases. A new worker that is running but still loading state or receiving no work has not added usable capacity. Measure scale-in as well, because an aggressive return can recreate pressure or interrupt queued work.

Test the fixed parts. Shared stores, ordered queues, external APIs, licenses, regional quotas and buyer networks may limit the service after stateless processing expands. State movement and rebalancing can consume capacity during the change. The Azure scale-out guidance describes scalability as throughput gain relative to added resources and warns that bottlenecks and synchronization limit proportional growth. Use that relationship as one bounded method, not as a claim that every layer doubles.

Give demand beyond the current envelope an owned route. The route might require a tested configuration change, quota increase, additional region, data partition, supplier agreement or planned engineering work. Name the trigger, evidence, lead time, cost treatment, acceptance test and decision owner. If the action is only on a roadmap, label it proposed and keep it out of the current-capacity claim.

Preserve enough context to repeat the result after a change

Retain the test plan, workload version, data recipe, environment record, release identifier, start and end times, load-controller logs, service observations, result calculations, incidents and deviations. Record the number of repetitions and variation between them. IETF RFC 8239 is limited to data-centre network benchmarking, but its insistence on reported iterations and repeatability is a useful bounded example. Do not apply its network-specific thresholds as a universal application rule.

Link every claim to the exact evidence snapshot and calculation. Another reviewer should be able to reproduce the published number from retained result rows, including the population of failures. Keep excluded intervals and test defects visible. If a client fault invalidates one stage, rerun that stage or report the limitation. Selecting the best run without a predefined rule turns normal variation into unsupported confidence.

Set expiry triggers. Reopen the schedule after a material release, data-model change, altered workload, infrastructure-class change, dependency revision, quota change, scaling-policy change or monitoring gap. Recheck it when the buyer supplies a different peak or operation mix. A dated test can remain relevant, but relevance must be decided against the current offer rather than inferred from a familiar product name.

Give the evaluator the envelope, evidence and next capacity action

Answer the requirement directly. Name the workload basis, tested release, representative boundary, useful outcome measures and observed envelope. State the test date or evidence period. Explain how capacity responds inside that range, how the service behaves under excess demand and which monitoring signal starts an expansion decision. Put material assumptions and buyer dependencies in the location required by the tender.

A bounded Northmere answer could say that the offered release was tested against the stated mix of result views, appeal submissions and evidence processing, using a representative data population and dependency stubs or live test services as identified. It would report the sustained useful completion range, selected tail-latency and error criteria, observed scale-response time and recovery result. It would then describe the approved path for the buyer forecast that remains outside direct evidence. It would not claim unlimited scale.

Reconcile the wording with the service-level schedule, price, monitoring, support and security disclosure. A test result does not authorize a contractual target or remedy. A service-level target does not prove capacity. Technical reviewers confirm the method and result; the service owner accepts the operating conditions; security controls the detail released; finance and commercial owners confirm cost; the relevant delegate approves the exact offer. Any missing authority remains visible rather than being replaced by confident prose.

Release decision for a scalability statement
Claim elementRequired authorityRelease condition
Workload and resultPerformance owner and product ownerTraceable test record with material differences stated
Operational envelopeService ownerHeadroom, monitoring, degradation and recovery accepted
Expansion pathEngineering, supplier and commercial ownersAction, lead time, cost and verification are authorized
Buyer-facing wordingProposal release delegateExact statement matches evidence, price and contract position

Useful outcomes from answer RFP scalability question

  • The buyer workload is expressed as dated operations, arrival patterns, concurrency, payloads, data state and external dependencies rather than one unexplained user count.
  • The measured boundary identifies which user journeys, interfaces, background tasks and third-party calls were included or excluded.
  • Test evidence names the offered release, configuration class, environment relationship, data preparation, duration, repetitions and monitoring method.
  • Useful throughput excludes failed, duplicate, abandoned and retried work unless the measure expressly includes it.
  • Latency percentiles, error classes, correctness checks, queue age and resource pressure are interpreted together at each load step.
  • The result identifies a stable operating region, the first limiting condition and observed behavior above the intended range.
  • Scale-up or scale-out claims include trigger, response delay, quota, state, dependency and cost conditions.
  • The public answer gives enough method and result detail for evaluation while withholding exploitable system information.
  • Every released statement has current technical, service, security, commercial and contractual authority.

How to run the work

  1. 01

    Freeze the buyer question and decision event

    Record the exact wording, definitions, lot, scored use, target date, proposed service, response field, contract references and controlling versions.

  2. 02

    Translate demand into operations

    Define user journeys, arrival rates, concurrency, payload and data distributions, geography, background jobs, retries and external calls.

  3. 03

    Fix the tested boundary

    Name the release, configuration class, interfaces, dependent services, test environment relationship, data state and material differences from the offer.

  4. 04

    Set acceptance and stop conditions

    Choose useful completion, percentile latency, correctness, error, queue, saturation and recovery limits before running the test.

  5. 05

    Run stepped and time-shaped load

    Measure warm baseline, expected load, peak, spike, sustained demand and controlled overload with repeated observations.

  6. 06

    Locate the safe envelope

    Identify the first bending point, bottleneck evidence, degradation mode, rejected work, recovery and the margin below the observed limit.

  7. 07

    Prove the expansion path

    Test the scaling action, trigger, lag, state movement, quotas, supplier dependencies, cost effect and return to normal capacity.

  8. 08

    Approve and release bounded wording

    Reconcile the schedule with service levels, security, price and delivery, then publish only the authorized claim and its material conditions.

Questions that change the decision

  • What exact business operation does the buyer expect the service to complete?
  • Does the stated user number mean registered accounts, active sessions, simultaneous requests or completed transactions?
  • What arrival pattern, peak duration, growth period and burst shape drive the demand?
  • Which payload sizes, file types, data volumes, search cardinalities and state transitions are representative?
  • Which geographic paths, network conditions, identity providers, payment services and scanning services sit inside the test?
  • How closely do the tested release, configuration and environment match the offered service?
  • Which successful business outcome counts toward throughput, and how are retries or duplicates removed?
  • Which latency percentile, error class, correctness check and queue threshold determine acceptable behavior?
  • Where does performance first stop scaling proportionally, and what evidence identifies the limiting condition?
  • What happens to accepted, queued and rejected work above the intended envelope?
  • How long does added capacity take to become useful, and which quotas or stateful components constrain it?
  • Which details can be released to the evaluator, and who can authorize the resulting promise?

Where teams lose control

01

Registered-user capacity is quoted as evidence for simultaneous active work.

02

Raw request rate counts retries, polling and failed calls as delivered business throughput.

03

An average hides slow or failed work at the tail of the distribution.

04

A small or uniform data set avoids indexing, storage, validation or caching behavior present in the buyer case.

05

The test client cannot generate the intended demand and is mistaken for a service bottleneck.

06

A short peak test misses queue growth, memory pressure, storage accumulation or delayed background processing.

07

Automatic scaling starts only after users have already crossed the response-time limit.

08

A third-party quota or buyer-controlled interface becomes the first limit but remains outside the answer.

09

The largest completed load is called maximum capacity although the test stopped before a limit appeared.

10

A sensitive component map, threshold or defensive control is disclosed to make the answer sound technical.

11

A test on an older release remains in the library after a material code, data or supplier change.

Measure the finished job

Measure the completed workflow, including review effort and exceptions. Output volume on its own is not evidence of a better process.

  • buyer workload dimensions supported by a cited requirement or approved assumption
  • test scenarios with a reproducible operation mix, data profile and arrival curve
  • useful completions per interval after failed, duplicate and retried work is separated
  • p50, p95 and p99 completion time by business operation and load step
  • correctness failures, timeouts, rejections and dependency errors at each stage
  • queue depth and oldest-item age during ramp, peak and recovery
  • load-to-throughput gain and resource-to-throughput gain across scale steps
  • time from expansion trigger to usable capacity and return to the stable region
  • proposal claims linked to a current test record and named authority
  • unsupported unlimited-scale statements in released content; target zero

Common questions

Does a concurrent-user test prove scalability?

Only for the operation mix, arrival pattern, data, release, environment, duration and acceptance rules represented by the test. Registered users and active concurrency are different quantities.

Can throughput be reported as requests per second?

It can be one technical measure, but the proposal should also count the completed buyer outcome. Separate failed, retried, duplicate and abandoned requests so traffic is not mistaken for useful work.

Which latency percentile should an RFP answer use?

Use the percentile and population required by the buyer or approved for the offered outcome. Report enough of the distribution to expose tail behavior, and always pair it with errors and exclusions.

Must a bidder disclose the complete production architecture?

Check the tender instructions and the approved disclosure route. Explain the tested boundary, material equivalence, scale method and evidence at the required level. Resolve any conflict with security restrictions through clarification or controlled disclosure before releasing sensitive details.

Does autoscaling mean the service has no capacity limit?

No. Scaling has detection and provisioning delay, quotas, fixed dependencies, state movement, cost and a tested range. Report the observed response and remaining limit.

What if the test environment is smaller than production?

Record every material difference, justify any proportional relationship, expose fixed or stateful limits and validate the model at an agreed gate. Do not multiply a result without evidence.

How old can scalability evidence be?

Age alone does not decide relevance. Reassess after changes to the release, data, workload, environment class, dependencies, quotas, scaling policy or monitoring, and state the evidence date.

Is a scalability result also an SLA commitment?

No. A test supports feasibility under stated conditions. A contractual level requires its own approved boundary, target, measurement, remedy, price and authority.

Primary references

Tony Kim

Tony Kim

Founder and CEO

Tony writes about applied AI, dependable product engineering and the systems that turn complex response work into controlled delivery.

Proposal software for source-grounded RFP, RFI, DDQ and questionnaire response work.

Bid, proposal, presales, security and compliance teams. Start with the workflow, constraints and evidence you already have.