Differences between SSR and SSG

Anton Ioffe - September 24th 2023 - 21 minutes read

In the rapidly evolving landscape of web development, understanding and leveraging the right rendering technique plays a pivotal role in creating proficient, high-functioning websites. As developers continue to choose between Server-Side Rendering (SSR) and Static Site Generation (SSG), this intricate guide presents a comprehensive dissection of these two advanced mechanisms. Designed for seasoned developers looking to delve into the nitty-gritty of SSR and SSG, this article offers an in-depth analysis of both methods, their merits and demerits, and their aptness for specific project requirements.

Playing out as a thorough exploration, this guide will navigate you through the elemental principles and real-world implications of both rendering techniques. Dedicate some time to unraveling the layers of SSR and SSG, discover their comprehensive comparative study and gain insights into their implementation within the fabled Next.js framework. Uncover common coding missteps and their corrections, and take an in-depth look at performance optimization and recognition.

Discover what this detailed walkthrough has to offer, and emerge with a firm understanding and professional command over SSR and SSG, informed enough to effectively choose between, implement and optimize them based on your specific development needs. Read on to refine your knowledge and further your prowess as a modern web developer.

Decoding Server-Side Rendering (SSR)

Server-Side Rendering (SSR) is a web development technique that generates and delivers a complete, fully-rendered HTML page to the user each time a request is made. This approach enables dynamic content and user interaction processed on-the-fly on the server.

Although it might seem straightforward on a high level, the actual rendering process within SSR is more complicated. As a user typically does not wait for the whole page to load at once, rendering has to happen incrementally, leading to a scenario where the browser sends a new request for each unique page, and the server has to generate HTML in response.

How does this process work in real-time? When a request is made, the server will execute the application's JavaScript code to generate the appropriate HTML. This HTML, which includes any elements dynamically generated based off the user request, is then sent back to the client. From the client's perspective, the web page appears pre-populated with all the required data, ready for instant usability.

However, it's crucial to note that this execution of JavaScript code on the server for each request leads to an increased server load. As a site scales up and the traffic increases, the number of page requests grow, and the server's workload escalates proportionally. This heightened workload poses a potential problem for websites that experience high traffic or require real-time updates, impacting the efficiency and the response time of the server.

Despite the workload, SSR proves beneficial for specific real-world use cases, primarily where personalized or unique content is needed for different users. For example, SSR serves as an excellent solution for e-commerce sites where the inventory and prices change frequently, or social media platforms that display individual user timelines.

Used correctly, SSR can significantly enhance your user experience by delivering the entire page with all necessary data, reducing the perceived loading time. However, it's important to always consider the trade-off between user experience and server load. The exact balance will vary based on your application's needs.

In the following section, we will further investigate the advantages and drawbacks of SSR, how they stack up against each other, and the ways to mitigate the challenges. Remember, it's not about completely avoiding problems associated with server load; it's about knowing them beforehand and deciding whether SSR is the right approach for you.

Understanding the Attributes and Constraints of SSR

Server-Side Rendering (SSR) has a unique set of attributes and constraints that distinguish it as a web development technique. Let's dive deep into understanding these characteristics, which have crucial implications on your site's performance, usability, and search engine optimization.

One of the key attributes of SSR is its capability to display dynamic content. By generating HTML on the server, SSR supports real-time updates on your web applications. This feature is highly beneficial for applications with frequently updating data, such as news sites, e-commerce applications, or social media apps. However, it comes with the added complexity of managing dynamic content generation on the server and ensuring its efficient delivery to the client-side.

SSR is SEO-optimized. Since the entire content of the page is delivered to the user's browser upon request, search engines can easily crawl this server-rendered content. SSR helps improve your site's visibility and rankings in search engines, which can significantly boost your site's organic traffic. This, however, means your servers might bear a heavy load, especially with high traffic volumes.

In terms of user experience, SSR offers a faster initial page load time as compared to client-side rendering. When users navigate to your site, they are immediately served the HTML, CSS, and JavaScript. This quick first paint leads to a perceived increase in your website's performance. Though, it's worth noting that the time to interactive page could be longer, as the entire page needs to be ready before it's shipped to the client's browser.

The development complexity is higher with SSR, particularly because of the balancing act between the initial server response and ongoing updates. Further, the code often has to take care of both client-side and server-side, making it less modular than client-side-only applications. It can complicate the process and increase the probability of mistakes, but with prudent practices, it is manageable

