Website performance is no longer a “nice to have” — it’s a critical part of user experience.
Faster websites keep users engaged, reduce bounce rates, and directly impact SEO rankings.

In this article, I want to share a simple yet powerful technique that can noticeably improve perceived page load speed using only 6 lines of HTML — no frameworks, no heavy refactoring.

The Core Idea

Instead of waiting for the user to click a link before loading the next page, modern browsers can be instructed to prepare pages in advance.

Google Chrome recently introduced the Speculation Rules API, which allows developers to define rules for prefetching and prerendering pages that users are likely to visit next.

The result?
Pages feel almost instant when the user clicks.

The magic code

<script type="speculationrules">
  {
    "prerender": [{ "where": { "href_matches": "/*" }, "eagerness": "moderate" }],
    "prefetch": [{ "where": { "href_matches": "/*" }, "eagerness": "moderate" }]
  }
</script>

How It Works

🔹 Prefetch

• Downloads only the HTML of the target page in the background

• Uses minimal resources

• Ideal for lightweight performance improvements

🔹 Prerender

• Fully loads the page (HTML, CSS, JavaScript, images)

• Keeps it ready to be displayed instantly

• Provides the best perceived speed, but uses more resources

🔹 Eagerness: moderate

• Tells the browser to wait for a short user signal (like hovering over a link)

• Avoids aggressive preloading

• Strikes a balance between speed and resource usage

Why This Matters

✔ Faster navigation
Pages appear instantly when users click links.

✔ Better user experience
Smooth transitions make the website feel responsive and modern.

✔ Improved engagement
Users stay longer on fast websites.

✔ SEO benefits
Page speed is a confirmed ranking factor for search engines.

Important Notes

• This feature is currently supported in Chrome 121+

• Other browsers will safely ignore the rule

• If resource usage is a concern, you can use prefetch without prerender

• Best suited for content-heavy websites with frequent internal navigation

Final Thoughts

Performance optimization doesn’t always require complex architecture or advanced tooling.
Sometimes, a few well-placed lines of HTML can make a real difference.

If you’re a Frontend or Full-Stack developer, this is definitely worth experimenting with.

Thanks <3

Ahmed Muhammady.

Advantages of the Dynamic Where Clause

One of the primary advantages of using the dynamic where clause in Laravel is its flexibility. With this feature, you can dynamically construct your SQL queries based on the conditions you specify. This can be especially useful when working with complex queries that require a lot of conditional statements.

Another advantage of the dynamic where clause is that it allows you to easily build queries that are customizable by the end user. For example, if you are building a search feature for your application, you can use the dynamic where clause to allow users to search for specific attributes like name or email address.

The dynamic where clause can also help you write concise code. Instead of writing multiple if statements to check for different conditions, you can use the dynamic where clause to construct your query in a single line of code.

Disadvantages of the Dynamic Where Clause

One potential disadvantage of using the dynamic where clause is that it can lead to code that is difficult to maintain. When you are constructing complex SQL queries on the fly, it can be easy to create code that becomes hard to read and understand over time. Additionally, if you are not careful, you may end up with queries that are vulnerable to SQL injection attacks.

Another disadvantage of the dynamic where clause is that it can be slower than constructing queries manually. This is because the dynamic where clause requires Laravel to parse the conditions you specify and generate the appropriate SQL on the fly. In some cases, this can result in slower query execution times.

However, there are ways to mitigate these disadvantages. For example, you can use Laravel’s query builder to construct your queries in a more structured manner, which can make them easier to read and maintain. Additionally, you can use Laravel’s query logging feature to identify slow queries and optimize them for better performance.

Examples

To illustrate how the dynamic where clause works, let’s take a look at two examples: whereEmail and whereName. These methods allow you to search your database for records based on a user’s email address or name, respectively.

Here is an example of how you might use the whereEmail method to search for users with a specific email address:

$user = User::whereEmail('info@webcapsules.com')->first();

In this example, we are using the dynamic where clause to construct a query that searches for a user with the email address ”info@webcapsules.com”. The ‘first()’ method returns the first user that matches this criteria.

Similarly, you can use the whereName method to search for users by name:

$users = User::whereName('Muhammady')->get();

In this example, we are using the dynamic where clause to construct a query that searches for all users with the name “John”. The ‘get()’ method returns all users that match this criteria.

Conclusion

While the dynamic where clause in Laravel may not be as well-known or widely-discussed as some other features, it can be a powerful tool in your development arsenal. By using this feature, you can build flexible, customizable queries that allow your users to search for specific attributes in your database.

However, it is important to be aware of the potential disadvantages of using the dynamic where clause, such as code that is difficult to maintain and slower query execution times. As with any feature in Laravel, it is important to weigh the pros and cons carefully and use the dynamic where clause judiciously. By doing so, you can take advantage of its benefits and avoid its pitfalls to build better, more efficient applications.