Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
High Performance Web Sites

High Performance Web Sites

Make websites feel faster by finding the delays hidden beyond the initial HTML.
by Steve Souders 2007 168 pages
4.15
500+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Profile the full page: HTML delivery is often just 10-20% of the wait

The visible delay is elsewhere. Souders found that downloading the initial HTML usually accounted for only 10-20% of a page's response time. The rest was spent fetching images, scripts, stylesheets, and other components, or waiting for the browser to process them. Across ten major sites, the HTML share was under 20% in nearly every measured case.

Small changes can have large reach. If backend work accounts for just 10-20% of the wait, cutting it in half improves total response time only modestly. The book reports that more than 50 Yahoo! teams reduced end-user response times by 25% or more through frontend improvements. Start by recording a request waterfall, which shows when each page resource is requested and completed, then improve the largest sources of delay.

Analysis

This is an application of Amdahl's law: speeding up a small fraction of a process places a hard ceiling on the total gain. The insight shifts performance work from the server's response to the entire trip from request to usable page. It also explains why a page can have a fast backend and still feel slow. The original measurements date to 2007, so the percentages are not universal constants. The durable lesson is methodological: measure where users actually wait before choosing what to optimize.

Cut requests before bytes: combine assets without shipping code the page never needs

Each request has overhead. When a page has many separate images, scripts, and stylesheets, the browser must make more HTTP requests. Souders recommends reducing requests without sacrificing the design: CSS sprites combine several images into one file, while build processes can combine scripts and stylesheets that remain modular during development. An image map can also replace a row of separate linked images. In one example, combining scripts made the page load 38% faster.

Choose combinations carefully. The book also describes data URLs, which embed small images in a page or stylesheet. They eliminate image requests but increase encoded size and, when placed in HTML, cannot be reused from the browser's cache across pages. Duplicate scripts are another avoidable request and can execute repeatedly. The aim is fewer unnecessary trips, not one enormous bundle containing resources no visitor needs.

Analysis

This is a latency problem as much as a file-size problem. In networked systems, each exchange can cost time even when the payload is small, so bundling often pays off more than shaving a few bytes from an individual asset. But bundling creates a countervailing cost: users may download unused code, and a changed bundle can invalidate a large cache entry. The strongest version of the advice is therefore selective consolidation, guided by shared use and measured request overhead.

Cache reusable files for years, but version their names when they change

Avoid repeat validation. An Expires header or Cache-Control max-age tells a browser how long it may reuse a saved component without contacting the server. A conditional GET checks whether an older copy is still valid, but still requires a round trip. In Yahoo! measurements cited in the book, 75-85% of page views arrived with a primed cache. In a test page, far-future expiration reduced repeat-view response time by 57%.

Make freshness explicit. Long caching creates a release problem: users may keep an old file after it changes. The solution is to publish changed content under a new filename, often by adding a version identifier. The book also warns that default ETags can undermine validation across a server cluster when different machines generate different tags for the same file. Configure consistent validators or remove unnecessary ETags.

Analysis

Caching is a form of moving work out of the critical path: a file already stored on the user's device needs neither a full transfer nor a validation exchange. Versioned filenames make that strategy reliable by separating the identity of each release. The tradeoff is operational discipline. A stale asset can break a page, so long-lived caching works best when publishing is automated and filenames change with content. The book's ETag warning is especially useful as a reminder that cache behavior depends on the whole delivery path, not just browser settings.

Compress text payloads, and minify scripts; skip risky obfuscation

Send fewer text bytes. Gzip compresses repetitive text, including HTML, JavaScript, CSS, XML, and JSON. The book's example page fell from 177.6K to 46.4K after its HTML, stylesheet, and script were compressed, a 73.8% reduction in transferred size and a 53.2% faster response in that test. Already-compressed formats such as images and PDFs generally should not be gzipped again. Servers must also identify which response variants are compressed so proxies do not serve the wrong version.

Then remove code clutter. Minification strips comments and unnecessary whitespace. Across six sites' JavaScript files, it reduced size by an average of 21%; combined with gzip, it saved an additional 20% compared with gzip alone. Obfuscation can shrink files further by renaming symbols, but it increases the risk of bugs and makes production code harder to debug.

Analysis

Compression exploits repetition, while minification removes characters that carry no meaning to the interpreter. These techniques complement each other because they eliminate different kinds of redundancy. The decision not to obfuscate is also a maintainability argument: a small extra transfer saving may be a poor bargain if it lengthens diagnosis of a production failure. Compression is not free, since servers and clients spend CPU cycles, so the right test compares transfer savings against processing costs for the actual audience and workload.

