Low performance is the #1 issue our Development Consulting Team faces when analyzing enterprise application bottlenecks. It causes constant failures, complicates vital processes, and blocks the full functioning of an application, making it inaccessible to a large base of end-users.

After using different approaches to solving this problem and analyzing their efficiency, we at Techstack have become convinced that increasing the performance of enterprise applications, in most cases, is carried out by implementing high-level solutions, such as rebuilding the application architecture using the CQRS pattern.

In this article, we explore the CQRS pattern: why it is most suitable for solving enterprise performance problems, what additional benefits it brings, and when it should not be used.

Why are Enterprise Applications Facing Performance Issues?

Before we dive deeper into the CQRS pattern, let's take a few steps back to focus on the main reasons why enterprise applications have performance issues.

Here are the 3 main ones:

1 - Low scalability.
Enterprises are mostly huge systems with a variety of functions, but a lack of scalability. Any system changes are difficult to implement, and the consequences of these changes may negatively affect the performance of an application.

2 - Product growth.
Enterprises can start as startups or MVPs - with basic functionality and simplified application architecture. Growing into a large product, an app typically faces performance problems: the underlying architecture does not cover the growing system requirements, causing errors and delays.

3 - Tight data connectivity.
A large number of enterprise applications, such as CRM systems, marketing platforms, or banking apps, are created to collect data and make reports for users. If they are built with high data connectivity, the increase in updates and requests from users will invariably reduce the system performance.

As usual, low performance is caused by several reasons simultaneously, and in such cases, situational decisions (database optimization, caching, etc.) only fix the problem pointwise but don’t bring desired outcomes in prospects.

To solve the challenge comprehensively and avoid performance issues in the future, re-architecture of applications is needed. The CQRS pattern may be exactly the solution to achieve this goal.

The CQRS Pattern: Why is it Good for Addressing Performance Challenges

CQRS (Command Query Responsibility Segregation) is a pattern where read and write operations are divided into 2 models with different life cycles - Command and Query:

  • Command is the system update model, or Write model. For an end-user, it can be a request "Book a hotel room" or “Pay the bill on the details";
  • Query is a Read model. After receiving a request from the user, the system displays the data on the screen.

The general principle of the CQRS pattern is demonstrated by the infographic below:

CQRS pattern

Under the hood, the CQRS pattern works as follows:

  • the user forms a command (for example, request "Book room No. 123 in the hotel");
  • the system processes the command and updates the Write database;
  • update Write model initiates Read database update. Now in the Read database, all the data of the hotel is displayed taking into account the booked room No. 123;
  • the user receives a response from the system “Room booked” (Command finished);
  • by requesting information about the number of free rooms (Query model), the user receives data taking into account the booked room.

Due to the fact that the Command (Write model) and Query (Read model) models are separated, we can optimize each model for the specific functions.

If an enterprise application has thousands of users and millions of requests, CQRS can optimize the Read model to minimize the execution time of a request to obtain this data. For the user, this means the fastest possible response to a request for any information.

Advantages and Disadvantages of the CQRS Pattern

In addition to improving system performance, the CQRS pattern brings advanced benefits to both the end-user and the business.

Still, the implementation of CQRS may be complicated, and the pitfalls that the engineering team may face will make this solution less attractive to use.

Let's take a look at the pros and cons of CQRS:

Pros and cons of CQRS

When CQRS is not Suitable

As with any approach, the CQRS pattern is not universal.

By addressing the performance issue of growing software products and adding scalability to complex applications, CQRS may not be suitable for apps with simple logic and data models.

Still, the main condition under which CQRS should not be used is if the system is updated more often than users request these updates.

By introducing CQRS, we simplify the reading of data to bring it to users as quickly as possible.

Although we complicate the writing, if the system updates are much larger than reads, CQRS will only reduce performance.

The task of the engineering team here is to check the Command / Query ratio and determine whether this ratio is necessary and stable enough to implement CQRS.


Re-architecture of an enterprise application using the CQRS pattern not only solves performance challenges and eliminates them in the long term, but also adds flexibility and scalability to the application, as well as reduces the cost of server services and infrastructure maintenance.

However, the complexity of implementing and maintaining CQRS can become obstacles to achieving these benefits, or even create additional issues in application processes.

Having a highly skilled engineering team with a deep understanding of the CQRS principles and experience in its implementation, you can be confident that it will bring the necessary results and add value to the enterprise application.