Conversely, SSR has a noteworthy constraint. It imposes a consistently high load on the server, primarily due to the real-time HTML generation for each request. This increased server load can result in longer server response times, potentially slowing down your site’s performance, and necessitates a robust server infrastructure.

Moreover, SSR may not be as favorable for applications demanding high interactivity. Since the HTML is re-rendered on the server for every change, SSR might not provide the most performant experience for highly dynamic applications.

In conclusion, SSR brings forth a suite of advantages, including dynamic content abilities, SEO benefits, and superior initial load experience. However, it also has its share of constraints such as higher server loads and performance considerations for highly interactive apps.

With this understanding of SSR’s attributes and constraints, let's juxtapose these findings with another popular rendering approach, Static Site Generation (SSG), in the next section. The aim is to explore the differences that make each technique more suitable in specific scenarios, helping you make informed decisions for your web development needs.

A Comprehensive Study on Static Site Generation (SSG)

Core Principles of SSG

Static site generation (SSG) is governed by robust principles that facilitate efficient website operation and an enhanced user experience.


One of the defining principles of SSG is pre-rendering. Web pages are rendered during the build time, before a user accesses them. This results in a collection of static HTML files that a server can directly deliver to the client, eliminating additional processing time.


The HTML pages generated by SSG are platform-independent, meaning they can be hosted on any environment capable of serving static files. This versatility makes SSG appealing to developers, regardless of their experience level.

Fast and Secure

Because webpages are pre-rendered during the build time, SSG-driven sites tend to be incredibly fast. Reduction of additional server-side processing significantly diminishes potential security vulnerabilities as well.

Operation Process of SSG

The operational process of SSG can be broadly classified into three steps. A comprehensive example using Jekyll, a popular static site generator, is provided:

  1. Create a new Jekyll site.
jekyll new my-awesome-site
  1. Build your site. During this step, the initial code is transformed into static HTML files.
cd my-awesome-site
bundle exec jekyll build

The above commands compile your site and output the result in the _site directory, which holds the ready-to-serve static HTML files. 3. Lastly, serve the static HTML files to the users.

bundle exec jekyll serve

The simplicity and effectiveness of this operational process make SSG particularly valuable for scenarios where website content doesn't update frequently.

Real-World Examples

Blogs and Personal Websites: For instance, consider a blog built with Hugo, another popular static site generator. The majority of blog content remains static over time, which makes it a perfect use case for SSG.

Documentation Sites: Redux, a widely-used JavaScript library for managing application state, uses GitBook (an SSG tool) for its documentation site. Given that updates are relatively infrequent, this setup leverages the benefits of SSG effectively.

Limitations of SSG

Despite numerous advantages, SSG doesn’t fit all use cases. Here are few potential challenges:

  • Lack of Dynamism: Every change, regardless of size, triggers a complete site rebuild. This isn't suitable for sites updated frequently.
  • Not Ideal for Large Websites: For large websites with thousands of pages, the build process can take a considerable amount of time.
  • Limited User Interaction: Since SSG serves pre-built files, real-time user interaction is limited.

A Case for SSG

While SSG might not be a one-size-fits-all solution, it offers indisputable advantages, particularly for static sites having infrequent updates. The allure of fast loading times, robust security, and reduced server workload makes SSG a tool that web developers should strive to understand and master. It’s not panacea but used wisely, SSG is an efficacious method yielding optimal and effective web solutions.

Unveiling the Strengths and Shortfalls of SSG

Static Site Generation (SSG) offers an abundance of advantages, making it a favorable choice for some specific use-cases. But it also carries certain limitations that may not be suitable for specific contexts. In this section, we'll explore the strengths and shortfalls of SSG.

Outstanding Page Performance

One of the standout features of SSG is its potential for superior page performance. When a page is requested, the server already has a statically generated HTML file ready to be served, accompanied by CSS and JavaScript. This results in immensely fast page-load times, offering an enhanced user experience.

The advantage of this is two-fold. On the user side, it significantly boosts the site's user experience by providing speedier page loads. On the developer side, it allows for more straightforward performance optimizations, as the deployed website consists of simple static files.

Strong SEO Potential

