Boost Your Laravel App Speed with These Optimization Tips
Tags: laravel, webdev, appconfig, tutorial
Published: 2023-07-26 19:55:12

Working on a Laravel project? Cool! It's a real powerhouse with its robust security and simple yet sophisticated coding architecture.

One thing though - Laravel can get slow if you don’t use the right optimization techniques.

Here are some tips to optimize your Laravel app:

### **1\. Route Caching**

Route caching is a helpful feature for apps with lots of routes. It saves you time by grouping routes into one command, so your website loads faster. Laravel retrieves the routes from the pre-compiled cache, rather than starting from scratch for each user. To use it, run this command:

```bash
php artisan route:cache
```

Remember to run it every time you make structural changes to your website. To clear the cache, use:

```bash
php artisan route:clear
```

### **2\. Optimize Composer**

Laravel uses Composer to manage dependencies. When you install Composer, it loads dev dependencies by default, but they slow down your website once it's live. To remove dev dependencies, use the command:

```bash
composer install --prefer-dist --no-dev -o
```

This optimizes the autoloader and boosts performance while keeping necessary dependencies intact. Just be careful not to remove runtime dependencies that your website needs to function properly.

### **3\. Reduce Autoloaded Services**

The goal of Laravel is to make the development process as breezy for devs as possible. When you launch Laravel, for example, it auto-loads a large volume of service providers listed in the **config/app.php** file to help you get started with your project quickly.

While this is a beneficial step by Laravel, you won’t need to use all of these services for building an application.

Take the REST API for instance. You don’t require services such as View Service Provider or Session Service Provider. In addition, many developers don’t follow the default framework settings. You can simply disable services that are superfluous to your needs (e.g. Pagination Service Provider, Translation Service Provider, Auth Service Provider, etc).

You’ll be able to improve the speed of your Laravel applications by applying the same principle to other apps. Just make sure you don’t remove any important services, and double-check everything before you drop the hammer.

### **4\. Use Artisan Commands and Cache Effectively**

Artisan is a popular command-line tool that comes with Laravel. It makes it easy for developers to carry out recurring and complex tasks automatically. Website creators can also use it to conduct tests and generate commands.

Using Artisan commands cleverly can amp up your app performance. Below, we’ve listed several of the best caching commands you can utilize.

#### **Configuration Caching**

Cache config is an excellent command to get a speed boost. It compiles all of your application’s configuration values into one file so that the framework can load faster. All you need is to run:

```bash
php artisan config:cache
```

Note that you shouldn’t execute the **config cache** command during local development. This is because configuration settings may need to be changed often throughout the development of your app.

To clear the config cache, run this command:

```bash
php artisan config:clear
```

#### **Views Caching**

The view cache is another aspect of the application that contains a cache. The view cache stores generated Blade templates to increase the speed of your project. You can use the artisan command below to compile all views manually and optimize performance:

```bash
php artisan view:cache
```

Remember to clear the cache when you upload a new code; otherwise, Laravel will use your old views and you will spend lots of time trying to troubleshoot this. Run this command to clear the view cache:

```bash
php artisan view:clear
```

#### **Application Caching**

This is the main cache in Laravel. It saves all the data that you cache manually in your app. Using Laravel’s cache is a smart approach to speed up commonly accessed data and optimize Laravel performance. If you use tags or multiple cache storage, you can flush only certain elements of the cache.

Here’s the artisan command to clear the Laravel cache:

```bash
php artisan cache:clear
```

Keep in mind that this command won’t delete any route, config, or view cache located in the /bootstrap/cache/ folder.

### **5\. Reduce Package Usage**

As an [open-source framework](https://kinsta.com/blog/php-frameworks/) with a populous community, it’s only natural to see more and more packages released or new versions in existing packages in Laravel. You’re free to use them and their features directly in your application.

You must include these packages in the `composer.json` file. Laravel will subsequently install them along with their dependencies.

Nevertheless, there are a few factors to be considered before adding new packages to any application. They aren’t all designed for the same purpose, for instance. Some packages are also created to perform a broad range of functions.

When you include packages with lots of dependencies, the application’s size grows, and its performance eventually suffers. That’s why it’s essential to review the dependencies closely before adding any package.

### **6\. Upgrade to the Latest Version of PHP**

Just like any other bit of code or software program, it’s always best to [update your PHP version](https://kinsta.com/blog/php-versions/) to the most recent release.

The primary reason to use an up-to-date PHP version is security. For two years, every PHP release receives security patches and bug fixes. Your system could be jeopardized if you continue to use earlier versions that are no longer being maintained.

Many developers may also be unaware that the older a PHP version gets, the slower its performance becomes. To boost efficiency, the [current PHP release](https://kinsta.com/blog/php-8-1/) has outstanding performance improvements such as faster execution of requests, enums, fibers, and inheritance cache.

Here at Kinsta, we use the latest major PHP version ([PHP 8.1](https://kinsta.com/feature-updates/php-8-1/)) for all environments so users can benefit from the platform’s extensive capabilities and optimize their apps for maximum speed and efficiency.

### **7\. Use Queues**

Offloading sluggish tasks to a queue job is a simple technique to rapidly maximize the speed of your Laravel application.

Sometimes you don’t need the information in the UI right away. In this case, such tasks can be postponed and run later in the background by a separate process (e.g. [sending an email](https://kinsta.com/blog/secure-email-providers/)). This can significantly increase the performance of your app’s online requests.

Laravel supports a variety of queue drivers such as IronMQ, Redis, Amazon SQS, and Beanstalkd. It additionally includes a built-in queue worker that can be executed using the following command:

```bash
php artisan queue:work
```

You can add a new job into the queue using this method:

```bash
Queue::push('SendEmail', array('message' => $message));
```

Use the method below via Carbon if you want to defer the execution of one of the queued jobs. For example, say you want to schedule a job that sends an email to a client 10 minutes after they create an account:

```bash
$date = Carbon::now()->addMinutes(10);

Queue::later($date, 'SendEmail@send', array('message' => $message));
```

## **Overall,**

Laravel is a fast-growing PHP framework, and there are [lots of tutorials available](https://kinsta.com/blog/laravel-tutorial/) for all kinds of users to learn Laravel regardless of their knowledge level.

What other methods have you used to speed up your Laravel apps? Let us know in the comments section below.