Web Page Rendering and Everything You Need to Know About It
Tags: webdev, javascript, frontend, beginners
Published: 2023-10-03 10:01:17

If you are a Frontend Developer, you are expected to understand how a web page renders, the methods involved, and when to use each. Some time back, during a Frontend Engineer job interview, I felt confident until the interviewer threw me a curveball: "Explain the difference between Server-Side Rendering and Client-Side Rendering and when would you use each?" At that moment, I realized I might not land the job. 

It was a bit embarrassing, but it motivated me to learn. However, I struggled to find online resources that explained in simple terms and addressed when and how to use these rendering methods. This led me to write this article.

**Here is what we are going to cover:**

- What is Web Page Rendering?

- Why should Web Page Rendering matter to a Frontend Developer?

- Various Web Page Rendering methods, along with their advantages and drawbacks.

- When should you use the different Rendering methods?

- Popular Frontend frameworks and their default rendering types.


## What is Web Page Rendering?
In simple terms, Web Page Rendering is the transformative process by which the code you, as a developer, create comes to life and is converted into interactive pages for users. Browser engines play a crucial role in this process as they retrieve the HTML, CSS, JavaScript, and media files, arranging them to present an engaging and visually appealing experience. 

## Why Should Rendering Matter to a Frontend Developer?
Because you stand at the forefront of delivering exceptional user experiences, and the browser is one of your primary tools for coding.

Browser engines are responsible for rendering your code to the user, but their performance relies heavily on the quality of the input they receive. To optimize the web applications you build, it's imperative to implement the right techniques from the very beginning. Your approach should be tailored to your project's specific requirements and the goal of providing users with the best possible experience.

Unfortunately, some developers overlook this aspect, often due to a lack of understanding or awareness of its importance. However, it's important to prioritize rendering if you aim to develop applications characterized by superb user experiences, enhanced performance and speed, improved search engine optimization, and greater accessibility. Frontend Developers who can master the art of rendering optimization are highly esteemed in the industry, as it showcases their expertise in crafting high-performance web applications.

## Types of Web Page Rendering With Their Pros and Cons
You may have heard about so many rendering types, but these are the two we will be focusing on:

1. Server-Side Rendering
2. Client-Side Rendering

Let us explore each of them, their pros and cons.

**Server-Side Rendering (SSR)**
As the name suggests, Server-Side Rendering (SSR) involves processing site content on the server rather than in the browser. This involves server-side handling of codes, including the retrieval of external data, before transmitting the fully rendered page to the browser. The server typically receives a request from the client and generates an HTML page for it. 

To illustrate this process, imagine visiting a website and requesting a specific page from the server, either directly or through a button click, the server receives the request and employs a server-side rendering engine to generate HTML content with the requested data and templates. Then the server dispatches this HTML content to the client, which immediately displays it within the browser. Afterward, the client may load JavaScript and CSS files to enhance the page's interactivity.

**Pros**
- Swift Page Loading: Servers generate complete HTML pages, including content, styles, and scripts. When users request a page, they instantly receive fully assembled pages.

- Search Engine Optimization Advantages: Rendering content prior to page load enables search engines to crawl and index it. This can significantly enhance a website's search engine ranking compared to client-rendered applications that are heavily reliant on JavaScript for content rendering.

- Accessibility: SSR enhances accessibility by ensuring immediate access to content, even in cases where JavaScript fails to load or execute properly. This is useful for users who depend on screen readers or have limited JavaScript access. It also benefits users with slower internet connections or older devices.

- Ideal for Static Websites: SSR is good at rendering web pages with minimal dynamic content and delivers superior performance.

**Cons**
- Server Strain: When HTML is created with each page request, it puts extra pressure on the server, especially for web applications that have high traffic.

- Slower Page Navigation: While SSR speeds up the first-page load, moving between pages can become sluggish because the browser has to ask for and load a fresh HTML page for each transition.

