Enhancing Symfony Response Time with Effective Database Indexing - LoadForge Guides

Introduction

Performance optimization is a critical aspect of web development, particularly when it comes to building responsive and efficient applications with Symfony, a popular PHP framework. A well-optimized application not only provides a better user experience but also ensures scalable, maintainable, and robust performance even under high load conditions. Neglecting performance can lead to slow response times, increased server costs, and can ultimately drive users away.

One of the most impactful areas for performance enhancement in Symfony applications is the database layer. As applications grow in complexity, the amount of data stored and accessed can significantly affect response times. This is where database indexing comes into play. Database indexing is a technique used to speed up the retrieval of rows from a database table. By optimizing the way data is stored and accessed, indexing can drastically reduce the time it takes to execute queries, leading to faster application performance.

In this guide, we will delve into the intricacies of database indexing and its importance for Symfony applications. We will explore the concepts behind indexing, identify opportunities for applying indexes within your Symfony application, and provide step-by-step instructions on how to implement and validate these indexes effectively.

Topics we will cover include:

Understanding Database Indexing: Learn what database indexing is, how it operates, and the different types available to you.
Identifying Indexing Opportunities in Symfony Applications: Discover how to pinpoint areas in your application that could benefit from indexing using tools like the Symfony profiler and database slow query logs.
Implementing Indexes in Your Database: Follow a detailed guide to add indexes to your database tables using both raw SQL and Doctrine ORM annotations.
Validating and Testing Index Performance: Use the Symfony profiler, slow query logs, and database explain plans to measure the effectiveness of your indexes, with additional load testing using LoadForge for comprehensive performance analysis.
Common Pitfalls and Best Practices: Learn about common mistakes to avoid as well as best practices to ensure your indexes are providing the maximum performance benefit.
Continuous Monitoring and Optimization: Understand the importance of ongoing performance monitoring and optimization to keep your application running smoothly as it evolves.

By the end of this guide, you will have a solid understanding of how to leverage database indexing to improve your Symfony application's response time. Regularly applying these optimization techniques will not only enhance your application's performance but also ensure a seamless and efficient experience for your users.

Let’s get started on the journey to a faster and more responsive Symfony application!


## Understanding Database Indexing

Database indexing is a powerful technique to enhance the performance of your database queries. It plays a crucial role in improving the response time of Symfony applications by allowing the database management system (DBMS) to retrieve data more efficiently. In this section, we will explore what database indexing is, how it works, and the types of indexes available. This foundational knowledge will pave the way for identifying indexing opportunities and implementing effective indexing strategies.

### What is Database Indexing?

At its core, a database index is a data structure that improves the speed of data retrieval operations on a database table. An index works similarly to an index in a book, allowing you to find the required information quickly without scanning the entire content.

When a query is executed, the DBMS can use indexes to find rows more efficiently than it would by performing a full table scan. By creating an index on one or more columns of a table, you provide the DBMS with a faster way to locate and access rows.

### How Does Database Indexing Work?

Indexes work by creating an internal data structure (typically a B-tree or a hash table) that maintains references to the rows in the table. When a query is run, the DBMS searches the index for the key values specified in the query and uses these references to directly access the rows. This process significantly reduces the number of disk I/O operations and speeds up query execution.

Here's a simplified example: consider a table `users` with columns `id`, `username`, and `email`. Without an index, a query to find a user by `username` would require scanning each row in the table. However, with an index on the `username` column, the DBMS can directly jump to the rows matching the search criteria.

### Types of Indexes

Understanding the different types of indexes available is key to choosing the right one for your specific use case. Here are some common types of indexes:

- **Primary Index**: A primary index is automatically created by the DBMS when a primary key is defined. It ensures that each row is uniquely identifiable.
- **Unique Index**: Similar to a primary index, a unique index ensures that all values in the indexed column(s) are unique. However, it can be created on columns other than the primary key.
- **Composite Index**: Also known as a multi-column index, this type indexes multiple columns together. It is useful for queries that filter by more than one column.
- **Full-Text Index**: Optimized for text-search queries, a full-text index facilitates efficient searching within large text fields.
- **Spatial Index**: Used for spatial data types, this index type is specifically designed for geometric queries.

### Example: Creating Indexes in SQL

To illustrate, let's see how to create indexes in SQL. Suppose we have a table `orders`:

