Achieving Seamless Production Readiness

Production Readiness Best Practices
DevOps and Testing Techniques
Kubernetes Resource Management
Infrastructure as Code Automation
Application Performance Monitoring
by Tiziano Perrucci
June 2, 2024


In the software industry, ensuring that an application is ready for production involves a process that includes various stages and components, from initial development to deployment and maintenance. This process, often referred to as the software supply chain, is critical to ensuring that an application can perform reliably in a production environment. This article covers key practices and strategies to make an application production-ready, including build artifacts, testing, versioning, configuration management, secret management, logging, health checks, resource usage, application metrics, security concerns, infrastructure as code, and state backup. These practices are essential for achieving seamless production readiness and ensuring your applications run smoothly and efficiently.

Build Artifacts

The creation of build artifacts is a fundamental part of the DevOps pipeline. These artifacts, which can include libraries, NPM packages, or Docker images, are automatically generated whenever changes are pushed to a branch, master, or tag. Ensuring that artifacts contain only the necessary components is crucial for optimizing performance and security.

The app pipeline can automatically generate artifacts for changes pushed to a branch, master, or a tag. Artifacts can be libraries (Maven or NPM packages) or Docker images.

Artifacts should only contain the necessary elements, this is especially important for images, where we want them to be as small as possible so that we have:

  • Fast builds: Smaller images build faster.

  • Fast uploads and downloads: Smaller artifacts reduce the time needed for uploading and downloading.

  • Reduced security attack surface: Fewer components mean fewer potential vulnerabilities.

Here are some good practices for building Docker images to achieve the above:

  • Use Official Base Images: Use official base images (e.g., from Docker Hub) because they are usually well-maintained, secure, and come with proper configurations.

  • Keep Images Small: Keep images small by only including what is necessary; use Alpine images which are generally very small. Use multi-stage builds to reduce the size of the final image.

  • Use Specific Tags: Always use specific tags so you have control over updates and avoid unexpected changes.

    • For your docker base images: alpine:3.18.5 instead of just alpine

    • For JS libraries: "dayjs": "1.11.7" without ~ or ^ prefix.

    • For JVM libraries: Specify version number and make use of bundling to limit overhead and inconsistencies.

  • Optimize Dockerfile Instructions: Order your Dockerfile instructions to leverage caching. Place frequently changing steps (like copying application code) towards the end of the Dockerfile.

  • Combine RUN Instructions: Combine multiple RUN instructions into a single line to minimize the number of layers created.

  • Remove Unnecessary Files: Remove unnecessary files and artifacts after each step to reduce the overall size of the image. Generally, the package manager can clean its own dependency cache.

  • Create a .dockerignore File: Create a .dockerignore file to exclude unnecessary files and directories from being copied into the image during the build process.

  • Include Only Necessary Dependencies: Only include dependencies required for your application to run, and remove unnecessary packages after installation or build tools that are not needed at runtime.

  • Avoid Running as Root: Avoid running containers as the root user. Create a non-root user in your Dockerfile and use it to run your application for better security.

By sticking to these best practices, you can ensure that your build artifacts are efficient, secure, and optimized for performance. This speeds up the development and deployment process and enhances the overall security and reliability of your application.


Testing is a cornerstone of the software development lifecycle, crucial for identifying and fixing defects. Investing in automated testing helps ensure that software functions as intended and prevents regression issues. Key characteristics of effective tests include:

  • Isolation: Tests should not affect each other.

  • Repeatability: Tests should yield consistent results across different cycles and environments.

  • Readability: Tests should be easy to understand and interpret.

Comprehensive testing encompasses various categories, including functional, non-functional, performance, security, and usability testing.


Effective versioning strategies are vital for tracking changes and ensuring that the exact version of the application running in production can be identified. This enables:

  • Code Traceability: Easily trace back to specific changes.

  • Communication: Facilitate discussions about changes.

  • Rollback: Quickly revert to previous versions if issues arise.

Configuration Management

Applications need to be configured appropriately for different environments (e.g., local, staging, production). Best practices include:

  • Environment Variables: Store configuration settings in environment variables to separate configuration from code.

  • Good Defaults: Set sensible defaults to make local development easier.

  • Strict Separation: Ensure clear separation of configuration from code to avoid hard-coded settings.

Secret Management

Managing secrets such as user credentials, tokens, and keys is critical. Secrets should never be hard-coded and should be managed securely:

  • Centralized Secret Management: Use tools like Doppler to securely store, distribute, and control access to secrets.

  • Regular Rotation: Regularly rotate secrets to minimize the impact of potential breaches.


Effective logging provides insights into application performance and issues. Key elements of logging include:

  • Format: Use consistent formats like plain text or JSON.

  • Timestamp: Include accurate timestamps with time zone information.

  • Log Levels: Categorize log entries by severity (DEBUG, INFO, WARN, ERROR, FATAL).

  • Source and Context: Identify the component generating the log and provide contextual information.

Health Checks

Health checks monitor the ability of an application to perform its tasks. They help ensure reliability and availability by checking critical components like database connections. Proper health checks can inform decisions about restarting or taking an application out of service if issues are detected.

Resource Usage

Capacity planning involves determining the computing resources required to meet current and future demands. The goal is for the system to have enough resources (CPU, memory, storage) to function and account for some extra slack according to predicted patterns (e.g., deployment rollout, one-off jobs).

In Kubernetes, resources are described by defining requests and limits. Requests are used by the scheduler to allocate workload on any available node that can satisfy the workload request, and limits are enforced so that one workload cannot jeopardize the node where it is running. The aim is to avoid over-provisioning resources and preventing wastage and increased costs. This way, you can also ensure predictable performance and efficient cluster utilization.

For more detailed information, see the Kubernetes documentation on resource management.

Application Metrics

Monitoring application metrics is essential for understanding performance and behavior. This involves collecting resource utilization metrics (CPU, memory, storage) and custom business metrics. Tools like Prometheus and Grafana facilitate the collection and visualization of these metrics, providing valuable insights.

Security Concerns

Securing the software supply chain involves several practices:

  • Dependency Scanning: Regularly scan dependencies for vulnerabilities using tools like Snyk.

  • Access Controls: Implement strict access controls based on the principle of least privilege.

  • Infrastructure as Code: Use declarative tools like Terraform and Tanka to automate infrastructure provisioning and deployment, ensuring consistency and repeatability.

State Backup

Automated scheduled backups are crucial for stateful applications to protect against data loss and ensure business continuity. Regular backups help safeguard data, enable quick recovery, and comply with regulatory requirements.


Achieving production readiness involves a comprehensive approach that integrates DevOps and testing practices. By following these essential techniques, teams can ensure their applications are secure, reliable, and capable of handling production demands. At Squads, we have extensive experience in implementing these practices. If you need expert guidance on ensuring your application's production readiness, reach out to us for support.