In DevOps, separating work into different environments is essential for smooth development, testing, and deployment. This chapter introduces you to the main types of environments you will encounter, such as development, testing, staging, and production. You will learn what each environment is used for, why they matter, and how they help ensure your applications are reliable and ready for users. By the end of this chapter, you will understand how these environments fit into a typical DevOps workflow and why environment separation is a key practice for successful software delivery.

Development Environment

The development environment is where you write and initially test your code. This environment is designed for rapid changes and experimentation. Its main purpose is to give you a safe space to build new features, fix bugs, and try out ideas without affecting other environments or users.

Typical activities in the development environment:

• Writing new code and implementing features;
• Performing initial testing to check if code works as expected;
• Debugging and troubleshooting errors;
• Experimenting with solutions before moving code forward.

You can freely make changes in the development environment, knowing that mistakes or failures here will not impact live applications or other team members’ work.

Testing Environment

The testing environment is a dedicated space where you run more formal tests to identify bugs and issues before releasing software to users. This environment is designed to closely mimic the production environment but is isolated to prevent any impact on real users or data.

Main purposes:

• Detect and resolve bugs;
• Validate that new code works as intended;
• Ensure that integrations between components do not break existing functionality.

Typical activities:

• Integration testing to check how different modules work together;
• System testing to verify the complete application’s behavior;
• Quality assurance (QA) to confirm the software meets specified requirements.

You use the testing environment to ensure your application is stable, reliable, and ready for further stages like staging or production.

Staging Environment

The staging environment is a dedicated space that acts as a pre-production replica of your production system. Its main purpose is to provide a realistic environment for final testing before releasing changes to users. Staging should closely mirror your production setup, including hardware, software, configurations, and data (with sensitive data sanitized).

Key activities performed in the staging environment include:

• User acceptance testing (UAT);
• Performance and load testing;
• Final verification of deployments and configurations;
• Checking integration with external services;
• Ensuring that new features or fixes behave as expected without impacting real users.

By using a staging environment, you can catch issues that might only appear under production-like conditions, reducing the risk of introducing problems to your live system.

Production Environment

The production environment is where your live application runs and is accessed by end users. This is the final stage of deployment, where real data is processed and actual business operations occur.

Main characteristics:

• Hosts the live version of your application;
• Exposed to real users and handles genuine traffic;
• Requires the highest level of stability, security, and performance.

Typical activities:

• Monitoring application health and performance;
• Performing regular maintenance to ensure uptime;
• Handling incidents and responding to issues affecting live users.

Any changes made in the production environment must be carefully planned and tested in advance to avoid disrupting the user experience.

Code Change Flow Example

Suppose you fix a bug in your application by updating a function in a file called app.py. Here is how the change moves through each environment:

1. Development Environment:

   • You edit app.py on your local machine.
   • You run the application locally to confirm the bug is fixed;
   • You commit the change to your version control system (such as Git);
   • You push the code to the shared development branch.

2. Testing Environment:

   • Automated tests run on the new code in a dedicated test environment;
   • Testers manually verify the bug fix using the updated application;
   • If issues are found, you update the code and repeat the process.

3. Staging Environment:

   • The approved code is deployed to a staging environment that closely mirrors production;
   • The team performs final checks to ensure everything works as expected;
   • Performance and security tests are often run here.

4. Production Environment:

   • The tested and approved code is deployed to the live production environment;
   • End users now experience the bug fix in the application.

This flow ensures that only stable, tested changes reach your production system.