Software scalability

The more users arrive, the slower the system gets

When the system slows down, software scalability looks like a question of resources, and the first answer is one more server or an urgent fix, which holds until the next peak. Every fix written in a hurry makes the code harder to change, and with no view of production the next one lands wherever the problem seems to be. Meanwhile the structure of the code, with a single path and a database that everything depends on, stays as it was.

Book a call

Does this sound familiar?

  • Response times grow with the number of users, and peaks bring timeouts and errors.
  • Heavy processing and reports slow down everything else while they run.
  • Every urgent performance fix calls for another one a few weeks later.
  • Adding servers helps for a while, then the problem returns.
  • When the system slows down, the data doesn’t say where a request gets held up.

Where do the slowdowns under load come from?

The chain starts with a production environment nobody can see. Fixes are made by intuition, pile up and stiffen the single path that makes everything depend on the same database. These are problems of architecture and visibility, and the place to start is often further back than where the system gives way.

  1. Everything goes down the same path

    User requests, heavy processing and external integrations run through the same code, so the slowest part sets the pace for all the others, and one more server doesn’t change the route. Separating the critical paths from the rest is architectural work: clear boundaries in the code, one step at a time.

  2. One database that everything depends on

    Transactions, reports and nightly jobs use the same database, whose schema has grown by accretion and never been rethought. Every new feature has to reckon with that structure, and it pays to work on how the code uses it before thinking about changing technology.

  3. Slowdowns discovered by users

    Without logs, metrics and traces that follow a request, a slowdown is discovered from user reports and the cause is hunted by intuition. Fixes then land where the problem is suspected to be, and the slowdown returns when the suspicion was wrong. The way in is to set up logs, metrics and traces with the team, so that every later step is aimed at what you can see.

  4. Urgent fixes that pile up

    Every peak brings a fix written in a rush, often without tests, which closes the emergency and makes the code a little harder to change. After a few emergencies the team is afraid to touch the very parts it should improve.

What changes when the team knows where the system gives way

The team sees in production where a request slows down, and notices before the users do. Interventions go where the system is limited at that moment, one at a time, and each is checked with the same measurements that pointed to it.

The question of whether to rewrite or change technology is settled by measuring, one part of the system at a time. People who steer the product can plan a campaign or the arrival of a large customer knowing where to look if the system slows down.

Let’s start with the last time the system gave way

We look with you at what production shows today about the latest slowdown. From there we decide whether to begin with observability, through our DevOps & Continuous Delivery service, or with the structure of the code.

We use your data to respond to your request. Read our Privacy Policy.