Just like its counterpart SSR, SSG provides a solid platform for SEO. The reason is straightforward - search engine bots have an easier time crawling sites that are made up of simple HTML files. Having your site pre-rendered means that all the important metadata, content, and links are already in the HTML when it goes out to the bot, leading to an improved crawl rate and potentially better search engine rankings.

Best Use Cases for SSG

One of the best scenarios to employ SSG is when dealing with websites where content doesn't change frequently. Because the HTML files are generated at build-time, any changes to content would require a rebuild of the site. Hence, SSG works exceptionally well for content that is more 'static' in nature, such as blogs or documentation sites.

SSG also shines when it comes to scalability. Generating static files that can be cached and served directly from a CDN, SSG can cater to a high volume of audience without straining the server resources.

The Downside of SSG

Despite these significant advantages, SSG does have some constraints that may limit its application in certain scenarios. One of the main drawbacks is the build time. For sites with a vast amount of pages, the process to build and regenerate static pages can become increasingly time-consuming, as every page needs to be built individually.

Additionally, catering to dynamic data needs or personalizing content to individual user preferences can become quite challenging with SSG. While some dynamic functionality can be brought in through APIs and external services, it can complicate your overall website structure and developmental efforts.

Gearing Up for Comparison with SSR

Having delved into the strengths and shortfalls of SSG, we are better equipped to differentiate between the two techniques. In the coming sections, we will place SSR and SSG side by side, and explore how they stack up against each other, with respect to various criteria. But before venturing into that, it is crucial to remind ourselves that neither is universally superior. The choice between SSR and SSG ultimately boils down to what do you prioritize - performance, SEO, build-time or real-time updates, and the specifics of the site you are working on.

Stay tuned as we dive into a head-to-head comparison to help you make the most informed decision for your particular needs.

SSR and SSG: A Comparative Analysis

SSR and SSG are two colossal approaches utilized in JavaScript for the generation of content in a web application. Both methodologies generate HTML outputs on the server, which makes them ideal for SEO as they allow for easy crawling and indexing by search engine bots. However, they differ in several key aspects such as speed, server load, user experience, development complexity, and cost-effectiveness. This section will take an in-depth look at these factors and draw a comparison between both approaches.


The difference in speed between SSR and SSG lies primarily in their rendering process. With SSG, the HTML is pre-generated at build time and shipped to the server which generally results in a faster rendering, making it particularly suitable for larger pages. SSR, on the other hand, renders the HTML document for each request at runtime. While this may add some milliseconds to the response time, it provides the benefit of fresh, dynamic content for viewers.

Server Load

SSR may pose a heavier load on the server depending on the number of requests it receives. This is due to the fact that it renders the content on-the-fly for each request. SSG, however, generates pages at build time and serves static HTML files, thereby lowering the server load and offering better scalability. The trade-off lies in the freshness of data - while SSG provides a higher performance, it may not serve the most recent content to users.


While both SSR and SSG are optimal for SEO due to server-side HTML generation, their difference lies in server response time. SSG, with its faster rendering, might provide a slight edge for SEO rankings, especially with larger pages. SSR, however, ensures that viewers see the most current content, which can provide added value for SEO in terms of relevancy and user retention.

User Experience

SSR ensures a more dynamic, interactive user experience as the content is generated on-the-fly, allowing for real-time updates and personalization based on user preferences. On the contrary, SSG presents largely static sites with limited interactivity, unless combined with Client Side Rendering (CSR) or SSR, making it more suited to pages where content updates are infrequent.

Development Complexity

The complexity of implementation varies with the needs of your web application. If your content is static and does not change often, an SSG approach may be simpler to implement. In contrast, if your application relies heavily on dynamic content, SSR may be more appropriate due to its flexibility to generate content at runtime, despite increased potential complexity in development.


In terms of cost-effectiveness, SSG generally has an advantage due to its lower server load and therefore reduced server costs. However, the personalization and real-time updates provided by SSR can potentially drive greater user engagement and retention, resulting in higher indirect profits.

In conclusion, the choice between SSR and SSG hinges on the specific requirements of your web application. Each methodology offers a distinct set of benefits and trade-offs that need to be considered when deciding the most suitable approach for your project. This comparison will hopefully assist you in making the right decision when balancing the needs for speed, server performance, SEO, user experience, development complexity, and cost-effectiveness. It is important to continually evaluate your choice in the long run to adapt to new conditions or requirements for your web application, thereby ensuring optimal performance and overall user satisfaction.

