Performance Optimisation

What This Is

Performance optimisation is the process of finding and eliminating the specific bottlenecks that make your application slow. Not applying generic best-practice checklists — actually measuring where time is spent, identifying the operations that consume the most resources, and fixing them in order of impact. A page that takes 4 seconds to load might have a single database query responsible for 3 of those seconds. Fixing that one query delivers more improvement than a dozen minor optimisations combined.

We approach performance as a measurable engineering discipline. Every optimisation starts with a measurement and ends with a measurement. If a change does not produce a measurable improvement in the metric that matters — page load time, server response time, Time to First Byte, database query duration — then it was not worth making. This discipline prevents the common trap of optimising things that feel slow but are not actually bottlenecks, while the real performance problems remain untouched.

Performance affects revenue directly. Research consistently shows that every additional second of page load time reduces conversion rates, increases bounce rates, and decreases user satisfaction. Google uses page speed as a ranking factor. Mobile users on constrained connections are especially sensitive to load times. The performance work we do is not abstract engineering — it translates to measurable business outcomes.

When You Need This

Performance optimisation is relevant when your application has measurable speed problems or when performance data shows degradation trends. Common scenarios:

• Page load times exceed 3 seconds and user engagement metrics (bounce rate, conversion rate) are suffering
• Server response times (TTFB) are over 500ms for pages that should be faster, indicating backend bottlenecks
• Your application has grown in data volume or traffic and performance has degraded as the database and server handle more load
• Specific pages or features are disproportionately slow — reports, dashboards, search, or pages with complex data aggregation
• Core Web Vitals scores (LCP, CLS, INP) are poor, affecting search ranking and user experience
• Your application runs on limited server resources and you need to extract better performance from the existing infrastructure rather than scaling up
• Database query times are climbing as tables grow, and the application was not designed with query performance in mind

This is not a substitute for architectural fixes. If the application’s fundamental architecture cannot support its workload — a monolithic query that joins every table, a synchronous process that should be async, a missing caching layer — those structural problems need addressing before micro-optimisation becomes productive.

How We Work

Performance work follows a profile-first methodology. We measure before we change anything. The profiling phase identifies exactly where time is spent — which database queries are slow, which API calls block the response, which frontend assets delay rendering, and which server configurations create unnecessary overhead. This produces a prioritised list of optimisations ranked by expected impact.

Backend profiling uses Laravel Telescope, query logging, and PHP profiling tools to trace request processing from start to finish. Every database query, cache interaction, external API call, and computation is timed. We identify N+1 query problems (the most common Laravel performance issue), missing indexes, unnecessary eager loading, and queries that should be cached. Fixes are specific and measurable — “added an index to orders.user_id, reducing the dashboard query from 2.3s to 12ms.”

Database optimisation is often where the biggest wins live. EXPLAIN analysis reveals queries performing full table scans on large tables. Missing indexes on foreign keys and frequently-filtered columns are added. Complex queries are restructured to use more efficient join strategies. Results that do not change frequently are cached in Redis with appropriate TTLs. Aggregate queries that scan millions of rows are replaced with materialised summaries updated on schedule.

Frontend optimisation addresses the client-side half of performance. JavaScript bundle sizes are analysed for unnecessary dependencies. Images are served in modern formats (WebP, AVIF) at appropriate sizes. CSS is loaded efficiently — critical CSS inline, non-critical CSS deferred. Third-party scripts that block rendering are loaded asynchronously. These changes improve Core Web Vitals scores and the perceived speed of the application.

Caching strategy is designed for the specific application rather than applied generically. Page-level caching for content that changes infrequently. Fragment caching for expensive components within dynamic pages. Query result caching for database operations that produce the same output across many requests. API response caching for external data that updates on known schedules. Each cache has an explicit TTL and invalidation strategy.

Infrastructure-level optimisation covers the server configuration that affects all requests. Nginx is configured with gzip/Brotli compression, appropriate buffer sizes, and static asset caching headers. PHP-FPM is tuned for the worker count and memory limits that match the server’s resources and the application’s request profile. OPcache is configured with appropriate memory allocation and revalidation settings.

What You Get

• Performance audit — comprehensive profiling identifying bottlenecks ranked by impact, with specific fix recommendations
• Database optimisation — index additions, query restructuring, and caching for the queries that consume the most time
• Frontend improvements — bundle analysis, image optimisation, critical CSS, and third-party script management
• Caching implementation — Redis caching strategy with appropriate TTLs, invalidation, and cache warming
• Server tuning — Nginx, PHP-FPM, OPcache, and database server configuration for the application’s workload
• Core Web Vitals improvement — targeted fixes for LCP, CLS, and INP that affect search ranking and user experience
• Before/after metrics — documented measurements proving the impact of each optimisation

Technologies We Use

• Laravel Telescope — request profiling with query, cache, and event timing
• Chrome DevTools / Lighthouse — frontend performance profiling and Core Web Vitals measurement
• MySQL EXPLAIN / PostgreSQL EXPLAIN ANALYZE — query execution plan analysis
• Redis — application caching, session storage, and result set caching
• Nginx — compression, static asset serving, and connection management
• OPcache — PHP bytecode caching for eliminating repeated script compilation
• WebPageTest / GTmetrix — synthetic performance testing from multiple locations

Related Systems

Performance optimisation touches every layer of the stack. Backend work involves Laravel application code and MySQL or PostgreSQL databases. Caching uses Redis. Web serving is handled by Nginx. Frontend assets are built by Vite and styled with Tailwind CSS. Server monitoring provides the ongoing metrics that track performance over time.

Talk to Us About Performance

If your application is slower than it should be and you want measurable improvements rather than generic advice, get in touch and we will profile the application and identify the highest-impact fixes.