Your App Shouldn’t Panic in Rush Hour Traffic – Here’s How to Prepare

For enterprise customers preparing for major events, go-live rollouts, or simply aiming to improve overall application performance, scale testing is an essential process. Whether you’re gearing up for a surge in user activity or testing the resilience of new customizations, scale testing helps ensure your system is prepared to handle increased loads smoothly. 

Let’s walk through the key principles of scale testing, as well as exploring best practices and tips for optimizing your applications.

Why scale testing matters

In a digital-first world, application performance can make or break user experiences. During critical periods — like product launches, promotional events, or seasonal spikes — it’s critical that your applications run efficiently. 

Scale testing simulates high traffic scenarios, pushing your system to its limits to uncover potential performance issues before they affect users. By stress-testing your applications under realistic conditions, you can identify and resolve obstacles, making sure your system performs optimally even during peak usage. 

4 key steps to successful scale testing

Before conducting a scale test, it’s important to have a clear strategy in place. Proper planning not only ensures that you use your test window effectively but also maximizes the insights you gain. Here are the core components you should focus on when planning your test: 

Step 1. Define your goals for scale testing

Start by identifying what you want to achieve through scale testing:

• Clearly articulate your business objectives: What are the specific outcomes you want to achieve with the scale test? Whether you’re preparing for a go-live event or expanding to handle more users, set specific goals for the test.
• Identify critical use cases: Focus on the core functionalities or business processes within your application. These could be high-value transactions, vital user flows, or custom functionality that must perform without fail. Consider using Scale Test’s Test Plan Creation for identifying these critical use cases from production.
• Set measurable success criteria: Define measurable metrics to determine if your application can handle the projected workload. This might include criteria like response time, throughput, and error rates. For example, you might aim to process a certain number of records per hour without exceeding specific error thresholds.

Step 2. Understand concurrency and throughput requirements

Your application’s ability to handle multiple users and transactions simultaneously is important for maintaining performance during high-traffic periods. Here’s how to approach it: 

• Concurrency: Estimate how many users will be using your system at the same time during peak periods. This helps ensure your application is prepared for real-world traffic levels. Consider factors like peak usage times and user behavior patterns.
• Throughput: Measure how many transactions (saves, loads, interactions) your system will need to handle per unit of time. This can be based on historical data or projected peak loads.

Step 3. Set scalability benchmarks

To effectively scale, you need to understand both your current capacity and your future needs.

• Establish a baseline: Assess the current performance of your application under normal load conditions. This baseline helps you understand how much room for improvement there is.
• Set realistic scalability goals: Decide how much your application needs to scale to meet peak demands. This could involve increasing throughput, reducing response times, or improving error rates.

Additionally, consider factors like business growth projections, seasonal variations, or promotional campaigns that may increase traffic. 

Step 4. Evaluate test accuracy during scale testing

Ensuring accuracy in your scale test is important for actionable insights.

• Utilize the Scale Test’s Product Trial Accuracy Feature: This tool compares your test suite’s expected workload with real-world production data.
• Analyze discrepancies: Identify areas where your test might deviate from production behavior, such as differences in transaction patterns, data volumes, or API usage.
• Make necessary adjustments: Modify your test scripts or data sets to ensure accurate representation of production conditions.

Preparing your system for scale testing

Once your goals are clear, it’s time to set the stage for a successful scale test by preparing your integration points to handle the anticipated load. Here’s how: 

Identify key integration touchpoints

Your test environment should mirror real-world conditions as closely as possible. This includes verifying that your servers, databases, and network resources are capable of supporting the load you plan to simulate. 

• Map all integrations: Create a comprehensive list of all external systems or services that your application interacts with. Explore the Test Plan Creation Feature that lists these integrations.
• Prioritize critical integrations: Focus on integrations that are essential for core functionality or that are likely to experience significant load during peak times.

Mock external APIs

To simulate the behavior of external systems during scale testing:

• Create stubbed responses: Craft mock responses that mimic the expected data structures and format with tools like Postman to generate responses that mimic external APIs.
• Validate mock data: Ensure the data returned by these mock responses accurately represents the data that your application would receive from real APIs. 

Ensure infrastructure parity for scale testing

Make sure your testing environment mirrors production infrastructure:

• Verify sandbox environment configuration: Confirm that your sandbox environment for integration services has the necessary resources (e.g., servers, databases, network resources) to handle the expected load. Salesforce’s Scale Test product automatically scales up sandbox environments during test durations.
• Address resource constraints: If your sandbox environment is underpowered, consider scaling up resources or optimizing your application to reduce resource consumption.
• Test integration performance: Run performance tests on your integrations to identify any potential issues or limitations before starting the full scale test.

Running Scale Test and analyzing results with Scale Center 

Once your system and integrations are ready, it’s time to execute your scale test. Salesforce’s Scale Center provides robust tools for analyzing performance data and identifying bottlenecks during the test.

Review key metrics from scale testing

• Review overall test performance: Examine key metrics such as response times, error rates, and resource utilization by navigating to Org Performance Feature of Scale Center.
• Identify performance bottlenecks: Look for areas where the application’s performance degrades significantly under load.
• Analyze error trends: Track the frequency and type of errors that occur during the test.

Generate consolidated reports

• Select a time window: Choose a specific timeframe during the test run for detailed analysis. The preferred time window will be when maximum number of errors have happened or when maximum Request Volume is observed for the test duration.
• Use the Consolidated Report: With Scale Test, these reports offer insights into performance metrics such as Apex execution times, database performance, row lock contention, API callout errors, and integration endpoints and their performance.

Utilize Apex summary and Concurrent Apex report

• Identify resource-intensive Apex code: Pinpoint the Apex methods or triggers that are consuming the most resources.
• Analyze database queries: Examine the SOQL queries executed by your Apex code to identify potential optimization opportunities.
• Optimize database access: Consider techniques like query tuning, batching, and bulkification to improve database performance.

Analyze rowlock errors

• Identify objects involved in row lock contention: Determine the objects that are frequently involved in locking conflicts and identify relationships between contending objects.
• Investigate conflicting transactions: Analyze the transactions that are attempting to acquire locks on the same objects simultaneously and look for any deliberate locks introduced from application using FOR UPDATE.
• Evaluate data pattern for correlation and parameterization: Consider evaluating total records running into row lock contention and identify scripting issues contributing to rowlocks.

Scale testing to create a seamless user experience

By incorporating scale testing into your application development and performance strategy, you can make sure that your applications are ready to handle any traffic. Proper planning, testing, and analysis are keys to maintaining high availability, fast response times, and an overall smooth user experience — even during your busiest times.