webpagetest | Official repository for WebPageTest | Cryptography library

Never mind. Found the problem, it was one of the scripts. Now TTFB 32ms.

When you receive any data from a server, your client connects to the server using, in most cases, a TCP connection.
TCP has a maximum amount of data that you can send for packet (TCP segments) that is the MSS or maximum segment size. Another limiting factor is the maximum transmission unit, MTU, that depends on the minimum MTU of the routers in the path between your client and the server, and resulting in the maximum amount of bytes you can send for each packet.
The 12kB you are referring in your question i believe are relative to the:

• MTU and depends on the protocol in use and, for example, with ethernet the the MTU is 1518 bytes with the ethernet headers and 1500 bytes for the upper layer data.
• For the MSS of TCP, if the IPV4 and ethernet protocols are in use (so MTU data can accomodate up to 1500 bytes of data), is 1500 - 20(ip headers) - 20(tcp headers) giving a MSS of 1460 bytes(this value is not guaranteed, since client and server can negotiate the MSS value if they support a different MSS value during the TCP connection procedure).

The minimum of those values will prevale otherwise if you send a packet that exceeds the MTU the the first router in the path will drop the packet.

So if the page (or data) size exceeds the MSS, TCP will segment your data in multiple segments, thus requiring more time to be acknowledged and sent. But if the data you are sending is smaller than the MSS, only one segment will be used resulting in a smaller time to send the page or "less chunks".

This is just a brief explaination, of course the values used in the examples above are examples of general cases so they can be different for specific scenarios since are not fixed.
Here you can find some more useful articles from wikipedia that might help with more insight:

• MTU
• TCP MSS
• TCP

You can add alwaysRun = true in @AfterClass annotation. like @AfterClass(alwaysRun=true).

If your test classes are independent of each other then it is good to use separate session for each test class. In this case you have to write @AfterClass method in each of test class to close individual session.

Does it mean that WebPageTest will neglect these responses with max-age=0 in static cache checking?

The documentation states that resources which include a specific indication of non-cacheability will not be subject to the 'Cache Static' check:

Applicable Objects

Any non-html object with a mime type of "text/*", "*javascript*" or "image/*" that does not explicitly have an Expires header of 0 or -1, a cache-control header of "private", "no-store" or "no-cache" or a pragma header of "no-cache"

While max-age=0 isn't included in that list, it should be treated the same as no-cache, and is likely being treated the same here and excluding those objects from this check.

Field data and Origin Summary are real world data.

There is the key difference between these metrics and the synthetic test that Page Speed Insights runs.

For example: CLS is measured until page unload in the real world, as mentioned in this explanation on CLS from Addy Osmani who works on Google Chrome.

For this reason your CLS can be high for pages if they perform poorly at certain screen sizes (as Lighthouse / PSI only tests one mobile screen size by default) or if there are things like lazy loading not performing well in the real world and causing layout shifts when things load too slowly.

It could also be certain browsers, connection speeds etc. etc.

Let's assume you have a page that does well in the Lighthouse synthetic test but it performs poorly in the real world at certain screen sizes. How can you identify it?

For that you need to gather Real User Metrics (RUM) data.

RUM data is data gathered in the real world as real users use your site and stored on your server for later analysis / problem identification.

There is an easy way to do this yourself, using the Web Vitals Library.

This allows you to gather CLS, FID, LCP, FCP and TTFB data, which is more than enough to identify pages that perform poorly.

You can pipe the data gathered to your own API, or to Google Analytics for analysis.

If you gather and then combine the web vitals information with User Agent strings (to get the browser and OS) and the browser size information (to get the effective screen size) you can narrow down if the issue is down to a certain browser, a certain screen size, a certain connection speed (as you can see slower connections from high FCP / LCP figures) etc. etc.

Page Speed Insights (PSI) is designed for simulating a first time user to the site, so your cookies popup would always show.

It does not cache cookies or anything else. There is no way to send cookies to PSI.

If you are using Lighthouse in the browser simply untick the "Clear Storage" option in the top bar (you may have to click the gear icon top right to reveal this) and at that point run the page twice (once to set the cache), cookies will be stored and you will record a run with cached images, files etc.

If you wanted to create a run where cookies are stored but nothing else is cached you could go to the application tab in developer tools and remove everything other than the cookies.

However as this is not indicative of a real world scenario I do not see the benefit and is only included as it answers the original question.

Your final option for complete control would be to run Lighthouse CLI on your own machine.

The source code for Lighthouse is available on GitHub, takes a short while to set up, installing chromium etc. but it is worth it.

At that point you have more control, if you partner it with Puppeteer then you have all the control to set individual cookies etc.

However it does appear that you should be able to pass cookies directly to Lighthouse via config according to this thread, but it might not work and ultimately ends up recommending puppeteer. Perhaps that is a feature that will get improved upon soon.

It seems to be the context of this issue.

In your getLocations() try adding this line before the fetch:

let vm = this

then inside your fetch function use:

vm.locationList.push(list); instead of this.locationList.push(list);

Hope it helps. Good luck.

The speed (in seconds, not scores) displayed on the speed test results is very influential on the test server region. The closer the test server region is, the faster the loading time will be.

Example of speed test results for your page, using servers from Australia - Sydney, Canada - Vancouver, and your base location: Brazil - São Paulo, using GTmetrix.

• Australia - Sydney (3,2s)
• Canada - Vancouver (1,9s)
• Brazil - São Paulo (0,8s)

So, it can be concluded LARGE POSSIBLE test server region used by Google Search Console is far from your base location.

By the way, when I open your page from Indonesia, it only takes about 0.9-1.2 seconds. So, congratulations, your page is fast!

Remove the font_awesome_flutter plugin from pubspec.yaml and wherever you are using it in your project.

You can just extract the icons you need from the font and discard the rest. An east way to do this is to use the IcoMoon site. For example I used the site to generate a font with only the Apple logo icon.

Note the code (eabe). You'll use it later.

You get get instructions for doing that here. I called my font family Apple.

To use your icon just use a Text widget with the code as the text and specify the font family that you registered in step 2.