Problem: API slowness due to N+1 queries
You launch an e-commerce store on Laravel, and within a month the API starts to slow down: pages load in 3-4 seconds. The typical culprit is N+1 queries in Eloquent ORM. The frontend fetches a list of orders, each order pulls user and products — 100 queries instead of one. But that's just the tip of the iceberg: suboptimal migrations, missing cache, slow integrations. Let's break down how to design a backend that can handle growth.
Why Laravel solves N+1 queries
Laravel with Eloquent ORM provides built-in mechanisms: eager loading (with(), load()), caching (Redis, Memcached), query optimization through subqueries. We use Eloquent not as a simple ORM but as a tool to build efficient queries. For catalog with filters and pagination we apply dynamic scopes, for complex aggregations — subqueries. This reduces database load and speeds up responses. Compared to raw PHP, Laravel cuts development time by 2-3x thanks to ready-made solutions.
How we architect Laravel backends
Standard MVC is the base, but to support growth we add a service layer and repositories. Typical module structure:
app/ Http/ Controllers/ Api/V1/ ProductController.php Requests/ CreateProductRequest.php Resources/ ProductResource.php Middleware/ EnsureRole.php Models/ Product.php Services/ ProductService.php Repositories/ ProductRepository.php Jobs/ SendOrderConfirmation.php Events/ OrderPlaced.php This approach isolates business logic from controllers and simplifies testing. We also use the Repository pattern to abstract database interaction. Unlike traditional MVC, the service layer allows easy replacement of implementations (e.g., switching from MySQL to PostgreSQL).
Typical backend bottlenecks in Laravel
| Problem | Solution | Result |
|---|---|---|
| N+1 queries | Eager loading, Redis cache | DB load reduced 5-10x |
| Slow authentication | Sanctum + Spatie Permissions | Response time < 50 ms |
| Unstable integrations | Queues with retry and backoff | API not blocked on failures |
| Suboptimal migrations | Indexes, foreign keys, speed checks | Migrations in seconds |
Case study: tagged cache for e-commerce
For a store with 50,000 products we implemented tagged caching. Category data was cached for 5 minutes; when a product changed, only its category cache was invalidated. Catalog page load time dropped from 2 seconds to 200 ms. Redis as a cache server handles requests 10x faster than direct MySQL queries.
// Tagged cache $products = Cache::tags(['products', "category:{$categoryId}"]) ->remember("products:cat:{$categoryId}:page:{$page}", 300, function () use ($categoryId, $page) { return Product::active()->where('category_id', $categoryId)->paginate(20, ['*'], 'page', $page); }); Case study: async order processing
In another project we implemented queues for sending emails and generating PDFs. We used Laravel Queue with Redis driver. At a peak of 1000 orders per minute, the queue processed in 10 seconds. The retry algorithm with exponential backoff eliminated task loss. This solution allows scaling processing without increasing load on the main server.
More on queue configuration
For queue configuration we use retry_after and backoff parameters in config/queue.php. For critical jobs, we set up to 3 retries with a 30-second interval. This ensures that failure of an external service does not lead to data loss.
How we test Laravel applications
Testing is a key stage. We write feature tests for API (PHPUnit), unit tests for services and repositories. Use Factory and Seeder for database seeding. On CI/CD we run tests before every deploy. This ensures changes don't break existing logic. This approach catches regressions early.
Process of work
- Analysis: study requirements, load, current architecture.
- Design: database schema, API structure, package selection.
- Development: migrations, models, controllers, tests.
- Integration: connect queues, cache, external services.
- Deployment and monitoring: CI/CD setup, logging, alerts.
Estimated timelines
| Step | Duration |
|---|---|
| Database and API design | 3-5 days |
| Core module development | 2-4 weeks |
| Queues, events, cache | 1-2 weeks |
| Testing and deployment | 1 week |
| Total | 5-10 weeks |
Exact timeline depends on complexity. Laravel provides powerful tools, but proper architecture is the key to success.
What's included in the work
- API documentation (OpenAPI/Swagger)
- Server and repository access
- Deployment instructions
- Team training (2-3 calls)
- 3-month warranty for bug fixes
Our team has over a decade of experience in Laravel and PHP, having implemented over 50 projects for e-commerce and enterprise systems. We guarantee stability and scalability.
Contact us for a free consultation and project evaluation.