Put stylesheets first and scripts last so browsers can render progressively

Resource order shapes what users see. Stylesheets placed in the document head let browsers obtain styling early. When stylesheets appear near the bottom, some browsers may withhold rendering and leave users staring at a blank screen. Others may show content before styling arrives, creating a flash of unstyled content. Souders recommends linking stylesheets in the head rather than importing them with CSS `@import`, which can delay their retrieval.

Scripts block more than execution. A browser may pause rendering and other downloads while an external script loads, because it could change the document or depend on execution order. Putting scripts near the end lets the visible page appear sooner. The book also warns against CSS expressions, a legacy Internet Explorer feature that repeatedly evaluates JavaScript during events such as scrolling and mouse movement. One example produced thousands of unnecessary evaluations.

Analysis

The distinction here is between total completion time and perceived progress. A page may finish downloading at the same moment yet feel faster if meaningful content appears earlier. This connects interface performance to human factors: visible feedback helps people understand that a system is responding. The specific browser behaviors discussed reflect the book's 2007 environment, so exact placement rules should be verified against current browsers and tooling. The underlying question remains useful: which resources prevent the next useful thing from appearing?

Use CDNs and a few hostnames to shorten distance without multiplying lookups

Bring static assets closer. A content delivery network, or CDN, serves files from distributed locations so users can retrieve them from a nearby server. Souders's test page loaded 18% faster from a CDN than from one distant server. In a Yahoo! Shopping rollout, measuring across live users showed a 20% response-time reduction, while tests near the company's own data center had suggested less than 5%. Static assets are easier to distribute than dynamic pages, which may depend on databases, sessions, and application logic.

Balance parallelism and DNS. Each new hostname can require a DNS lookup, which the book estimates may take 20-120 milliseconds, but multiple hostnames can allow more simultaneous downloads. Its 2007 guidance was to use roughly two to four hostnames for a page with many components, while supporting persistent connections. Treat those figures as historical guidance and measure under the current browser, protocol, and network conditions.

Analysis

The CDN example exposes a common measurement trap: testing from the office may privilege the infrastructure closest to the developers rather than the users. Distributed systems performance is geographic, so representative measurement locations matter. Hostname splitting presents a genuine optimization tension: more parallel transfers can help, but DNS resolution and connection setup have costs. Modern protocol behavior can change that balance, which makes the principle more durable than the old numeric prescription: reduce distance, then measure the net effect.

Avoid redirects and duplicate scripts because both add delays users cannot see

A redirect delays the whole page. Before the browser can retrieve the destination HTML, it must make an initial request, receive the redirect, and request the new address. Nothing on the destination page can render while those steps are underway. Souders recommends avoiding redirects for common fixes such as missing trailing slashes, connecting old and new site routes, or tracking navigation when direct routing or referrer logging can do the job.

Repeated code wastes work. A duplicated script can trigger extra requests, especially in the Internet Explorer versions tested, and it is evaluated multiple times even when already cached. A script-management function in the page template can prevent duplicate inclusion and manage dependencies and versions in one place. For outbound click tracking, the book discusses beacons as an alternative, while noting that coordinating a beacon with navigation can introduce complexity and timing risks.

Analysis

Both problems are examples of invisible work inserted between a user's intention and the result. Redirects are easy for developers because they simplify routing, and shared scripts can be added independently by multiple teams. Those local conveniences create global latency. This is an organizational insight as much as a technical one: central ownership of routes and asset inclusion can prevent repeated costs that no individual contributor sees. Measurement should also distinguish necessary redirects from accidental ones, since some migrations genuinely require them.

Externalize shared code when caching beats the cost of another request

Inlining is not always faster. In a one-view comparison, putting JavaScript and CSS directly in the HTML was 30-50% faster than fetching separate files, because it avoided extra requests. But external files can be cached and reused across pages, while inline code is downloaded again with each uncached HTML document. The better choice depends on how often users revisit, whether their cache is primed, and how many pages share the same assets.

Match packaging to navigation. The book generally favors external files for sites with repeated visits and reusable code. It identifies home pages as a possible exception, since a user may visit only one page per session and expect it to appear quickly. A page can inline what it needs immediately, then download external copies after load for likely next pages. Dynamic inlining uses a cookie as a rough signal of whether files may already be cached.