```sql
CREATE TABLE orders (
    id INT PRIMARY KEY,
    order_number VARCHAR(255),
    customer_id INT,
    order_date DATE
);

Here are a few examples of creating different types of indexes:

Creating a simple index on order_number:

CREATE INDEX idx_order_number ON orders (order_number);

Creating a unique index on customer_id and order_date:

CREATE UNIQUE INDEX idx_unique_customer_order ON orders (customer_id, order_date);

Creating a composite index on customer_id and order_date:

CREATE INDEX idx_customer_order_date ON orders (customer_id, order_date);

Example: Creating Indexes in Doctrine ORM

If you're using Doctrine ORM in your Symfony application, you can define indexes via annotations in your entity classes. Here's an example for the orders table:

/**
 * @Entity
 * @Table(name="orders", indexes={
 *     @Index(name="idx_order_number", columns={"order_number"}),
 *     @Index(name="idx_customer_order_date", columns={"customer_id", "order_date"})
 * })
 */
class Order
{
    // Entity properties and methods
}

Importance of Indexing for Performance

Proper indexing can dramatically improve query performance, especially for large datasets. By reducing the amount of data the DBMS needs to sift through, indexes enable faster data retrieval and, consequently, faster response times for your Symfony application.

However, it's essential to strike the right balance—while indexes speed up read operations, they may slow down write operations (INSERT, UPDATE, DELETE) as the DBMS needs to maintain the index. This makes it crucial to index only the columns on which queries are run frequently.

With a solid understanding of database indexing, you're now equipped to identify indexing opportunities and implement effective indexing strategies in your Symfony applications. Up next, we'll delve into identifying indexing opportunities to harness these benefits.

Identifying Indexing Opportunities in Symfony Applications

Optimizing the performance of your Symfony application often begins by identifying where database indexing can yield the most significant benefits. In this section, we'll explore how to find these opportunities through performance analysis techniques and tools.

Analyzing Query Performance

To begin with, you must determine which queries are potential candidates for indexing. Here are steps to guide you:

Enable the Symfony Profiler: The Symfony Profiler is an invaluable tool for capturing detailed information about each request, including database queries. Ensure that the profiler is enabled in your development environment.
```
# config/packages/dev/web_profiler.yaml
web_profiler:
    toolbar: true
    intercept_redirects: false