The Decision: SSR or SSG

The crux of the decision between SSR and SSG comes down to a combination of your web application's specific needs and the resources at hand. As you navigate this decision-making process, there are a few pivotal factors to consider. Let's dive into them:

Content Dynamism

The first factor to consider is whether the content on your site shifts frequently or remains relatively static. For fairly static sites, such as blogs or marketing pages, SSG may serve better since it enables faster rendering. This is due to the fact that all necessary data is available at build time and there's no need to fetch data on each request. Consequently, it provides a more excellent performance and SEO outcome.

On the contrary, if your web application deals with dynamic content or needs to present user-specific data, SSR will likely be a better fit. The server-side rendering provided by SSR allows for keeping the page content fresh by enabling data updates on each page request, albeit at a slight trade-off of rendering speed.

Data Update Frequency

How often your website's data changes is another influential factor. With SSR, you can ensure that each page request returns the most recent data, which makes it particularly suitable for websites requiring frequent updates. However, for SSG, this would require a complete rebuild of the site with each data change. Therefore, for sites with infrequent data alterations, SSG is a more feasible option.

Performance Vs. SEO

Another key decision criterion lies between two somewhat conflicting needs: performance and SEO. SSG provides a performance advantage by serving pre-rendered HTML to the user, leading to faster page loads and a better user experience, while still maintaining good SEO. SSR, on the other hand, may slightly compromise on performance but gives better SEO results by allowing search engine bots to crawl and index the pages more effectively.

Specific Scenarios

While SSG and SSR each have their strengths, they're not applicable to all scenarios. For example, if you have a large application with not only continuously changing content but also thousands of pages, ISR (Incremental Static Regeneration) may be a better option to consider. It offers a middle path by allowing you to regenerate individual pages at a time, post-deployment.

In conclusion, there isn't a one-size-fits-all answer to the SSR Vs. SSG question.

Summary: SSG and SSR have their specific advantages and use-cases. In general terms, consider SSG if your site is content-heavy and doesn't need to update frequently. SSR would be a better fit if your content needs frequent updates or includes dynamic data. Remember, midway solutions such as ISR in Next.js can offer a fine balance between SSR and SSG for specific situations. It’s all about finding the best fit for your project’s needs to achieve optimal performance and SEO.

A well-informed analysis of your web application's performance, SEO, and data dynamism requirements will pave the way to the right decision. Are you prepared to make your choice?

Unifying the Powers: SSR and SSG in a Single Application

Harnessing the synergy between Server-Side Rendering (SSR) and Static Site Generation (SSG) in a single application can be both a challenging and rewarding endeavor. This amalgamation allows businesses to capitalize on the respective strengths of each modus operandi, thus enabling a powerhouse of performance and usability.

One important point to remember is the necessity of discerning the distinct serving mechanisms of both SSR and SSG. While SSR renders a page every time a request comes in, SSG pre-builds HTML pages at compile time, serving them flatly upon request. To synergize these fundamentally different techniques, it becomes crucial to strategize the componentual architecture of the application, compartmentalizing dynamic and static content.

The first thing to consider is the nature of the page content. For instance, pages that remain constant and have a low volume of dynamic content are prime candidates for SSG. Conversely, pages that require high data variability and are heavily interactive are best suited to SSR. With a solid understanding of these implications, it's easier to make decisions about where to apply each generation method for optimal results.