- Demands Resources: SSR applications require a server, leading to higher operational expenses. These costs increase as the application expands.

- Complexity and Compatibility Challenges: Implementing SSR can be trickier than client-side rendering (CSR) because it involves additional server-side coding for rendering and routing. Also, certain third-party tools may not work smoothly with SSR.

**Client-Side Rendering (CSR)**
In Client-Side Rendering, a huge portion of the rendering and processing of pages happens in the user's browser rather than on the server. The client requests a template with the necessary JavaScript and CSS files from the server which is loaded and executed in the browser.

How does this work? When you request a web page, the server sends an HTML template that includes the basic structure of the page. Once this is loaded, the JavaScript code responsible for fetching data from an API and manipulating the DOM is executed and the fetched data is used to populate the template. Also, routing or navigation takes place on the client side without a full page reload. 

**Pros**
- Reduced Server Load - The server primarily focuses on providing data and API endpoints, reducing the need for Server-Side Rendering. This can lead to more efficient server resource utilization.
- Faster Navigation and Page Speed - Once the initial JavaScript and CSS resources are cached, navigating between pages within the application can be very fast because only the data and minimal markup need to be fetched.
- Interactivity - CSR allows for highly interactive and dynamic web applications. Users can perform actions, such as clicking buttons and submitting forms, without waiting for full-page reloads.

**Cons**
- Not Very Suitable For Search Engine Optimization - Traditional search engine crawlers may have difficulty indexing CSR applications because they often rely heavily on JavaScript. Although search engines have improved their ability to crawl and index JavaScript-generated content, server-side rendering is still preferred for SEO-sensitive content.
- Slow initial page load - Since only templates are fetched from the server on initial page load and rendering of the page happens after the execution of JavaScript code, the pages take a long time to display their content to the users.
- Accessibility: Ensuring accessibility in CSR applications can be challenging because some users may rely on assistive technologies that require fully rendered HTML content.

**Others:**
**Pre-rendering:** This is simply prefetching all page elements ahead of runtime. It's more like transforming your high-level programming language into machine code before you run the program. Static HTML files are generated even before the users request them and can be beneficial to the server.

Pros:
- It doesn't require so much Server-Side processing which makes web pages load faster and has good performance.
- Search engines can easily index static HTML which means pre-rendered pages are SEO-friendly.

Cons:
- Static sites rarely have dynamic behavior and the web pages may have limited real-time interactivity.

**Deferred Site Generation:** Comparable to Server-Side rendering on-demand but instead of pre-generating all pages, the server dynamically generates pages when a user requests them. Of course, critical pages are rendered at build time, while others are rendered only when they are requested (deferred).

Pros:
- Content is generated in real-time based on user requests, allowing for personalized, dynamic user experiences.
- Since pages aren't pre-generated and stored, lots of storage is saved, making it efficient, especially for large websites.

Cons:
- The first request for a page might be slower as it's generated on the fly.
- Dynamic content generation can strain servers, especially during high traffic.

**Edge-Side Rendering:** This is more like deploying a mini-rendering station closer to your users. These edge servers, located strategically worldwide, generate web pages on-demand, minimizing latency and offloading the work from servers.

Pros:
- Distance between users and web content is reduced which leads to an almost instantaneous content delivery. 
- Web content can also be tailored based on the user's location and device which translates to a very good user experience.

Cons:
- Availability of edge servers might be sparse in some regions. Users in these areas might face latency issues.
- Configuring and managing edge servers, especially in a distributed environment, can be complex and requires precise setup to function optimally.

**Static Site Generation:** This is compiling an entire website into a set of HTML, CSS, and JavaScript files. Once compiled, these files are served directly to users.

Pros:
- Static sites are incredibly fast. They don't require server-side processing and they serve pre-built HTML files directly.
- Since there isn't server-side processing, security is optimized.

Cons: 
- Managing large static sites with numerous pages can be challenging without the right tools.
- Minimal user interaction.

