History of Preview Environments - an Introduction
Web development sure has come a long way.
Web development used to feel more like “the wild west” as developers would write code directly on production servers, hoping that their changes wouldn’t break their website or service. Back then, the lack of proper tools and processes made development a difficult and error-prone task.
But as the industry evolved, developers began to adopt more structured approaches to web development. The concept of version control systems, such as Git and SVN, emerged, which allowed developers to keep track of their code changes over time. But even with these tools, developers still had no way to test their code changes in a safe and isolated environment before pushing the changes to production.
This led to the emergence of “preview environments” - separate testing environments where developers can deploy their code changes and test them without affecting the production environment. Preview environments are isolated from the live environment and provide a safe space for developers to test their code changes and ensure that everything works and looks as intended before deploying them to the production environment.
“Preview environments” come in different forms, such as local preview environments and cloud-based preview environments. Local preview environments are run locally on a developer’s machine, while cloud-based preview environments are run on remote servers. These types of preview environments can provide similar benefits of an isolated environment, but cloud-based environments have the added advantage of being accessible from anywhere, making it easier for remote teams to collaborate on development.
In this article we’ll zoom out and look at the history, evolution and adoption of preview environments. When did they become popular? What caused this shift in the industry? What benefits do they bring teams? What high-profile incidents propelled them into becoming a standard part of development workflows?
Let’s dive in.
Early preview environment solutions
In the early days of web development, developers often made changes directly on the live website, which could result in downtime, errors, or other issues. However, as web applications became more complex and user expectations grew, it became clear that a more structured approach to development and testing was necessary.
In the late 1990s and early 2000s, as the internet developed and web development became more widespread, developers began to adopt local development environments that could be used to test their code before deploying it to the live website. These environments were often simple setups, such as a local web server running on a developer’s machine, but they allowed developers to catch errors and other issues before they became live problems.
In these early days, the modern cloud-based development platforms that we know and love today were not yet available. So local preview environments were created using a combination of web server software and text editors.
However, these early preview environment alternatives had limitations. One major challenge was the complexity of configuring and managing web server software. This could be especially difficult for new developers who were not familiar with the intricacies of web server technology.
Additionally, text editors lacked many of the advanced features and functionality of modern Integrated Development Environments (IDEs). This meant that developers had to manually manage their code, including dependencies and libraries, which could be a tedious and error-prone process. Text editors also lacked sophisticated debugging and code analysis tools that are now common in modern IDEs.
The shift towards cloud and SaaS
As a result of these challenges, developers began to look for more user-friendly and efficient ways to create preview environments. One solution was the development of containerization technologies like Docker, which made it possible to package code and dependencies into self-contained units that could be easily deployed and managed.
Another solution was the development of cloud-based development platforms like GitHub, which provided developers with a range of collaboration, version control, and deployment tools in a single integrated environment. These platforms made it easier for developers to create, test, and deploy code without the need for complex local infrastructure or tools.
The shift towards cloud-based preview environments in web development got a huge boost with the rise of cloud computing and Software as a Service (SaaS) platforms in the early 2000s. As more businesses began to adopt cloud-based infrastructure for their IT needs, developers saw an opportunity to leverage the scalability and flexibility of these platforms to create more efficient and effective development workflows.
One of the earliest cloud-based development platforms was Salesforce.com, which launched in 1999 and offered a range of web-based development tools and services. Other cloud-based platforms followed, including Amazon Web Services (AWS) and Google Cloud Platform (GCP), which provided developers with a wide range of infrastructure and services for building, testing, and deploying web applications.
As the popularity of cloud-based platforms grew, developers began to explore new ways to leverage these platforms for their own development needs. This included the development of containerization technologies like Docker, which made it easier to package and deploy code in a consistent and repeatable way.
Overall, the shift towards cloud-based preview environments was driven by a combination of technological innovation, changing business needs, and the growing complexity of web applications.
High profile incidents that drove preview environment popularity
Sometimes it’s easy to think that an adoption of a new standard (like preview environments) was a natural outgrowth of the technology that evolved around it. Better tech will eventually lead to better tools. But that’s not the story here. Because using preview environments was tantamount to a culture shift in web dev circles, and any good culture shift needs its “culture shock” moments to go with it. And the use of preview environments is no different.
So together with the evolution of the relevant tools and infrastructure, there were several high-profile incidents that made headlines and underscored the lack of and need for preview environments in development workflows. And these news items helped propel the preview environment culture shift that we benefit from today.
One famous example is the story of how a developer named Mike Davidson accidentally deleted the entire Yahoo! homepage while trying to fix a typo. This happened in 2006, when Davidson was a senior vice president of Yahoo! and responsible for the company’s front page. He was using a tool called “vi,” a text editor commonly used by developers, to make the change. Unfortunately, he inadvertently deleted the wrong line of code, which caused the entire page to disappear. Davidson quickly realized what had happened and tried to undo the deletion, but it was too late. The page had already been wiped from the servers. The error went live, and for about an hour, anyone who visited the Yahoo! homepage saw nothing but a blank page. Davidson was able to restore the homepage from a backup, but the incident became infamous as an example of the dangers of working directly on production (mysteriously and ironically, many of the artilcles covering this incident have since been removed from the internet…).
Another story involves the early days of Facebook, when the site was still run out of founder Mark Zuckerberg’s dorm room at Harvard. According to legend, Zuckerberg and his small team would work on the site in real-time, making changes and pushing them live without any testing or quality control. This led to numerous bugs and errors, including one incident where the entire site went down for several hours due to a coding error. While Facebook might have evolved from those early days, the notion that employeed should “Move fast and break things” continued to be one of the core culture pillars of the company for years.
Another incident that helped boost the adoption of preview environments was the deployment of Healthcare.gov by the Obama administration in 2013. When the website launched, it was plagued with performance issues and bugs that made it difficult for users to sign up for health insurance. The root cause of these issues was traced back to a lack of testing and inadequate preview environments, which had resulted in a rushed and poorly planned launch.
The Healthcare.gov incident highlighted the importance of preview environments in web development, and spurred a renewed interest in testing and quality assurance. As a result, many businesses and organizations began investing in preview environments to ensure that their web applications were thoroughly tested and optimized before being deployed to production.
Preview environment advocates
In addition to these incidents, there have been several influential personalities who have helped popularize preview environments in web development. One of the most notable of these personalities is Kent Beck, the creator of Extreme Programming (XP) and one of the pioneers of Agile software development.
Beck has been a vocal advocate for preview environments, arguing that they are essential for effective collaboration and rapid iteration in Agile development workflows. He has also been a key proponent of Test-Driven Development (TDD), which emphasizes the importance of automated testing and preview environments in the software development process.
Another influential personality in the world of preview environments is Jez Humble, the co-author of the book “Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation”. Humble has been a leading voice in the DevOps movement, which seeks to bridge the gap between development and operations teams by emphasizing collaboration and automation.
Humble has argued that preview environments are a key component of successful DevOps workflows, enabling teams to test and deploy code more quickly and efficiently. He has also championed the use of continuous integration and delivery tools, which allow developers to automatically build, test, and deploy code to preview environments as part of their development workflows.
The combination of these incidents and influential personalities like Kent Beck and Jez Humble have helped transform the way that web applications are developed and deployed today, with preview environments as an integral part of the workflow.
The past decade: The growing preview environment trend
Over the past 10 years, the landscape of preview environments in web development has undergone significant changes, driven by advancements in technology and changes in development workflows. These are some of the key trends and developments that have shaped the evolution of the preview environment landscape:
- Shift towards cloud-based environments: One of the most significant trends in the preview environment landscape over the past decade has been the shift towards cloud-based environments. Cloud platforms like AWS, Azure, and Google Cloud have made it easier and more cost-effective for developers to create and manage preview environments, and have enabled greater scalability and flexibility in development workflows.
- Proliferation of specialized tools: As the demand for preview environments has grown, so too has the number of specialized tools available for creating and managing them. Today, there are a variety of tools available for everything from code review and testing to deployment and monitoring, each designed to address specific needs in the development workflow.
- Increased emphasis on automation: Automation has become a key part of modern development workflows, and preview environments are no exception. Many developers now use continuous integration and delivery (CI/CD) tools to automatically build, test, and deploy code changes to preview environments, streamlining the development process and reducing the risk of errors.
- Integration with containerization: Containerization has become increasingly popular in recent years, and preview environments have evolved to integrate with containerization tools like Docker and Kubernetes. This has made it easier for developers to manage complex environments and deploy applications across multiple environments.
- Greater focus on security: With the growing number of cyber threats and data breaches, security has become a top priority for developers. Preview environments have evolved to incorporate security measures like access controls, encryption, and monitoring to protect sensitive data and prevent unauthorized access.
Overall, the evolution of the preview environment landscape over the past 10 years has been characterized by a shift towards cloud-based environments, increased automation, and a greater emphasis on security and specialized tools. These trends are likely to continue in the coming years as development workflows become increasingly complex and the demand for preview environments continues to grow.
Impact on other technologies
There have also been other technologies developed in recent years that have highlighted the benefits of using preview environments in web development. Some examples:
- GitHub’s Dependabot: In 2020, GitHub announced the release of Dependabot, an automated tool that helps developers keep their dependencies up to date. Dependabot uses preview environments to test updates before they are merged into production, helping to catch any issues before they affect end-users. This has helped improve the stability and security of GitHub’s platform and has made it easier for developers to keep their dependencies up to date.
- Facebook’s ”PushGatekeeper”: In the mid 2010’s, Facebook announced the release of PushGatekeeper, a tool that uses preview environments to test changes to the company’s codebase. PushGatekeeper automatically creates a preview environment for each change, allowing developers to test their changes in a safe and isolated environment before they are merged into the main codebase. This has helped improve the quality and stability of Facebook’s platform and has made it easier for developers to collaborate on code changes.
These examples show how the industry has been trending towards preview environment-like technologies that can help improve the quality, stability, and security of web applications.
Today’s preview environment landscape
Today developers have a seemingly endless set of preview environment solutions to choose from, each with its unique features and strengths.
Some of the most popular preview environment solutions include GitHub Pages, Netlify, Heroku, Firebase Hosting, and Vercel. Lesser-known preview environment solutions include platforms such as Render, Amplify, Azure Static Web Apps, open source solutions such as Preevy and many other alternatives that make up a list too long to include here in a single paragraph. are
Preview environments are even better than we thought
While the initial motivations for using preview environments were basically to avoid breaking things in production, development teams around the word have come to appreciate many other benefits that preview environments bring to the table:
- Improved testing and debugging: Preview environments provide a safe and isolated environment for testing and debugging code changes before they are deployed to production. This helps developers catch errors early on in the development process, reducing the risk of costly bugs or downtime in production.
- Increased productivity: Preview environments can help streamline the development process by allowing developers to test code changes quickly and easily. This can lead to faster feedback loops, allowing developers to make changes more efficiently and get their code to production faster.
- Enhanced security: Preview environments can help improve security by allowing developers to test code changes in an isolated environment, separate from production systems. This reduces the risk of security vulnerabilities and can help prevent unauthorized access to sensitive data.
- Code quality: Preview environments can help improve code quality by allowing developers to catch errors and issues earlier in the development cycle, reducing the likelihood of bugs and other problems in production.
- Learning opportunities: Preview environments can provide opportunities for developers to learn new skills and technologies, as they can experiment with different tools and approaches without fear of breaking anything in production.
- Infrastructure management: Preview environments can help organizations better manage their infrastructure by allowing them to test and evaluate new infrastructure configurations or changes before deploying them to production.
- Collaboration: Preview environments can make it easier for teams to collaborate on code changes by providing a shared environment for testing and reviewing changes. This can help ensure that all team members are working with the same code and can provide feedback more quickly and efficiently.
- Better scalability: Preview environments can be scaled up or down as needed to accommodate changes in development needs or traffic levels. This can help ensure that development environments are always optimized for the task at hand, without wasting resources on unused infrastructure.
In fact, these additional, recognized benefits of preview environments in development workflows have enabled us here at Livecycle to build an entire collaboration and communication tool for development teams based on the preview environment paradigm.
Overall, using preview environments can bring a range of benefits beyond just improving the deployment process. By providing a safe and isolated environment for testing and debugging, increasing productivity, enhancing security, facilitating collaboration, and enabling better scalability, preview environments can help streamline the development process and make it easier for teams to build high-quality applications.
The evolution of preview environments has revolutionized the way web developers work, enabling them to create and test new features with greater speed and efficiency while minimizing the risk of problems in production.
From the early days of broken production environments, local development environments and manual testing, we can say that with preview environments, web development has indeed come a very long way.