Analysis

This is a useful reminder that an optimization cannot be judged from a single request in isolation. Inlining wins on the first visit by eliminating a network exchange; external files can win over a session by amortizing their cost across pages. The broader concept is amortization: pay a setup cost once, then reuse the result. Cookies only estimate cache state, however, so this technique is probabilistic rather than exact. Real visit patterns and cache measurements should decide the tradeoff.

Cache Ajax by user and resource identity; asynchronous does not mean instant

Requests still take time. Ajax lets a page request data without a full reload, but an active request may leave the user waiting for the answer. Passive requests, made before information is needed, can make likely next actions feel faster. In Yahoo! Mail, the client downloaded the first three messages in advance. A request for another message was not cacheable, so reopening it caused another server trip even when the content had not changed.

Define what a response belongs to. To cache personalized data safely, the request must identify both the user and the specific resource, for example through a user identifier and a stable message ID. A simple position such as fourth in the inbox is not stable because the list can change. The book also stresses privacy: cache policy must reflect sensitive content, not merely performance goals. Compression, minimal redirects, and other frontend rules apply to Ajax responses too.

Analysis

The key distinction is between a responsive interface and a completed task. Asynchrony can keep a screen interactive without making the requested information arrive sooner. Prefetching can hide latency when the next action is predictable, but it can also spend bandwidth on data never used. Cache identity is equally important: personalization is compatible with caching when each response is correctly scoped, but careless keys risk serving the wrong version or user's data. Performance and privacy must be designed together.

Use waterfalls and real-user measurements to find the bottleneck, not intuition

Inspect the request sequence. A waterfall chart shows when each request begins and ends, making blocked downloads, serial scripts, and idle gaps visible. In the book's 2007 survey of ten major sites, page weight and response time had a correlation of 0.94. Yet weight alone did not explain everything: Yahoo! was relatively heavy but fast, while Amazon's many images made its page slow despite a favorable YSlow score. YSlow graded pages against the book's rules and helped point teams toward likely fixes.

Test with the right audience. The book warns that a test near the server can understate the benefit of a CDN. It also shows why a single grade is not a substitute for inspecting actual behavior. Measure repeat views as well as first visits, and examine performance from multiple locations. The best next change is the one that removes the real bottleneck, not the one that improves a tidy metric.

Analysis

This is a case for combining metrics rather than worshipping one. Page weight, request count, visual rendering, and response time describe different parts of the experience; none is a complete proxy for the others. A high correlation across ten sites is informative but does not prove that reducing bytes alone causes every improvement. The Amazon example makes that limitation concrete. The best performance practice is empirical iteration: form a diagnosis from traces, change one important factor, and verify the user-facing result.

Analysis

The book's central contribution is a change of attention. Web performance is often treated as a server problem, so engineers reach first for database tuning, faster hardware, or application rewrites. Souders instead follows the browser's work after it receives HTML and finds that component requests, caching behavior, resource order, and network distance often dominate the user's wait. The result is an unusually practical engineering argument: many high-value gains come from modest changes to asset packaging and server configuration rather than major architectural projects.

Its rules are most powerful when read as interacting mechanisms, not an untouchable checklist. Combining files can reduce request overhead but may increase unused payload. Long cache lifetimes avoid repeat validation but require versioned filenames. More hostnames can improve parallel downloads while adding DNS and connection costs. Inlining can accelerate an initial page yet sacrifice reuse. The book repeatedly shows that performance is a balancing problem, and that the right choice depends on a site's traffic and component reuse.

The measurement examples also give the book its narrative force. Waterfalls turn an abstract delay into visible blocked requests and idle gaps; comparisons across test locations reveal how easily teams can measure themselves rather than their users. YSlow makes the rules actionable, but its grades are only diagnostic. The Amazon example demonstrates that a good score can coexist with a slow page when the scoring model misses an important source of work.

The technical environment is explicitly of its time. Browser concurrency limits, Internet Explorer behavior, and HTTP conventions described in 2007 should not be carried forward as fixed specifications. Modern delivery stacks require retesting those prescriptions. The enduring value lies beneath the details: observe the whole delivery path, minimize avoidable exchanges, make reusable content reusable, and judge success by measured user experience. That method remains useful even when the browser's mechanics change.

