Fast. Simple. No meetings. No delays.
Home / Blog / Israel / Website Performance Checklist for Israeli Businesses

Website Performance Checklist for Israeli Businesses

A practical checklist for faster pages: images, fonts, scripts, hosting and the Core Web Vitals that actually affect users.

Cover graphic for the article: Website Performance Checklist for Israeli Businesses

A useful website performance checklist starts with measurement, then works through images, fonts, third-party scripts, caching, hosting and mobile behaviour in order of impact. Fix the biggest bottleneck first, re-test, and set up monitoring so the gains last. Treat this list as a working document you return to, not a one-off audit.

Measure first: field data versus lab data

Before changing anything, decide what you are measuring. There are two kinds of data, and they answer different questions.

  • Lab data comes from a tool that loads your page in a controlled setting (for example Lighthouse or PageSpeed Insights). It is repeatable, so it is ideal for checking whether a specific change helped.
  • Field data comes from real visitors on their real phones and connections (for example the Chrome User Experience Report, which PageSpeed Insights surfaces when enough traffic exists). It tells you whether users actually experience a problem.

Check the three Core Web Vitals in both: Largest Contentful Paint (how quickly the main content appears), Interaction to Next Paint (how quickly the page responds to taps and clicks) and Cumulative Layout Shift (how much the layout jumps). Google documents the current thresholds on web.dev; confirm them there rather than trusting a blog post, including this one, because they can be revised.

Test the pages that matter commercially: the home page, your top landing page, a product or service page, and the checkout or contact form. If your visitors are mostly in Israel but some are abroad, look at the field data split by country if your analytics allows it, since distance to your server changes the result.

Images: size, format and lazy loading

Images are usually the largest part of a page, so they are the first place to look.

  1. Serve images at the size they are displayed. A photo uploaded at camera resolution and shown in a small card wastes bandwidth.
  2. Use a modern format such as WebP or AVIF where your audience's browsers support it, with a fallback if you need one.
  3. Use srcset and sizes so phones download smaller files than desktops.
  4. Add explicit width and height attributes so the browser reserves space and the layout does not jump.
  5. Lazy-load images below the fold with loading='lazy', but do not lazy-load the main hero image. That image is often the Largest Contentful Paint element and should load early.

Fonts and third-party scripts

Fonts

Hebrew web fonts can be heavy, especially if you load several weights plus a Latin set. Keep the number of families and weights small, subset the font to the characters you need, and use font-display: swap so text shows immediately in a fallback face. Self-hosting fonts is often faster than adding another external connection. Check that the Hebrew and Latin text both fall back gracefully.

Third-party scripts

Chat widgets, tag managers, analytics, heatmaps, review badges and ad pixels all run on your visitor's device and compete with your own code. Make an inventory and ask of each one: who uses this data, and when did they last look at it? Remove what nobody uses, load the rest with async or defer, and delay non-essential widgets until after the page is interactive or the user scrolls. Re-test after each removal so you know which one actually mattered.

Caching and compression

  • Enable Brotli or gzip compression for HTML, CSS, JavaScript and JSON.
  • Give static files (CSS, JS, fonts, images) long cache lifetimes and use versioned file names so a new release busts the cache automatically.
  • Put a CDN in front of static assets so that visitors in Israel and abroad fetch them from a nearby location.
  • Cache full pages for anonymous visitors where the content allows it, and exclude carts, accounts and checkout.
  • Minify CSS and JavaScript, and remove CSS and JS that no page uses.

Hosting and database response time

If the server takes a long time to send the first byte, no front-end tweak can fully compensate. Look at Time to First Byte in your lab tool, then ask where the time goes.

  • Is the server in a region reasonably close to most of your visitors?
  • Is the PHP or Node runtime reasonably current and configured with an opcode cache or process manager?
  • Are slow database queries the cause? Turn on the slow query log, look for missing indexes, and watch for pages that run the same query dozens of times in a loop. Our notes on MySQL query optimisation for PHP applications go deeper on this.
  • Is shared hosting at its limit during peak hours? Compare response times at busy and quiet times before deciding to upgrade.

Mobile-specific fixes

Most phones have less processing power than the laptop you test on, and mobile connections vary. Test with CPU and network throttling turned on.

  • Reduce JavaScript. Long tasks block taps, which hurts Interaction to Next Paint.
  • Avoid large carousels, autoplaying video and heavy animations on small screens.
  • Make tap targets large enough and keep cookie banners and pop-ups from covering content or pushing it down after load.
  • Check right-to-left pages on a phone as well. A mirrored layout can introduce its own shifts if images or fonts load late.

Monitoring so it stays fast

Sites slow down gradually: a new marketing script here, an uncompressed banner there. Make performance a habit rather than a project.

  • Set a simple performance budget, such as a maximum image weight per page or a limit on the number of third-party scripts, and review it when anyone adds something.
  • Run automated lab tests on key pages after each release.
  • Watch field data monthly for the three Core Web Vitals and note any change.
  • Keep a short change log, so that when a metric moves you can see what shipped that week.

Putting your website performance checklist together

Work in this order: measure, fix the largest images, remove or defer unnecessary scripts, enable caching and compression, then look at hosting and the database. Re-test after each step so you learn what moved the numbers. If the problems sit deep in a custom codebase, fixing Core Web Vitals on a custom-built website covers the code-level work, and our software development services for Israeli businesses page explains how an outside team can help with a larger clean-up. You can also compare options on the packages page.

Frequently asked questions

What is a good Largest Contentful Paint?

Google's web.dev guidance has described roughly two and a half seconds or less as good for Largest Contentful Paint, measured at the 75th percentile of real visits. Thresholds can be revised, so confirm the current figure on web.dev, and judge your own pages by field data from real visitors rather than a single lab run.

Do third-party scripts slow my site?

Often yes. Chat widgets, tag managers, pixels and heatmaps download and run on your visitor's device, competing with your own code. List every script, ask who still uses its data, remove what is unused, and load the rest with async or defer. Re-test after each change to see which one mattered.

How often should I re-test performance?

Run an automated lab test on key pages after every release, since that is when regressions appear. Review field data from real visitors about once a month, and do a fuller audit whenever you add a major feature, change hosting, redesign, or install a new third-party script.

Related articles

Web Development Tel Aviv

Startup Landing Page Launch Checklist

Everything a startup landing page needs before launch: message, speed, forms, analytics, metadata, privacy text and tracking.

6 min read

🚀 Start Now