// Applying SSG for static content
export async function getStaticProps() {
    const data = staticData(); // Fetch your static data

    return {
        props: { data } // Passing data to the page component

// Applying SSR for dynamic content
export async function getServerSideProps() {
    const data = dynamicData(); // Fetch your dynamic data

    return {
        props: { data } // Passing data to the page component

This strategy amalgamates SSG's performance and SEO benefits with SSR's flexibility in real-time data rendering, resulting in applications that outperform their singularly-rendered counterparts.

But, it comes with its own challenges. Managing data flow across these diverse rendering methods can be tricky. A suitable state-management solution should be an imperative part of your strategy to ensure seamless data transitions.

Optimizing performance across these different modes can also be quite a challenge. Employing a sound caching strategy can greatly alleviate the impact of reloads on frequently accessed dynamic pages.

Hybridization also imposes a higher cognitive load on developers. Deciding which pages should be static and which should be server rendered requires a deep understanding of both methods and the specific project requirements.

What would be the downsides of ignoring certain sections for either SSR or SSG? How would you, as a developer, assess the ideal page rendering method and decide between SSR and SSG for different parts of a project?

This hybrid approach of SSR and SSG, while enticing, requires a keen eye for architectural decisions and a grounded expertise in handling the technical nuances. Nonetheless, when executed meticulously, this can serve as a powerful paradigm, offering businesses the flexibility and performance they need to stay competitive in the ever-evolving digital landscape.

SSR and SSG within Frameworks: A Closer Look at Next.js

Next.js has quickly become one of the dominant frameworks in modern web development, with its impressive support for both SSR and SSG. It provides developers with the flexibility to choose the best rendering strategy suited to specific needs of their applications, or even mix and match as required. This versatility makes it a powerful tool for developers seeking optimal performance and user experience.

Firstly, let's examine how SSR is utilized in Next.js. Used primarily for dynamic content, server-side rendering occurs every time a user makes a request to the server. This makes the website content always up-to-date and responsive to real-time changes.

// The standard way of doing SSR in Next.js is with a function named 'getServerSideProps'
export async function getServerSideProps(context) {
    const res = await fetch(`https://api.example.com/data`);
    const data = await res.json();

    if (!data) {
        return {
            notFound: true,

    return {
        props: { data }, 

In this example, getServerSideProps makes a request to an API endpoint and returns the data as props to the component. This code runs on the server-side every time a client fetches this page.

On the other hand, for static content, SSG is a powerful technique to pre-render pages during build time. In essence, the pages of your website are generated just once at build time and cached, resulting in fast load times for the end user.

// For doing SSG in Next.js, you can use 'getStaticProps' function
export async function getStaticProps() {
    const res = await fetch(`https://api.example.com/data`);
    const data = await res.json();

    return {
        props: {
        revalidate: 60, // This will attempt to regenerate the page when a request comes in, at most once every 60 seconds

In this code snippet, getStaticProps is used to fetch data from API as before, yet this time, the data fetched is static and regenerated at most once every 60 seconds, due to the revalidate keyword, allowing for very efficient and performance optimized pages.

In conclusion, the Next.js framework has comprehensive support for both SSR and SSG, and knowing when to use which technique is crucial to building efficient, high-performing web applications. The use of server-side rendering and static site generation in Next.js is a testament to its flexibility and power, and offers developers a wealth of options when building modern web experiences. By carefully choosing between SSR and SSG based upon the nature of the content being served, developers can significantly enhance page load times, resulting in an improved user experience and potentially, a better Search Engine Optimization ranking.

Common Coding Missteps in SSR and SSG and their Corrections

Common Coding Missteps in SSR and SSG and Their Corrections

As developers start working with Server-Side Rendering (SSR) and Static Site Generation (SSG), a handful of common missteps tend to occur. By going through these mistakes, and the correct practices, we aim to facilitate more efficient and error-free development.

Misguided Network Request Patterns

A frequent problem arises when mismatching network request patterns common to Client-Side Rendering (CSR) are mistakenly used in SSR or SSG. Remember that SSR and SSG send a complete rendered page to the client, not just the chunks of data based on user interactions, which is typical to CSR.

Consider this basic approach to data fetching in CSR:

function App() {
    useEffect(() => {
            .then(data => setAppData(data));
    }, []);
    return <div>{appData.someValue}</div>;

In contrast, SSR and SSG require all necessary data to be ready before the page is rendered. The correct code for such a scenario would be:

async function getServerSideProps() { 
    const res = await fetch('/api/data')
    const appData = await res.json();
    return { props: { data: appData } };

Overlooking the Time of Data Fetching

Many developers overlook the criticality of the timing of data fetching, especially when it involves dynamic data that changes frequently. If SSG is used for fetching data that changes constantly, it may result in a stale and incorrect display, since data changes between builds will not be displayed unless another build occurs.

Incorrect SSG data fetching example, fetching dynamic data:

async function getStaticProps() {
    const res = await fetch('/api/data');
    const appData = await res.json();
    return { props: { data: appData } };

The correction here is to use SSR for content that keeps updating after each user request, ensuring the data is up-to-date.

async function getServerSideProps() {
    const res = await fetch('/api/data');
    const appData = await res.json();
    return { props: { data: appData } };

Misconception Regarding Performance

It's not uncommon for developers to assume that applying SSR or SSG across all pages will offer consistent performance boosts. However, the performance benefits can differ based on the static and dynamic nature of content and their user-specific data. It's crucial to analyze the specific requirements of different parts of your application and choose the fitting rendering strategy accordingly.

Can you isolate parts of your application where static data is served and could thus benefit from SSG? What about dynamic or user-specific parts benefiting from SSR?


By mapping out and correcting these common trip-ups in SSR and SSG, we can deepen our understanding of these techniques and ensure an optimal balance between performance and freshness of data to deliver supreme value to end-users.

Are there other areas in your recent code where you may have applied the inappropriate rendering strategy? If so, how would you correct it now?

SSR and SSG: Identifying and Ensuring Optimal Performance

Recognizing whether a website utilizes SSR or SSG can sometimes be tricky, but there are a few telltale signs developers can look out for. If a site generates pages almost instantly upon a user's request and each page URL contains .html at its end, it is likely leveraging SSG. In contrast, SSR-equipped websites might experience a slight delay in page generation because the server is dynamically generating the HTML.

Now, for achieving optimal performance with either SSR or SSG, there are several best practices to follow. One crucial aspect is reducing the compute time on the server. Fast, efficient server handling not only enhances the user experience by cutting down page load time, but it can also result in significant cost savings for the service maintenance.

When dealing with SSR, be mindful of your application's request-response cycle. Minimizing the data payload and implementing a data caching strategy can help improve the response time. For SSG, significant performance gains can be made by optimizing your build process with mechanisms such as modules/code splitting, incremental builds, and parallelization.

There are also several powerful tools that can help verify whether SSR or SSG is implemented correctly and to measure their performance. Google's Lighthouse, for instance, offers audits for performance, accessibility, SEO, and more, and it's specifically designed to work well with modern web paradigms. Another useful tool is WebPageTest, which provides in-depth information about your site's loading speed and potential bottlenecks.

As web development continues to evolve, one can only speculate how these two techniques will change. Will there be a more profound merge of SSR and SSG? Perhaps, we might see the rise of even more tailored solutions like Incremental Static Regeneration (ISR) offered by Next.js, which amalgamates SSR's dynamism with SSG's performance benefits.

These are exciting questions to think about, and as developers, it is essential to keep a tab on these emerging trends. There's no one-size-fits-all solution in web development; the journey to finding the best approach often involves experimentation, evaluation, and continual learning.

In conclusion, being able to identify a website's rendering technique and understanding how to ensure optimal performance is crucial in the modern web development landscape. Whether you opt for SSR, SSG, ISR, or a hybrid approach, key is to choose a strategy that best suits your application's demands and user expectations. Let's stay tuned and be prepared to embrace the trends shaping the future of web performance.


The article "Differences between SSR and SSG" provides a comprehensive analysis of Server-Side Rendering (SSR) and Static Site Generation (SSG) in modern web development. It discusses the attributes, constraints, advantages, and limitations of both rendering techniques. The article also highlights the use cases, performance considerations, and trade-offs of SSR and SSG. Additionally, it explores the integration of SSR and SSG in a single application and provides insights into using Next.js framework for implementing SSR and SSG.

The key takeaways from this article include:

  1. SSR is suitable for applications requiring real-time updates and personalized content, while SSG is ideal for websites with static content and infrequent updates.
  2. SSR offers a more dynamic and interactive user experience, while SSG provides faster initial page load times and improved SEO.
  3. The choice between SSR and SSG depends on factors such as content dynamism, data update frequency, performance vs. SEO requirements, and specific application needs.

The challenging technical task for the reader is to analyze their own web application and make an informed decision on whether to use SSR or SSG based on the specific requirements of their project. The task involves considering the nature of the content, frequency of data updates, performance and SEO priorities, and evaluating the trade-offs of each rendering technique. The reader is encouraged to understand the strengths and limitations of SSR and SSG, and make a decision that best suits their application's needs for optimal performance and user experience.

Don't Get Left Behind:
The Top 5 Career-Ending Mistakes Software Developers Make
FREE Cheat Sheet for Software Developers