Summary in 30 Seconds
The initial HTML often accounts for just 10 to 20% of a page's wait, so profile every resource. Reduce needless requests, compress text, and order stylesheets and scripts to let visible content arrive sooner. Long-lived caching can cut repeat-view response time by 57%, provided changed files get new names. CDNs and careful asset packaging can help, but tradeoffs depend on reuse and network conditions. Use waterfalls and real-user measurements to locate the actual bottleneck.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.15 out of 5
Average of 500+ ratings from Goodreads and Amazon.

High Performance Web Sites receives mixed reviews, with an overall positive reception. Many readers find it informative and essential for web developers, praising its practical advice on improving website performance. Some highlight its continued relevance despite its age, while others consider it outdated. The book is commended for explaining the reasoning behind optimization techniques and providing concrete examples. Critics note that some information is now widely available online or through tools like YSlow. Overall, it's seen as a valuable resource for understanding web performance fundamentals.

Your rating:
4.51
171 ratings
Want to read the full book?

Glossary

Performance Golden Rule

Frontend time dominates

Souders's principle that downloading the HTML document commonly consumes only 10-20% of a page's end-user response time, while fetching and processing the page's components accounts for most of the rest. It directs optimization toward images, scripts, stylesheets, caching, and browser behavior rather than focusing only on backend response time.

CSS sprites

Combined image assets

A technique that places multiple small images in one image file and displays the desired portion as an element's background using CSS positioning. It reduces the number of image requests while retaining more layout flexibility than an image map. The combined file can also be smaller than the separate images because shared image-format overhead is reduced.

far future Expires header

Long-lived browser cache

An HTTP response header that tells browsers a component can be reused from cache until a distant expiration time. It prevents repeat requests and validation checks for stable assets. Because browsers may continue using that copy after the server file changes, the book pairs long expiration with changing the asset's filename whenever its contents are updated.

ETag

Resource version validator

An HTTP entity tag is a server-provided identifier for a particular version of a resource. A browser can send it back in a conditional request so the server can respond that its cached copy remains valid. Souders warns that default tags may include machine-specific values, causing validation to fail when requests move between servers in a cluster.

CSS expressions

Dynamic CSS JavaScript

A legacy Internet Explorer feature that allows a CSS property to be calculated with a JavaScript expression. The browser may reevaluate the expression during rendering, resizing, scrolling, or pointer movement, creating substantial repeated work. The book recommends replacing expressions with one-time assignments or event handlers tied only to relevant changes.

Post-Onload Download

Load assets after rendering

A technique for downloading external JavaScript or CSS after a page's load event, often after a short delay. It lets a home page use inline code for its immediate first render while placing external files in the browser cache for likely subsequent pages. The approach requires care because the code may be included both inline and externally.

Dynamic Inlining

Choose inline or external

A technique that uses a cookie as an approximate signal of whether external JavaScript or CSS has already been downloaded. If the signal suggests a cold cache, the server places the code in the HTML; otherwise, it references external files. A post-load download can establish the cookie and populate the cache. The signal is imperfect, but a mismatch affects efficiency rather than basic correctness.

primed cache

Assets already cached

A browser cache is primed for a page when its reusable components have already been stored locally. A primed visit can avoid downloading those files, while an empty-cache visit must fetch them. The distinction matters when evaluating expiration headers and deciding whether inline code or external files will perform better across a user's visits.

YSlow

Web performance grader

A Yahoo!-developed tool that examines a page's components, HTTP headers, and implementation choices against performance rules, then assigns an overall grade. It also exposes component summaries and rule-level findings to help locate likely improvements. Its score is a diagnostic aid, not a direct measurement of every user's experience or a guarantee that a page is fast.

Performance Research, Part 2: Browser Cache Usage - Exposed!

Yahoo cache-use study

A browser-cache study by Tenni Theurer cited by Souders. It found that, across Yahoo! properties, 40-60% of unique users arriving at least once per day had a primed cache, while 75-85% of page views occurred with one. The distinction shows why repeat page views can benefit substantially from caching even when many users initially arrive with empty caches.

FAQ

1. What’s "High Performance Web Sites" by Steve Souders about?

  • Focus on Frontend Performance: The book explains that 80–90% of web page load time is spent on the frontend, not the backend, and provides actionable rules to optimize this.
  • 14 Performance Rules: Souders presents 14 prioritized rules for making web sites faster, each explained in its own chapter with real-world examples.
  • Practical, Data-Driven Advice: The book is based on research and extensive testing, offering practical techniques that can be implemented with minimal effort for significant speed gains.
  • Covers a Range of Technologies: Topics include HTTP, caching, compression, JavaScript, CSS, CDNs, DNS, and Ajax, making it a comprehensive guide for web developers.
  • Case Studies and Tools: The book analyzes top websites and introduces tools like YSlow to help developers measure and improve performance.