```
Review Profiler Queries: Navigate to any page in your application and open the Symfony Profiler by clicking on the debug toolbar at the bottom of the page. Under the "DB" section, you can view executed queries, their execution times, and how often they are run.
Identify Slow Queries: Look for queries that take a significant amount of time to execute or are executed frequently. These queries are prime candidates for optimization through indexing.

Using Database Slow Query Logs

Most relational database systems support logging slow queries, which can be instrumental in identifying indexing opportunities:

MySQL: Enable the slow query log in your MySQL configuration file.
```
# /etc/my.cnf
[mysqld]
slow_query_log = 1
slow_query_log_file = /var/log/mysql/mysql-slow.log
long_query_time = 2
```
This configuration logs queries that take longer than 2 seconds to execute.
PostgreSQL: Adjust postgresql.conf settings similarly:
```
# /etc/postgresql/12/main/postgresql.conf
logging_collector = on
log_min_duration_statement = '2s'
log_directory = 'pg_log'
```
PostgreSQL will log all queries exceeding 2 seconds to the pg_log directory.

Tools for Query Analysis

EXPLAIN Command: Use the EXPLAIN SQL command to analyze how the database executes a query. This can show if a query is using indexes and which indexes are being utilized.
```
EXPLAIN SELECT * FROM users WHERE email = 'example@example.com';
```
This will produce output that details the steps the database takes to execute the query and whether it utilizes an index.

Doctrine SQL Logger: Symfony uses Doctrine ORM, which can log SQL queries for further analysis.

// config/services.yaml
services:
    doctrine.dbal.logger:
        class: Doctrine\DBAL\Logging\EchoSQLLogger

// Use the logger in your services
doctrine:
    dbal:
        connections:
            default:
                logging: true

Performance Panels: Utilize monitoring and logging tools like New Relic, Blackfire, or Tideways for deeper insight into database query performance and bottlenecks. These tools can provide a graphical representation of query performance stats.

Identifying Indexing Opportunities

When evaluating queries for potential indexing, consider the following criteria:

Columns in WHERE Clauses: Look at the columns used in WHERE clauses for filters. Creating indexes on these columns can dramatically improve query performance.
Join Conditions: Columns used in JOIN operations are also good candidates for indexing. Foreign keys often benefit from indexing to speed up join operations.
Order By and Group By: Index columns that are frequently used in ORDER BY or GROUP BY clauses.

By thoroughly analyzing query performance through Symfony Profiler, slow query logs, and tools like EXPLAIN, you can pinpoint exactly which parts of your database schema will benefit most from indexing, thereby improving your Symfony application's response times.

Implementing Indexes in Your Database

Implementing indexes in your database can dramatically improve the response times of your Symfony application. In this section, we will walk you through the process of adding indexes to your database tables. We will cover both raw SQL commands and how to utilize Doctrine ORM annotations to optimize queries in Symfony applications.

Step-by-Step Guide to Adding Indexes

1. Adding Indexes Using SQL Commands

Start by identifying the tables and columns that require indexing based on your query performance analysis. Here are common SQL commands to create indexes:

-- Creating a simple index
CREATE INDEX idx_user_email ON user (email);

-- Creating a unique index
CREATE UNIQUE INDEX idx_unique_username ON user (username);

-- Composite indexes (multi-column indexes)
CREATE INDEX idx_user_name_dob ON user (last_name, first_name, date_of_birth);

In the above examples:

idx_user_email: Creates an index on the email column of the user table.
idx_unique_username: Creates a unique index on the username column to ensure all entries are unique.
idx_user_name_dob: Creates a composite index on last_name, first_name, and date_of_birth which can greatly improve search performance on queries involving these columns.

2. Adding Indexes Using Doctrine ORM Annotations in Symfony

Doctrine ORM, the default ORM for Symfony applications, offers a way to define indexes directly within your entity classes. This allows for seamless integration of indexing with your database schema. Here’s how you can do it:

First, open your entity class file where you want to add the index. For instance, if you have a User entity, you might have a file named User.php.

Example With Doctrine Annotations:

<?php

namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity(repositoryClass="App\Repository\UserRepository")
 * @ORM\Table(name="user", indexes={
 *     @ORM\Index(name="idx_user_email", columns={"email"}),
 *     @ORM\Index(name="idx_user_name_dob", columns={"last_name", "first_name", "date_of_birth"})
 * })
 */
class User
{
    // Entity properties

    /**
     * @ORM\Column(type="string", length=180, unique=true)
     */
    private $username;

    /**
     * @ORM\Column(type="string", length=255)
     */
    private $email;

    /**
     * @ORM\Column(type="string", length=50)
     */
    private $first_name;

    /**
     * @ORM\Column(type="string", length=50)
     */
    private $last_name;

    /**
     * @ORM\Column(type="date")
     */
    private $date_of_birth;

    // Getters and setters
}

In the above example:

@ORM\Index(name="idx_user_email", columns={"email"}): Adds an index to the email column.
@ORM\Index(name="idx_user_name_dob", columns={"last_name", "first_name", "date_of_birth"}): Adds a composite index to last_name, first_name, and date_of_birth columns.

Running Migrations to Apply Indexes

After annotating your entities, you need to generate and run the migrations to apply these indexes to your database schema.

Generate the migration:

php bin/console doctrine:migrations:diff

Run the migration:

php bin/console doctrine:migrations:migrate

These commands will generate the necessary SQL commands to create the indexes and apply them to your database.

Conclusion

By effectively implementing indexes, you greatly enhance the performance of database queries in your Symfony application. Both raw SQL and Doctrine ORM annotations provide flexible ways to define these indexes. Ensure to follow best practices and continually monitor query performance, which we'll discuss in the subsequent sections. Indexing is a powerful tool, but it must be used wisely to ensure it delivers the intended performance benefits.

Validating and Testing Index Performance

Once you've implemented your indexes, the next step is validating their effectiveness and testing their impact on your Symfony application's performance. Here’s how you can systematically approach this process using several essential tools.

Using the Symfony Profiler

Symfony Profiler is a powerful built-in tool that provides detailed insights into your application's performance, including database queries. Here’s how to use it to validate your indexes:

Access the Profiler: Enable the Symfony Profiler in your development environment by ensuring your config/packages/dev/web_profiler.yaml is configured correctly.
Analyze Database Queries: After loading a page, access the Symfony Profiler by clicking the debug toolbar at the bottom of the page. Navigate to the "DB" tab to review the queries executed.
Check Query Duration: Look at the duration of the critical queries before and after indexing. You should see a substantial decrease in query execution time if the indexes are effective.

Monitoring Slow Query Logs

Most relational databases like MySQL and PostgreSQL support slow query logging, which helps identify inefficient queries:

Enable Slow Query Logging:
- MySQL: Add the following to your MySQL configuration file (e.g., my.cnf):
```
slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow-queries.log
long_query_time = 1
```
- PostgreSQL: Adjust your PostgreSQL configuration (postgresql.conf):
```
log_min_duration_statement = '1s'
```
Analyze Slow Queries: Review the slow query logs for any queries that still take a significant amount of time. This helps identify areas that might need additional indexing or query optimization.

Utilizing Database EXPLAIN Plans

Understanding how a database executes a query can provide valuable insights into the effectiveness of indexes:

Generate EXPLAIN Plans: Use the EXPLAIN statement to display the execution plan of your queries:
```
EXPLAIN SELECT * FROM your_table WHERE some_column = 'value';
```
Interpret the Results: The results will show you how the database engine processes the query and whether it utilizes the intended indexes. Look for key metrics like index usage and row scans.

Load Testing with LoadForge

To comprehensively assess the performance impact of your indexes, you should conduct load testing under real-world conditions. LoadForge facilitates efficient load testing:

Set Up LoadForge:
- Create a LoadForge account and set up your test scenarios to simulate realistic traffic patterns.
Run Load Tests: Execute load tests on your Symfony application before and after applying the indexes. This helps measure the overall performance improvements:
Analyze Results: Focus on key performance indicators such as average response times, throughput, and error rates. LoadForge provides detailed reports to help you understand the impact of your indexing on application performance.

Summary

By leveraging the Symfony Profiler, slow query logs, database EXPLAIN plans, and load testing with LoadForge, you can validate and measure the performance improvements from your database indexing efforts. This comprehensive approach ensures your application runs efficiently, providing a better user experience.

Common Pitfalls and Best Practices

When adding indexes to your database tables, it is essential to understand and navigate common pitfalls to maximize the benefits. Below are some common mistakes to avoid and best practices to follow to ensure your Symfony application's performance is optimized without unintended negative impacts.

Common Pitfalls

1. Over-Indexing

Creating too many indexes can lead to significant overhead during write operations. Each index must be updated every time the related data is modified, which can slow down insert, update, and delete operations.

Example Pitfall: Indexes on all columns in a table can cause performance degradation.

CREATE INDEX idx_example_1 ON example_table(column1);
CREATE INDEX idx_example_2 ON example_table(column2);
CREATE INDEX idx_example_3 ON example_table(column3);
-- More indexes might lead to slower write operations.

Tip: Only create indexes on columns that are frequently used in WHERE, JOIN, ORDER BY, and GROUP BY clauses.

2. Ignoring Composite Index Benefits

Failing to use composite indexes when multiple columns are frequently queried together can result in suboptimal performance. Instead of creating separate indexes for each column, a composite index can be more efficient.

Example Pitfall: Separate indexes for columns that are often queried together:

CREATE INDEX idx_user_id ON orders(user_id);
CREATE INDEX idx_status ON orders(status);

Best Practice: Use a composite index:

CREATE INDEX idx_user_status ON orders(user_id, status);

3. Neglecting Index Maintenance

Indexes can become fragmented over time, leading to reduced performance. Regular maintenance activities, such as rebuilding or reorganizing indexes, are crucial for optimal performance.

Tip: Schedule regular index maintenance tasks to keep your indexes in good shape.

4. Overlooking Data Types

Indexing columns with large data types, such as text or blobs, can lead to inefficiencies. Indexes on columns with smaller, fixed-width data types are more efficient.

Example Pitfall: Indexing large text columns:

CREATE INDEX idx_large_text ON large_table(large_text_column);

Best Practice: Prefer using integers or smaller string columns for indexing:

CREATE INDEX idx_user_id ON users(user_id);

Best Practices

1. Analyze and Optimize Query Performance Regularly

Regularly analyze your queries using tools like the Symfony Profiler and database slow query logs. Look for queries that take longer than expected and identify opportunities for indexing.

Example: Using Symfony Profiler to identify slow queries:

# config/packages/dev/web_profiler.yaml
web_profiler:
    toolbar: true
    intercept_redirects: false
    query_logging: true

2. Use EXPLAIN to Understand Index Utilization

Use the EXPLAIN statement to understand how your queries are being executed and whether your indexes are being utilized efficiently.

Example Query:

EXPLAIN SELECT * FROM users WHERE last_login > '2023-01-01';

3. Monitor Index Impact with LoadForge

After implementing indexes, use LoadForge to perform load testing on your application. This will help you understand the impact of your indexes on overall performance under varying levels of load.

Best Practice:

# Run load testing
loadforge test run --url "https://your-symfony-app.com" --concurrent-users 100

4. Follow Naming Conventions

Use consistent and descriptive naming conventions for your indexes to make maintenance easier.

Example:

CREATE INDEX idx_users_last_login ON users(last_login);
CREATE INDEX idx_orders_user_status ON orders(user_id, status);

5. Conditionally Create Indexes

Use dynamic SQL creation to ensure indexes are added only when necessary, particularly in environments with varying data loads.

Example:

IF NOT EXISTS (SELECT 1
               FROM pg_class c
               JOIN pg_namespace n ON n.oid = c.relnamespace
               WHERE c.relname = 'idx_users_last_login' AND n.nspname = 'public')
THEN
    CREATE INDEX idx_users_last_login ON users(last_login);
END IF;

By avoiding common pitfalls and adhering to best practices, you can ensure that your indexing efforts yield significant performance improvements for your Symfony application without adverse effects. This balanced approach will help maintain optimal response times and contribute to a smoother, more efficient user experience.

Continuous Monitoring and Optimization

Ensuring long-term performance improvements in your Symfony application goes beyond initial database indexing. As your application grows and changes, continuous monitoring and optimization of your database queries and indexes are crucial. This ongoing process helps you adapt to evolving data patterns and prevent potential performance degradation.

Monitoring Query Performance

Regularly monitoring query performance is essential for maintaining an optimized database. Here are several strategies and tools to help you keep a close eye on your database queries:

Symfony Profiler: The Symfony Profiler is a powerful tool that provides detailed insights into the performance of your application, including database queries. It shows execution times, which queries are executed, and how often.
- Usage: Ensure the profiler is enabled in your development and staging environments:
```
# config/packages/dev/web_profiler.yaml
web_profiler:
    toolbar: true
    intercept_redirects: false
