Skip to content
PRS India

Laravel 12 · Octane · Horizon · Filament

Laravel Development

The framework we have built more business systems on than any other. Laravel 12 with Octane for speed, Horizon for job queues that survive a bad day, and Filament for a back office your operations team will really use.

Last updated

  • p95 under 40ms with Octane
  • Horizon-supervised queues
  • Filament admin from day one
  • 85%+ test coverage on main paths
Laravel Development
Why Laravel

The boring framework that keeps shipping.

Laravel is not exciting, and that is the whole reason to use it. A queue system that works. An ORM that does not fight you. Database changes that survive four years of schema changes. An admin panel you get for free, instead of budgeting three days for it and regretting it for five years. We use Laravel when the system handles many transactions and the business rules are complicated: orders, payments, inventory, approvals, matching accounts, reporting. That is most business software. The framework has an answer for nearly every problem such a system will hit. The answer is usually the one the next Laravel engineer would pick too, so the code outlives the team that wrote it.

Talk to a Laravel engineer
38ms
p95 API latency

On Octane with FrankenPHP, measured on a live I/O-bound API, not in a benchmark.

4.2x
Throughput on Octane

Typical gain over PHP-FPM once the application is careful about state kept in memory.

2.1M
Jobs per day

Watched by Horizon, on the busiest queue we run now. Safe to repeat, can be replayed, and failed jobs are kept.

87%
Test coverage

On the main business paths, with Pest. Feature tests that use the database, not fake parts that agree with themselves.

How we actually build it

Laravel is the framework we have put more live systems on than any other, and the reason is plain: a good team can build a correct, well-tested business application in it that is easy to maintain, faster than in anything else. The person who takes it over in three years will understand what they are looking at.

Octane, and when it is a trap

Laravel Octane starts the application once and keeps it in memory, serving requests from a long-running worker under FrankenPHP or Swoole. On an I/O-bound API we often see requests per second go up by three to five times and p95 latency drop below 40 ms, because you no longer pay for framework start-up on every single request.

The trap is that a worker kept in memory changes the rules. Static properties stay between requests. Singletons hold data you did not mean to keep. A container binding that captured the first request's user will happily show that user's data to the next person. Octane is a speed tool for code that is already careful about state. It does not fix a slow application, and we will not switch it on to hide N+1 queries. We find those first, with Telescope and Pulse, and fix them.

Queues are where the application actually lives

Anything that talks to a system we do not control goes on a queue. Payment webhooks, GST filings, carrier APIs, invoice PDFs, e-way bill generation, sending many notifications: all of it is a job, backed by Redis, watched by Horizon, on a named queue with its own workers, so a slow third party cannot block your checkout. Jobs are safe to run twice, because a queue will deliver twice one day and that day should pass quietly. Failed jobs go into a table with their full data, and there is a screen where an operator can look at one and run it again without a developer opening a terminal.

This is the biggest design difference between a Laravel application that survives its first Diwali sale and one that does not.

Filament for the back office, and it is not a compromise

Nearly every business application needs an internal admin. It nearly always gets three days at the end of the project and is hated for the next five years. We build it in Filament instead: screens over the same Eloquent models, real roles and permissions, bulk actions, exports, activity records, and custom pages where a table is the wrong answer. Your operations team gets a tool they can really work in on day one, and your engineers stop being a human CRUD interface for anyone who needs a record changed.

The rest of the discipline

Pest for tests, with feature tests that use the HTTP layer and the database rather than faking everything until the test means nothing. Database changes that can always be undone. Sanctum for API tokens, Passport when a real OAuth server is truly needed. Scout with Meilisearch or Typesense when search matters. Telescope in staging, Pulse on the live system. Every release sits behind a health check with a one-command rollback, because the important question about a release is not whether it will fail but how fast you can undo it.

The honest part

When Laravel is the right call — and when it is not.

  Choose Laravel Choose something else
Transactional business system Yes, and it is not close. Orders, payments, inventory, approvals, reporting: Laravel has a proven answer for every part of it. Nothing we would suggest over it for this kind of problem at this budget.
100k concurrent WebSocket connections No. PHP holds one process per connection. This is the wrong tool and no amount of tuning fixes that. Node.js or Go for the socket layer. Keep Laravel for the business rules behind it and let the two talk over Redis.
CPU-bound ML or heavy data processing No. You will be fighting the language, and a library that already exists elsewhere will do better. Python. Run it as a separate service and have Laravel call it through a queue. This is a plain, reliable way to do it.
Public site that must rank hard Blade makes fine HTML and ranks perfectly well. For most sites this is a complete answer. If the marketing site is very important to your business, a Next.js front end on a Laravel API gives you better tools for it.
Your team is JavaScript-only Consider it anyway. Laravel plus Inertia keeps React on the front, and learning it takes two weeks, not three months. If the team truly will not maintain PHP, NestJS on Node is the closest thing to Laravel's clear structure in that world.
You need an admin panel in a week Filament. Screens over your existing models, real permissions, bulk actions, activity records. Days, not sprints. There is no better answer in any tool set we work in. This is Laravel at its most productive.
What we build

Laravel work we take on.

ERP and internal platforms

Inventory, buying, approvals, GST-aware invoicing, and reports so the finance team stops copying data to Excel.

CRM and sales systems

Lead routing, pipeline, activity records, and quota and commission rules that hold up when a real sales director uses them.

APIs for mobile and partners

REST APIs with versions, using Sanctum or Passport, request limits, keys that stop repeat actions, and OpenAPI docs that are generated, not written by hand.

Filament admin panels