2. Why should I read "High Performance Web Sites" by Steve Souders?

  • Immediate Impact on Speed: Implementing even a few of the book’s rules can make web pages noticeably faster, improving user experience and retention.
  • Frontend Optimization Focus: It shifts the common misconception that backend is the main bottleneck, showing that frontend changes often yield bigger, faster wins.
  • Actionable and Accessible: The rules are clear, concise, and often require only configuration changes or minor code adjustments, making them accessible to most developers.
  • Industry Endorsements: The book is praised by leading developers and is considered essential reading for web developers and performance engineers.
  • Long-Term Benefits: Most optimizations are one-time tweaks that continue to pay off as your site grows and evolves.

3. What are the key takeaways from "High Performance Web Sites"?

  • Frontend Dominates Load Time: The majority of user wait time is due to frontend issues, not backend processing.
  • 14 Rules for Speed: Following the book’s prioritized rules can reduce page load times by 25–50% or more.
  • Caching and Fewer Requests: Techniques like reducing HTTP requests, leveraging browser caching, and combining files are among the most effective.
  • Measure and Profile: Always profile your site to identify where the biggest gains can be made, using tools like YSlow and Firebug.
  • Continuous Improvement: Performance is an ongoing process; regularly review and update your practices as your site and technology evolve.

4. What is the "Performance Golden Rule" in "High Performance Web Sites" by Steve Souders?

  • Backend vs. Frontend Time: Only 10–20% of end user response time is spent downloading the HTML document; the remaining 80–90% is spent on frontend components.
  • Optimization Focus: To achieve the greatest performance improvements, focus on optimizing the frontend—images, scripts, stylesheets, and other resources.
  • Diminishing Returns on Backend: Halving backend response time yields only minor overall gains, while halving frontend time can cut total load time by up to 45%.
  • Easier and Faster to Implement: Frontend optimizations typically require less time and fewer resources than backend changes.
  • Proven Results: Many teams at Yahoo! and elsewhere have achieved 25% or greater reductions in response times by following this rule.

5. What are the 14 rules for high performance web sites according to Steve Souders?

  • Rule 1: Make Fewer HTTP Requests: Reduce the number of components (images, scripts, stylesheets) to minimize HTTP overhead.
  • Rule 2: Use a Content Delivery Network (CDN): Serve static content from geographically distributed servers to reduce latency.
  • Rule 3: Add an Expires Header: Leverage browser caching by setting far-future Expires or Cache-Control headers on static resources.
  • Rule 4: Gzip Components: Compress HTML, CSS, and JavaScript to reduce transfer size and speed up downloads.
  • Rule 5: Put Stylesheets at the Top: Place CSS in the document HEAD to enable progressive rendering and avoid blank screens.
  • Rule 6: Put Scripts at the Bottom: Move JavaScript to the end of the page to prevent blocking rendering and parallel downloads.
  • Rule 7: Avoid CSS Expressions: Don’t use dynamic CSS expressions in IE, as they can cause severe performance issues.
  • Rule 8: Make JavaScript and CSS External: Use external files for better caching and reuse, except in rare cases like homepages.
  • Rule 9: Reduce DNS Lookups: Limit the number of unique hostnames to minimize DNS resolution delays.
  • Rule 10: Minify JavaScript: Remove unnecessary characters from code to reduce file size and improve load times.
  • Rule 11: Avoid Redirects: Eliminate unnecessary HTTP redirects, which delay page loading.
  • Rule 12: Remove Duplicate Scripts: Ensure scripts are included only once to avoid extra downloads and execution.
  • Rule 13: Configure ETags: Remove or standardize ETags to prevent cache misses in multi-server environments.
  • Rule 14: Make Ajax Cacheable: Apply caching and other performance rules to Ajax requests for dynamic applications.

6. How does "High Performance Web Sites" by Steve Souders recommend reducing HTTP requests, and why is this important?

  • Biggest Impact on Load Time: Reducing HTTP requests is the single most effective way to speed up initial page loads, especially for first-time visitors.
  • Techniques Provided: Use image maps, CSS sprites, inline images (with data: URLs), and combine scripts and stylesheets to cut down the number of requests.
  • Balance Design and Performance: These methods allow you to maintain rich designs without sacrificing speed.
  • Development Workflow: Modularize code during development, but use a build process to combine files for production.
  • Real-World Results: Examples in the book show up to 50% faster load times by applying these techniques.

