Fix Common Scalability Issues

There are many different causes of scalability issues, but the most common issues arise from application code, hardware resources, and database limitations.
 

Application Code

Suppose you have an application where users upload images. If the application is running on a single thread, a large image could bring the entire application to a halt. These slow components in the request pipeline put a lower limit on an application’s response time and limit its scalability.

The best solution to these types of problems is moving slow components into asynchronous background jobs. For instance, image upload requests could be sent to a queue as part of a request. The user’s request would be fulfilled as soon as the job was queued (in milliseconds) while a background worker would then handle the actual uploading task.
 

Hardware Resources

Suppose you have a financial application that draws a stock chart with various technical indicators. Each indicator is a complex calculation that must be performed on the fly using time series data. The time it takes to run the complex calculations could slow down the response time and limit the scalability of the application.

The best solution to these types of problems is caching pre-computed values and performing calculations in a separate background job. For instance, you may compute a technical indicator’s historical time-series data up until the current period and cache those values. This eliminates the need to compute the entire time series with each request.
 

Database Limitations

Suppose you have a large database of content with millions of articles and hundreds of authors. If you wanted to query the latest articles per author, you might loop through authors with one SQL query and then execute a second SQL query that grabs the articles for the given author. These types of N+1 queries can serverely impact performance.

The best solution to most database scalability issues is optimizing SQL queries and implementing indexing strategies. By building articles and authors into a single query, you can dramatically reduce the volume of queries you’re running. Database indexes can also make it much more efficient to look up records by date or other indexed criteria.
 

Plan for Application Performance

To build scalable web applications, adgere to best practices and commit to ongoing quality assurance.

Start by profiling your application and identifying scalability issues you need to address. While it may not be possible to address all of these issues immediately (and many may not be mission-critical at the moment), you should make room in each sprint to incrementally address these issues and commit to improving performance over time.

There are many ways to profile an application:

• Browser DevTools: Chrome or FireFox DevTools provide a way to profile your application’s performance. You can identify front-end assets or processes with lengthy load times and compare them with application logs to uncover bottlenecks.
   
• Google PageSpeed Insights: Google’s free PageSpeed Insights tool lets you analyze your web application’s performance and suggests asset-related improvements you can make to reduce page load times.
   
• New Relic: New Relic makes it easy to analyze everything from response times to the performance of external services. You can narrow down performance issues from HTTP requests all the way down to the SQL queries behind them.

The next step is incorporating performance metrics into your development workflow. Rather than running ad hoc performance tests, you should build them into your continuous integration and deployment (CI/CD) cycle to ensure they’re consistently executed every time. Any issues should be immediately addressed in the current sprint before the deployment.

The biggest challenge with load testing is the heavy scripting required and the high level of effort required to maintain those scripts. In addition, most load testing platforms are protocol-based, which means they only test your API. The problem is that browsers may account for a significant portion of load times, especially for single-page applications (SPAs).

LoadNinja Record and Replay Capabilities – Source: LoadNinja

LoadNinja helps solve these issues by taking a browser-based, record-and-replay approach that makes it easy for anyone to record flexible tests that can be easily tied into Jenkins and other platforms via plugins. In addition, these load tests are run on actual cloud-based browser instances so you can dive in and troubleshoot problems.

The Simplicity of Scaling

Scalability is an important and underappreciated aspect of web application development. By adhering to best practices during development and incorporating load tests into your CI/CD processes, you can ensure your application remains scalable and free from bottlenecks that could both degrade the user experience and dramatically increase your costs.

LoadNinja makes it easy to build load tests for both APIs and UIs using a browser-based interface. After building these load tests, you can easily incorporate them into a continuous integration and deployment process to ensure they run before deployment. You can even use innovative troubleshooting tools to quickly resolve bottlenecks.