**Incremental Static Regeneration:** Incremental static regeneration is like having a dynamic cache that updates selectively. Specific pages regenerate on-demand, to ensure the most recent content is always accessible without regenerating the entire site.

Pros: 
- Specific pages update in real-time without regenerating the entire site.
- Frequently accessed pages load swiftly.

Cons: 
- Balancing real-time updates and performance through caching strategies requires careful planning. Mismanagement might lead to serving outdated content.

## When Should You Use The Different Rendering Methods?
Now that we've explored various web page rendering techniques, let's further explore some specific scenarios where each rendering method is best suited.

**Use Client-Side Rendering When:**
- You Need High Interactivity: For applications requiring real-time user interactions and dynamic content loading, CSR provides a responsive user experience.

- The SEO Impact is Mitigated: If SEO is a concern, you can implement techniques like Server-Side Rendering (SSR) for initial page loads and then switch to CSR for subsequent interactions.

**Use Server-Side Rendering When:**
- SEO is a Priority: For websites where search engine visibility is important, SSR ensures that search engines can easily index content and improve your SEO rankings.

- Faster Initial Load Times are Essential: If providing users with a fast, initial loading experience is a priority, SSR delivers pre-rendered HTML directly to the browser.

**Use Pre-rendering When:**
- You Have Content-Heavy Pages: If your website has predominantly static or semi-static content that doesn’t change frequently, pre-rendering is ideal. It ensures fast loading times for these pages.

- SEO is a Priority: Pre-rendered pages are easily indexed by search engines. If search engine visibility is crucial for your website, pre-rendering can boost your SEO efforts.

**Use Deferred Site Generation when:**
- You Require Real-time Data: If your content or data changes frequently and you need to display real-time information to users, generating pages on demand ensures the latest data is always presented.

- Storage Efficiency is Important: For websites with vast amounts of content, generating pages on demand saves storage space since you don’t need to store pre-rendered versions of every page.

**Use Edge Side Rendering When:**

- You Want to Reduce Latency: If your audience is geographically dispersed, using edge servers can significantly reduce latency by serving content from servers closer to the users.

- You Want to Optimize Bandwidth: Edge servers allow you to optimize content for different devices and screen sizes, making the most efficient use of available bandwidth.

**Use Static Site Generation When:**

- Your Content is Mostly Static: For content-centric websites or blogs where the information doesn’t change frequently, static site generation ensures rapid loading and simplicity.

- Security is a Priority: Since there is no server-side processing, static sites have a minimal attack surface that is susceptible to online attacks.

**Use Incremental Static Regeneration When:**

- You Need a Balance Between Real-time Updates and Performance: For websites that need to update specific pages in real-time without compromising overall performance, ISR offers a compromise.

- Caching Strategies are Carefully Managed: Proper caching management ensures that real-time updates don’t conflict with cached content, providing users with both real-time data and optimal performance.

## Popular Frontend Frameworks and Their Default Rendering Types
- React JS: Client-Side Rendering
- Angular JS: Client-Side Rendering
- Vue JS: Client-side Rendering
- Next JS: Server-Side Rendering and Incremental Static Regeneration
- Nuxt JS: Server-Side Rendering and Static Site Generation
- Gatsby: Static Site Generation and Deferred Site Generation

Note: While these are the default rendering methods for these frameworks, you can switch to different rendering methods selectively. For example, in Next JS 13, you can use the "use Client" directive to switch to Client-Side Rendering based on your application needs. 

## Final Thoughts
In a nutshell, understanding Web Page Rendering is like knowing the secret sauce behind every web application. We've explored the basics, why it matters for Frontend Developers, the different methods, and when to use them. It's not about complicated jargon; it's about knowing the right tool for the job.

Now that you understand these techniques, you're not just a developer; you're a creator. With this knowledge, you can craft websites that load fast, interact seamlessly, and rank well on search engines. 

So, this is your cue to start experimenting, and if you have any questions, leave them in the comments. 

Happy coding!