7. What is the role of caching and the Expires header in "High Performance Web Sites"?

  • Browser Caching: Setting a far-future Expires or Cache-Control header allows browsers to reuse cached resources, reducing repeat HTTP requests.
  • Primed vs. Empty Cache: Most users and page views benefit from caching, as a significant percentage revisit sites with a primed cache.
  • Beyond Images: Apply caching headers to all static resources—images, scripts, stylesheets, and Flash—not just images.
  • Filename Versioning: When updating resources, change filenames (e.g., add version numbers) to ensure users get the latest versions.
  • Dramatic Speed Gains: Proper caching can cut response times for repeat visits by 50% or more.

8. How does "High Performance Web Sites" by Steve Souders address compression and file size reduction?

  • Gzip Compression: Enable gzip (or deflate) on your server for HTML, CSS, and JavaScript to reduce file sizes by about 70%.
  • What to Compress: Only compress text-based files; images and PDFs are already compressed and don’t benefit.
  • Configuration Tips: The book provides Apache configuration examples for mod_gzip and mod_deflate, and discusses handling edge cases with proxies and browser bugs.
  • Minification: Remove comments and whitespace from JavaScript (and CSS) using tools like JSMin for further size reduction.
  • Combined Effect: Gzipping and minifying together maximize bandwidth savings and speed.

9. What are the best practices for JavaScript and CSS placement and management in "High Performance Web Sites"?

  • External Files Preferred: Use external JavaScript and CSS files for better caching and reuse, except in special cases like homepages.
  • Placement Matters: Put stylesheets in the HEAD for progressive rendering; place scripts at the bottom to avoid blocking downloads and rendering.
  • Combining Files: Merge multiple scripts and stylesheets into single files to minimize HTTP requests.
  • Minify and Gzip: Always minify and gzip these files to reduce size and improve load times.
  • Special Techniques: For homepages, consider inlining or dynamic inlining with post-onload downloads to balance speed and caching.

10. How does "High Performance Web Sites" by Steve Souders recommend handling DNS lookups and redirects?

  • Reduce Unique Hostnames: Limit the number of domains used for resources to minimize DNS resolution delays (each lookup can take 20–120ms).
  • Balance Parallel Downloads: Use 2–4 hostnames to allow parallel downloads without excessive DNS lookups.
  • Keep-Alive Connections: Enable persistent connections to further reduce DNS lookups and connection overhead.
  • Avoid Redirects: Eliminate unnecessary HTTP redirects, as they delay the delivery of the HTML document and all resources.
  • Alternatives to Redirects: Use server configuration (Alias, mod_rewrite) and referer logging instead of redirects for tracking and URL management.

11. What are ETags, and why does "High Performance Web Sites" by Steve Souders advise configuring or removing them?

  • ETag Definition: ETags are unique identifiers for resource versions, used by browsers to validate cached content.
  • Multi-Server Issues: Default ETag formats in Apache and IIS include server-specific data, causing cache misses when requests are served by different servers.
  • Performance Impact: Mismatched ETags force unnecessary downloads, increasing load times and bandwidth usage.
  • Recommended Solution: Remove ETags or configure them to be consistent across servers, relying on Last-Modified headers for cache validation.
  • Real-World Prevalence: Many top sites have not addressed this, leading to avoidable performance penalties.

12. How does "High Performance Web Sites" by Steve Souders apply its rules to Ajax and modern web applications?

  • Ajax Performance Matters: The same frontend rules

About the Author

Steve Souders is a prominent figure in web performance optimization. As a former Chief Performance Yahoo! at Yahoo!, he pioneered many techniques for improving front-end performance. Souders is known for developing tools like YSlow and advocating for performance best practices. His work has significantly influenced how developers approach website optimization. Souders has authored multiple books on web performance, including "Even Faster Web Sites" as a follow-up to "High Performance Web Sites." He has also contributed to various open-source projects and spoken at numerous conferences, establishing himself as a respected authority in the field of web performance engineering.

Download PDF

To save this High Performance Web Sites summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.46 MB     Pages: 23

Download EPUB

To read this High Performance Web Sites summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.44 MB     Pages: 29
Want to read the full book?
Follow
Listen10 mins
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...