A real back office over your existing models: permissions, bulk actions, exports, activity log. Days of work, not a sprint.

Octane and queue performance

Measuring, removing N+1 queries, index work, then Octane and separate Horizon worker pools. Usually cheaper than the rewrite you were quoted.

Legacy PHP rescue

CodeIgniter, Yii, or a 2014 Laravel that never upgraded. Moved page by page into modern code, with releases all the way.

Migration path

From straining monolith to queued workers.

What we do when a Laravel application is slow and somebody has already quoted you for microservices.

  1. 01

    Measure before touching anything

    Week 1

    Telescope and Pulse in staging with data like the live data. The slowest endpoint is almost never the one the team suspects. The fix is almost always an N+1 query or a missing index, not a new design.

  2. 02

    Fix the database first

    Weeks 1–2

    Eager loading, composite indexes, and moving report queries onto a read replica. This alone often takes p95 down by 60 to 80 percent, and it costs a fraction of anything else on this list.

  3. 03

    Get third parties out of the request

    Weeks 2–4

    Every call to a system you do not control becomes a queued job: payment webhooks, carrier APIs, GST filings, PDFs, sending many notifications. Jobs are safe to repeat, tried again after a wait, and failed ones are kept with a screen to run them again.

  4. 04

    Isolate the worker pools

    Week 4

    Horizon with named queues and separate worker pools, so a pile of invoice PDFs cannot block checkout. Each pool gets its own alarm for size and age, so you find out before your customers do.

  5. 05

    Then, and only then, consider Octane

    Week 5

    Once we have checked how state is handled and fixed the queries, Octane on FrankenPHP gives three to five times more throughput. It costs one config change and a careful check of static properties and singletons.

Characteristics

Performance and cost, with numbers.

  • p95 under 40ms on Octane

    FrankenPHP workers keep the application in memory. Framework start-up stops being a cost on every request, which is where most of the gain comes from.

  • Runs on modest hardware

    A container that keeps no state behind a load balancer, with Redis for cache and sessions. Most systems we run cost between ₹8,000 and ₹40,000 a month to host.

  • Queues that survive a bad day

    Jobs that are safe to repeat, longer waits between retries, and a table of failed jobs with a replay screen an operator can use without a developer or a terminal.

  • Auth and permissions that hold up

    Sanctum or Passport, rule-based permission checks, and roles enforced in the model layer, not left for the controller to remember.

  • Observability from day one

    Pulse on the live system, Sentry for errors, alarms on queue size and age. You should never learn about an outage from a customer.

  • Reversible deploys

    Releases with no downtime behind a health check, database changes that can always be undone, one-command rollback. The question is not whether a release fails but how fast you undo it.

The stack

What ships with a Laravel build from us.

Laravel 12
PHP 8.4
Octane + FrankenPHP
Horizon

Slow Laravel app? Bring it to us before you approve the rewrite.

Most systems we are asked to rebuild do not need rebuilding. They need the queries fixed, the third parties moved onto queues and the workers kept apart. We will tell you honestly which one you are.

FAQ

The questions you were going to ask on the call.

PHP 8.4 with JIT is a fast, strictly-typed language with good tools, and Laravel is the most productive full-stack framework we have used. The question is never "is PHP serious". It is "what does this system actually do". For a business application with many transactions (orders, payments, inventory, daily work steps, reporting, an admin panel), Laravel will get you live sooner and cheaper than a custom Node or Go stack, and it will still be easy to read for whoever takes it over. For a live system holding a hundred thousand open sockets at once, we would not use it, and we would tell you so.

When the application is I/O bound, already free of obvious N+1 problems, and careful about static and container state. Then Octane typically gives us three to five times the request throughput and drops p95 latency under 40ms, because framework start-up stops happening on every request. We do not turn it on to rescue a slow application. A worker kept in memory will happily keep leaked state between requests, which turns a speed problem into a data-leak problem. Measure first, fix the queries, then start Octane.

It handles the size most businesses really have. We run Laravel systems doing millions of requests a day. They use app containers that keep no state behind a load balancer, Redis for cache and sessions, a read replica for report queries, and Horizon workers on their own machines, so a pile of PDF jobs cannot slow down checkout. In practice the limit is almost never PHP. It is the database, and it would have been the database in any language.

Livewire when the screens are mostly built on the server with a few interactive parts: dashboards, CRUD, admin, forms with conditional logic. It keeps one language, one way of thinking and one release. Inertia with Vue or React when the interface is truly like an app (drag and drop, instant updates, complex browser state) and you want a real frontend framework without hand-writing an API layer. If the product also needs a public marketing site that must rank, we will often pair a Laravel API with a Next.js front end instead.

Almost always, and a rewrite is usually the wrong idea. The problem is rarely the monolith. It is that everything runs inside the HTTP request. We measure, fix the N+1 queries and missing indexes, then move every slow or third-party operation onto Horizon queues with separate worker pools. Reports go to a read replica. Often-read data gets a cache that is cleared properly. Most "we need microservices" talks end at that point, having cost a fraction of a rewrite and carrying none of its risk.

A focused internal tool or workflow system is typically 8 to 12 weeks from around ₹8,50,000. A full platform — multi-role, payments, integrations, a real admin, an API for a mobile client — is 16 to 28 weeks and starts around ₹22,00,000. What moves the price is connections to other systems. Every outside system you do not control is a risk with a deadline attached, which is why we check them in a paid discovery sprint before quoting.

Let's talk laravel development

Bring us the hard version of the problem.

A senior engineer reads every enquiry. You'll get a real answer — scope, risk and a number — within one business day.