```
  - Access the profiler via the Symfony debug toolbar at the bottom of your web pages.
Slow Query Logs: Most relational databases offer slow query logs that record queries taking longer than a specific threshold to execute. By regularly reviewing these logs, you can identify queries that may benefit from indexing or optimization.
- MySQL Example:
```
SET GLOBAL slow_query_log = 'ON';
SET GLOBAL long_query_time = 2; -- log queries taking longer than 2 seconds
```
  - Logs are typically stored in a file, such as /var/log/mysql/slow-query.log.
Database Explain Plans: Analyzing explain plans can help you understand how queries are executed and identify areas for improvement. Use the EXPLAIN statement before your query to get this information.
- MySQL Example:
```
EXPLAIN SELECT * FROM users WHERE email = 'example@example.com';
```

Tuning Indexes

Once you've identified slow or frequently executed queries, you can consider further tuning your indexes. Here are best practices for index optimization:

Re-evaluate Existing Indexes: Regularly review the indexes currently in use. Remove unnecessary indexes that do not improve performance or are seldom used.
Composite Indexes: Consider multi-column (composite) indexes for queries that filter on multiple columns.
```
CREATE INDEX idx_users_email_active ON users(email, active);
```

Automated Monitoring Tools

Implementing automated tools can lighten the load of continuous monitoring and provide real-time insights. Some recommended tools include:

New Relic: Provides performance analytics and monitoring for applications, including database performance insights.
PgBadger: For PostgreSQL, PgBadger analyzes PostgreSQL logs and provides detailed performance reports including slow queries.
PMM (Percona Monitoring and Management): A comprehensive monitoring tool for MySQL and MongoDB, offering query analytics and performance dashboards.

Regular Performance Audits

Schedule regular performance audits to systematically review and optimize your application. Audits should include:

Review of Query Execution Plans: Use tools like EXPLAIN to revisit execution plans and adjust indexes as needed.
Index Usage Analysis: Tools like the MySQL performance_schema or PostgreSQL's pg_stat_user_indexes can provide insights into how often indexes are used.

Load Testing with LoadForge

To ensure the changes you've made have a positive impact on performance, conduct regular load testing. LoadForge offers powerful load testing capabilities that simulate real-world usage of your Symfony application. This helps you validate the effectiveness of your indexes under various load conditions:

Set Up LoadForge Tests: Configure tests to mimic typical user interactions with your application.
Run Load Tests: Execute the tests and monitor the results.
Analyze Results: Identify any performance bottlenecks and iterate on your indexes and query optimizations as necessary.

Conclusion

Continuous monitoring and optimization are key to maintaining the performance of your Symfony application. By regularly evaluating query performance, fine-tuning indexes, and leveraging automated tools and load testing techniques, you can ensure that your application remains responsive and efficient as it evolves. Regular performance audits, along with real-world load testing using tools like LoadForge, will help you stay ahead of potential performance issues and deliver a seamless user experience.

Conclusion

In this guide, we've explored various facets of database indexing and its vital role in enhancing the performance of Symfony applications. Let’s recap the key points and underscore the continuous need for performance optimization in your Symfony projects.

Key Points Recap

Introduction to Performance Optimization:
- We began by understanding why performance optimization is a critical aspect of any Symfony application. Quick and efficient response times ensure a good user experience and better overall application performance.
- Database indexing was highlighted as a pivotal strategy for optimizing database interactions.
Understanding Database Indexing:
- We clarified what database indexing is, including the fundamental workings, and discussed different types of indexes such as B-tree, hash, and full-text indexes.
- This foundational knowledge is crucial for making informed decisions about when and what type of indexing is appropriate.
Identifying Indexing Opportunities in Symfony Applications:
- We examined how to pinpoint areas in your Symfony application that would benefit from indexing.
- Tools like the Symfony profiler and database slow query logs were suggested as valuable resources for performance analysis.
Implementing Indexes in Your Database:
- A step-by-step guide was provided to demonstrate how to add indexes to your database tables using SQL commands and Doctrine ORM annotations.
```
// Example Doctrine Annotation
/**
 * @ORM\Table(indexes={@ORM\Index(name="search_idx", columns={"search_field"})})
 */
```
- This practical section aimed to provide actionable steps for implementing indexes effectively.
Validating and Testing Index Performance:
- We discussed methods to validate the effectiveness of your indexes, leveraging tools like the Symfony profiler, slow query logs, and database explain plans.
- Additionally, we introduced using LoadForge for load testing to measure the impact of indexing on your application's performance under different loads.
Common Pitfalls and Best Practices:
- Common mistakes such as over-indexing and not maintaining indexes were highlighted.
- Best practices such as indexing frequently queried columns and avoiding redundancy were emphasized to ensure optimal performance.
Continuous Monitoring and Optimization:
- The need for continuous monitoring was addressed, advocating for regular performance audits and the use of automated tools.
- As your application evolves, so should your indexing strategy to adapt to new query patterns and data changes.

Continuous Performance Optimization

Implementing database indexes should not be a one-time task. The dynamic nature of web applications means that queries and data patterns can evolve, necessitating ongoing adjustments. Regularly monitoring performance and being proactive about optimizations are essential habits for maintaining an efficient Symfony application.

By following the tips and strategies discussed in this guide, you can significantly enhance your Symfony application’s response times. Start by analyzing your queries, implement effective indexes, and validate their performance impact. Keep refining your approach, and leverage tools like LoadForge to ensure your application remains performant under various load conditions.

Moving Forward

We encourage you to apply these insights to your own Symfony projects. Regular database performance optimization is a crucial aspect of maintaining a high-performing, responsive application. With diligent monitoring, a well-considered indexing strategy, and continuous performance tuning, you can deliver a top-notch user experience.

Thank you for following along with this guide. Your journey towards a highly optimized Symfony application is just beginning – happy optimizing!

Recommended

← Guides