Backend Development Workflows: Docker Tools & Best Practices

Backend development workflows have evolved significantly with containerization and cloud technologies, with Docker emerging as the cornerstone for modern development environments. Backend developers now leverage Docker containers to create isolated, reproducible local setups that mirror production environments, enabling consistent development experiences across teams while eliminating “works on my machine” problems.

Contents

• The Evolution of Backend Development Workflows
• Essential Tools for Modern Backend Development
• Docker Containers in Backend Development
• Setting Up Local Development Environments
• Backend Development Workflow Best Practices
• Working with Servers and Production Environments
• Testing and Quality Assurance in Backend Development
• Deployment and CI/CD Integration
• Monitoring and Maintenance
• Future Trends in Backend Development

The Evolution of Backend Development Workflows

Backend development has undergone a remarkable transformation over the past decade, shifting from monolithic server setups to containerized microservices architectures. This evolution has fundamentally changed how developers approach their daily workflows, environment configurations, and deployment processes.

In the early days of web development, backend developers typically worked directly on physical servers or virtual machines, often facing challenges with environment inconsistencies and dependency conflicts. The workflow involved SSH connections to remote servers, manual installations of dependencies, and complex configuration management that often led to “works on my machine” scenarios.

The introduction of Docker revolutionized this approach by providing lightweight, portable containers that package application code with its dependencies. This paradigm shift enabled developers to create consistent environments across development, testing, and production stages. According to the official Docker documentation, containerization allows for separation of concerns, where each service can be developed, tested, and deployed independently.

Modern backend development workflows now embrace DevOps principles, integrating development, operations, and quality assurance into seamless processes. These workflows prioritize automation at every stage, from local development to production deployment, ensuring faster delivery cycles and higher code quality.

Essential Tools for Modern Backend Development

A well-equipped backend developer’s toolkit contains a carefully selected set of tools that address different aspects of the development lifecycle. These tools streamline processes, improve productivity, and ensure code quality throughout the development workflow.

Core Development Tools

At the foundation of any backend development setup are core programming language tools and IDEs. The choice of these tools often depends on the backend technology stack being used. For JavaScript/Node.js developers, Visual Studio Code with extensions like Docker and MongoDB integration provides a comprehensive development experience. For Python developers, PyCharm offers robust support for Django, Flask, and other frameworks.

Database management tools form another critical component of the backend toolkit. Tools like DBeaver, DataGrip, or the built-in database interfaces in IDEs allow developers to interact with databases efficiently. These tools provide query editors, schema visualization, and data manipulation capabilities that significantly speed up database-related development tasks.

API Development Tools

API development represents a substantial portion of backend work, and specialized tools have emerged to streamline this process. Postman and Insomnia enable developers to test and document REST APIs with ease, while Swagger helps create interactive API documentation that developers can share with frontend teams.

For GraphQL development, tools like Apollo Studio and GraphQL Playground provide specialized environments for schema design and query testing. These tools often include features for real-time collaboration, making them valuable in team environments.

Version Control and Collaboration

Version control remains non-negotiable in modern backend development workflows. Git, with platforms like GitHub, GitLab, or Bitbucket, provides the foundation for code collaboration. Beyond basic version control, these platforms offer pull request workflows, code review processes, and integration with CI/CD pipelines.

The Pesto Tech resource highlights that effective collaboration tools are essential for backend teams, enabling seamless integration of code changes while maintaining code quality standards.

Docker Containers in Backend Development

Docker containers have become the standard approach for backend development environments, offering unprecedented consistency and flexibility. By packaging applications and their dependencies into isolated containers, developers can create reproducible environments that eliminate common “works on my machine” problems.

Container Architecture Fundamentals

At its core, Docker containerization leverages Linux kernel features to create isolated environments that contain everything needed to run an application. This includes the application code, runtime, system tools, libraries, and settings. The official Docker documentation emphasizes that containers should be stateless and disposable, following Twelve-Factor App principles.

One of the most powerful aspects of Docker is its layered architecture, which allows for efficient image creation and sharing. Each Dockerfile instruction creates a new layer in the image, and Docker can reuse these layers across different images, significantly reducing storage requirements and build times.

Multi-Container Applications

Modern backend applications rarely consist of a single component. Instead, they typically involve multiple services working together—databases, caches, message queues, and API servers. Docker Compose simplifies the orchestration of these multi-container applications by allowing developers to define all services in a single YAML file.

According to practical experience shared in the Docker for Beginners guide, a typical backend development setup using Docker Compose might include:

• An application container running the backend service
• A database container (PostgreSQL, MySQL, or MongoDB)
• A cache container (Redis or Memcached)
• A message queue container (RabbitMQ or Kafka)

This approach ensures that each service runs in its own isolated environment with its own dependencies, preventing conflicts and simplifying maintenance.

Image Optimization Best Practices

Creating efficient Docker images is crucial for both development and production environments. The official Docker documentation recommends using multi-stage builds to separate build and runtime layers, producing smaller, cleaner images. This approach allows developers to include build dependencies in early stages while keeping only the necessary runtime components in the final image.

Another best practice is using .dockerignore files to exclude unnecessary files and directories from the build context, reducing image size and improving build performance. Additionally, using specific image tags rather than latest ensures reproducibility and prevents unexpected changes in dependencies.

Setting Up Local Development Environments

Creating an effective local development environment is perhaps the most critical aspect of a smooth backend development workflow. A well-configured local setup allows developers to work efficiently while ensuring that their changes will work consistently across different machines and eventually in production.

Docker-Based Local Environments

The modern approach to local backend development involves Docker containers that mirror production environments. This method addresses several traditional pain points: dependency conflicts, database setup complexity, and environment inconsistencies. As explained in the blog post about Docker local environments, Docker solves “terminal hell” by packaging each service in its own container and orchestrating them with docker-compose.

A typical Docker-based local development setup includes:

1. Volume Mounts: Bind-mount source code into containers to enable hot-reloading during development. This allows changes made on the host machine to be immediately reflected in the running container without requiring rebuilds.

2. Isolated Services: Each component (database, cache, application) runs in its own container, preventing dependency conflicts and allowing independent scaling and configuration.

3. Environment Variables: Use .env files to manage environment-specific configurations without hardcoding values in the application or Docker files.

4. Docker Compose: A single docker-compose.yml file defines the entire application stack, making it easy for any developer to get started with docker-compose up.

Database Management in Local Environments

Database setup represents one of the most complex aspects of backend development. Docker simplifies this by providing official images for popular databases like PostgreSQL, MySQL, MongoDB, and Redis. These images can be customized with initialization scripts, environment variables, and data volumes.

One significant advantage of containerized databases is the ability to create isolated instances for each developer. As noted in the beginner’s guide, using separate database containers eliminates migration conflicts and ensures that each developer works with their own independent data state.

For database migrations, most backend teams use versioned migration files that can be applied consistently across environments. These migrations are typically stored in version control and applied automatically when containers start, ensuring schema consistency.

IDE Integration and Development Experience

Integrating development tools with Docker containers creates a seamless development experience. Modern IDEs like Visual Studio Code offer Docker extensions that allow developers to manage containers directly from the interface, including starting, stopping, and inspecting containers.

Hot-reload capabilities are essential for efficient development. For Node.js applications, tools like nodemon can be configured to restart the application when files change. For compiled languages like Go or Java, file watchers can trigger rebuilds and container restarts automatically. The Docker local environment guide explains that this hot-reload functionality is achieved through volume mounts combined with appropriate watchers inside containers.

Backend Development Workflow Best Practices

Establishing consistent workflows is essential for maintaining productivity and code quality in backend development. These best practices span the entire development lifecycle, from initial setup to deployment and maintenance.

Code Organization and Structure

A well-organized codebase facilitates easier maintenance, collaboration, and scaling. Modern backend applications typically follow modular architectures that separate concerns into distinct modules, services, or microservices. The API documentation guide emphasizes the importance of clear project structures that make the codebase navigable and maintainable.

Key principles for effective code organization include:

• Separation of business logic from data access and presentation layers
• Clear naming conventions that reflect the purpose and function of components
• Consistent error handling patterns across the application
• Modular design that allows components to be developed and tested independently

Testing Strategies

Testing forms a critical component of modern backend development workflows. A comprehensive testing strategy typically includes unit tests, integration tests, and end-to-end tests, each addressing different aspects of the application’s functionality.

Unit tests focus on individual components in isolation, mocking external dependencies to ensure predictable behavior. Integration tests verify that different components work together correctly, while end-to-end tests validate entire user flows from the frontend through the backend to the database.

Modern development practices emphasize testing early and often. Tools like Jest for JavaScript, PyTest for Python, and JUnit for Java provide robust frameworks for writing and running tests. Continuous integration pipelines automatically run these tests on every code change, preventing broken code from entering the main branch.

Code Review and Quality Assurance

Code review ensures that code meets team standards and catches potential issues before they become problems. Modern platforms like GitHub, GitLab, and Bitbucket provide pull request workflows that facilitate code review with inline comments, discussions, and approval processes.

Beyond traditional code review, static analysis tools can automatically detect code quality issues, security vulnerabilities, and performance problems. Tools like SonarQube, ESLint, and Pylint integrate into development workflows to provide immediate feedback on code quality.

The Pesto Tech resource highlights that backend development tools should include static analysis capabilities to maintain code quality and catch issues early in the development process.

Working with Servers and Production Environments

Transitioning from local development to production servers requires careful consideration of security, performance, and maintainability. Backend developers must understand how to configure, deploy, and maintain servers that host their applications.

Server Configuration and Hardening

Production server configuration goes beyond simply deploying the application. It involves hardening the server against security threats, optimizing performance, and ensuring reliability. Key aspects of server configuration include:

1. Security Measures: Implementing firewalls, SSH key authentication, regular security updates, and intrusion detection systems. The principle of least privilege should guide all server access configurations.

2. Performance Optimization: Configuring appropriate resource allocations, implementing caching strategies, and optimizing database queries to ensure the application performs well under load.

3. Monitoring and Logging: Setting up comprehensive logging and monitoring systems that provide visibility into application performance and system health.

4. Backup and Recovery: Implementing automated backup strategies and testing recovery procedures to ensure data protection and business continuity.

Container Orchestration in Production

For containerized applications, orchestration platforms like Kubernetes or Docker Swarm manage container deployment, scaling, and networking in production environments. These platforms provide features like:

• Service Discovery: Automatically registering and discovering services within the cluster
• Load Balancing: Distributing traffic across multiple instances of services
• Auto-scaling: Automatically adjusting the number of running instances based on demand
• Rolling Updates: Deploying new versions without downtime by gradually replacing old instances

The official Docker documentation provides guidance on container best practices that apply specifically to production environments, emphasizing statelessness, resource efficiency, and security considerations.

Environment Management Strategies

Managing different environments (development, staging, production) requires careful planning to ensure consistency while allowing environment-specific configurations. Common strategies include:

1. Configuration Management: Using environment variables, configuration files, or dedicated configuration management tools to separate environment-specific settings from application code.

2. Infrastructure as Code: Defining server configurations and deployment processes in code using tools like Terraform, Ansible, or CloudFormation. This approach ensures reproducibility and version control of infrastructure configurations.

3. Blue-Green Deployments: Maintaining two identical production environments and switching traffic between them to enable zero-downtime deployments.

4. Feature Flags: Using feature flags to control the rollout of new functionality without deploying new code, allowing for gradual releases and quick rollbacks if issues are detected.

Testing and Quality Assurance in Backend Development

Testing forms an integral part of modern backend development workflows, ensuring code quality, preventing regressions, and validating application functionality. A comprehensive testing strategy addresses multiple levels of application behavior and integration.

Unit Testing Fundamentals

Unit tests focus on testing individual components or functions in isolation, mocking external dependencies to ensure predictable and repeatable results. These tests should be fast, reliable, and provide immediate feedback on code changes.

For backend applications, unit tests typically cover:

• Business logic validation
• Data transformation functions
• Error handling mechanisms
• Utility functions and helpers

Modern testing frameworks like Jest (JavaScript), PyTest (Python), and JUnit (Java) provide robust assertion libraries and mocking capabilities that make writing effective unit tests straightforward. The best practice is to maintain high test coverage for business logic, ensuring that critical functionality is thoroughly tested.

Integration Testing

Integration tests verify that different components of the application work together correctly. Unlike unit tests, integration tests involve multiple components and often require real dependencies like databases or external services.

Key areas covered by integration tests include:

• API endpoint validation
• Database interaction and data persistence
• Authentication and authorization flows
• Communication between microservices

For containerized applications, integration tests can run against Docker containers that mirror production environments, ensuring that tests reflect real-world conditions. The API documentation guide emphasizes that integration tests should cover the most critical user flows and data exchanges between components.

Performance and Load Testing

Performance testing ensures that the application can handle expected traffic loads without degradation in response times or system stability. This type of testing answers questions about how the application behaves under stress and identifies potential bottlenecks.

Performance testing typically involves:

• Load testing: Simulating expected user traffic to measure system performance
• Stress testing: Pushing the system beyond its expected limits to identify breaking points
• Capacity testing: Determining how much traffic the system can handle before performance degrades
• Scalability testing: Verifying that the system can scale horizontally to handle increased load

Tools like JMeter, k6, and Gatling provide sophisticated capabilities for simulating realistic user loads and measuring system responses. Modern development practices integrate performance testing into CI/CD pipelines to catch performance regressions early.

Security Testing

Security testing identifies vulnerabilities in the application before they can be exploited by malicious actors. This type of testing should be an integral part of the development process rather than an afterthought.

Common security testing approaches include:

• Static Application Security Testing (SAST): Analyzing source code for security vulnerabilities
• Dynamic Application Security Testing (DAST): Testing running applications for security flaws
• Dependency scanning: Identifying vulnerabilities in third-party libraries and packages
• Penetration testing: Simulating attacks to identify exploitable weaknesses

Modern development tools integrate security scanning directly into the development workflow, providing immediate feedback on security issues. The Pesto Tech resource highlights that security testing should be automated and performed continuously throughout the development lifecycle.

Deployment and CI/CD Integration

Modern backend development workflows rely heavily on automation for deployment processes, reducing manual errors and accelerating delivery cycles. Continuous Integration and Continuous Deployment (CI/CD) pipelines form the backbone of these automated workflows.

Continuous Integration Basics

Continuous Integration automates the process of building, testing, and validating code changes whenever developers push code to the repository. The core principles of CI include:

1. Automated Builds: Every code change triggers an automated build process that compiles the application and creates deployable artifacts.
2. Automated Testing: The pipeline runs a comprehensive suite of tests (unit, integration, security) to validate code quality.
3. Feedback Loop: Developers receive immediate feedback on build status and test results, allowing them to fix issues quickly.

Modern CI platforms like GitHub Actions, GitLab CI, Jenkins, and CircleCI provide sophisticated capabilities for defining complex build and test workflows. These platforms can containerize applications, run tests in isolated environments, and generate deployment artifacts automatically.

Deployment Strategies

Effective deployment strategies ensure that new features reach users with minimal disruption and maximum reliability. Several proven approaches have emerged in modern backend development:

1. Rolling Updates: Gradually replacing old instances with new ones, maintaining availability throughout the deployment process. This approach works well for stateless applications running in container orchestration platforms like Kubernetes.

2. Blue-Green Deployments: Maintaining two identical production environments and switching traffic between them. This strategy enables zero-downtime deployments and quick rollbacks if issues are detected.

3. Canary Releases: Deploying new versions to a small subset of users initially, monitoring performance and behavior before gradually rolling out to the entire user base.

4. Feature Flags: Using feature toggles to control the rollout of new functionality without deploying new code, allowing for gradual releases and quick rollbacks.

The API documentation guide emphasizes that deployment strategies should align with business requirements, risk tolerance, and release frequency.

Infrastructure as Code

Infrastructure as Code (IaC) represents a fundamental shift in how infrastructure is managed, treating server configurations and deployment processes as code that can be version controlled, tested, and deployed alongside application code.

Popular IaC tools include:

• Terraform: For defining and provisioning infrastructure across multiple cloud providers
• Ansible: For configuration management and application deployment
• CloudFormation: For AWS-specific infrastructure definitions
• Docker Compose: For defining multi-container applications

IaC provides several key benefits:

• Consistency: Ensures that environments are identical across development, testing, and production
• Reproducibility: Makes it easy to recreate environments from scratch
• Version Control: Tracks changes to infrastructure over time
• Automation: Enables automated provisioning and configuration of environments

The official Docker documentation recommends using Docker in conjunction with IaC tools to create comprehensive automation for deployment workflows.

Monitoring and Observability in CI/CD

Modern CI/CD pipelines integrate monitoring and observability tools to provide visibility into application performance and user experience after deployment. This integration allows teams to quickly identify and address issues that arise in production.

Key observability practices include:

• Application Performance Monitoring (APM): Tracking application metrics, transaction traces, and error rates
• Logging Centralization: Collecting and analyzing logs from all components in one place
• Distributed Tracing: Following requests as they flow through microservices to identify bottlenecks
• Alerting: Configuring automated alerts based on predefined thresholds and patterns

By integrating these observability practices into CI/CD pipelines, teams can create feedback loops that inform development decisions based on real production data.

Monitoring and Maintenance

Once applications are deployed, ongoing monitoring and maintenance ensure continued reliability, performance, and security. Modern backend development workflows treat monitoring as an integral part of the development lifecycle rather than an operational afterthought.

Application Performance Monitoring

Application Performance Monitoring (APM) provides insights into how applications perform in production, helping identify bottlenecks, errors, and areas for optimization. Modern APM tools offer features like:

1. Real-time Metrics: Dashboards displaying key performance indicators such as response times, error rates, and throughput
2. Transaction Tracing: Detailed views of individual requests as they flow through the application
3. Dependency Mapping: Visualization of how different components interact with each other
4. Anomaly Detection: Automated identification of unusual performance patterns that may indicate issues

Popular APM tools include New Relic, Datadog, and Dynatrace, each offering comprehensive monitoring capabilities for backend applications. The integration of APM into development workflows allows teams to make data-driven decisions about performance optimization.

Logging Strategies

Effective logging provides visibility into application behavior and is essential for troubleshooting issues. Modern logging strategies focus on structured logging, correlation, and centralized management:

1. Structured Logging: Using JSON or other structured formats rather than plain text logs, making them easier to parse and analyze
2. Log Correlation: Including unique identifiers across logs from different components that make up a single request
3. Centralized Logging: Aggregating logs from all components into a single system for unified analysis
4. Log Retention and Rotation: Implementing policies for managing log storage and preventing disk space issues

Tools like the ELK Stack (Elasticsearch, Logstash, Kibana), Splunk, and Graylog provide powerful capabilities for log management and analysis. The API documentation guide emphasizes that logging should be designed with troubleshooting in mind, including sufficient context to diagnose issues effectively.

Security Monitoring and Maintenance

Security monitoring goes beyond traditional application monitoring to detect potential security threats and vulnerabilities. Key aspects of security monitoring include:

1. Vulnerability Scanning: Regular scanning of applications and dependencies for known security vulnerabilities
2. Intrusion Detection: Monitoring for unusual patterns that may indicate security breaches
3. Access Control Auditing: Tracking and reviewing access to sensitive systems and data
4. Compliance Monitoring: Ensuring that systems meet regulatory requirements and standards

Modern security tools integrate with development workflows to provide early detection of security issues. The Pesto Tech resource highlights that security should be a continuous process rather than a one-time assessment, with regular updates and monitoring.

Maintenance and Updates

Regular maintenance ensures that applications remain secure, performant, and compatible with evolving technologies. Key maintenance activities include:

1. Dependency Updates: Regularly updating third-party libraries and frameworks to patch security vulnerabilities and access new features
2. Performance Tuning: Optimizing database queries, caching strategies, and resource allocation based on monitoring data
3. Capacity Planning: Scaling infrastructure resources to accommodate growth in user traffic and data volume
4. Documentation Updates: Keeping technical documentation, API references, and runbooks current with application changes

Modern development practices emphasize automation for maintenance tasks, reducing manual effort and minimizing the risk of errors. Container orchestration platforms like Kubernetes provide automated scaling and self-healing capabilities, reducing the need for manual intervention.

Future Trends in Backend Development

The field of backend development continues to evolve rapidly, with new technologies, methodologies, and best practices emerging regularly. Staying informed about these trends is essential for backend developers who want to build efficient, scalable, and maintainable systems.

Serverless Architecture and Function-as-a-Service

Serverless architecture represents a fundamental shift in how applications are designed and deployed. Rather than managing servers, developers focus on writing individual functions that execute in response to events. This approach offers several advantages:

1. Reduced Operational Overhead: No need to manage server infrastructure, allowing developers to focus on code
2. Automatic Scaling: Functions scale automatically based on demand, optimizing resource usage
3. Cost Efficiency: Pay only for actual compute time used rather than provisioned capacity
4. Faster Development: Simplified deployment process allows for rapid iteration and experimentation

Popular serverless platforms include AWS Lambda, Google Cloud Functions, and Azure Functions. While serverless isn’t suitable for all applications, it excels for event-driven workloads, microservices, and applications with variable traffic patterns.

Edge Computing and Distributed Systems

Edge computing brings computation and data storage closer to the source of data generation, reducing latency and improving performance for distributed applications. This trend is particularly important for applications that require real-time processing, such as IoT devices and mobile applications.

Key aspects of edge computing include:

• Distributed Processing: Spreading computation across multiple locations rather than concentrating it in central data centers
• Edge Gateways: Intermediate devices that preprocess and filter data before sending it to central systems
• Offline Capabilities: Applications that can function with limited or no connectivity
• Data Privacy: Processing sensitive data locally to reduce transmission risks

The evolution of edge computing is driving changes in backend architecture, with more applications adopting hybrid approaches that combine centralized cloud resources with edge processing capabilities.

AI and Machine Learning Integration

AI and machine learning are becoming integral components of backend systems, enabling intelligent features and automation. Backend developers increasingly need to understand how to integrate AI capabilities into their applications:

1. Model Serving: Deploying and managing machine learning models that provide predictions or classifications
2. Data Processing Pipelines: Building systems that prepare and transform data for ML training and inference
3. Real-time Inference: Creating APIs that provide ML predictions with low latency
4. Model Monitoring: Tracking model performance and detecting drift over time

Tools like TensorFlow Serving, MLflow, and Kubeflow provide specialized capabilities for managing ML workflows in production environments. The integration of AI into backend systems is creating new opportunities for innovation and differentiation.

DevSecOps and Security by Design

DevSecOps extends the DevOps philosophy to include security throughout the development lifecycle, rather than treating it as a separate phase. This approach emphasizes:

1. Shift Left Security: Integrating security testing early in the development process
2. Infrastructure Security: Applying security controls to infrastructure-as-code definitions
3. Runtime Protection: Implementing security controls that protect applications during execution
4. Compliance Automation: Using automation to ensure regulatory requirements are met

The official Docker documentation highlights security as a fundamental consideration in containerized environments, emphasizing that security should be designed into systems rather than added as an afterthought.

Low-Code/No-Code Integration

Low-code and no-code platforms are enabling business users to create backend functionality without traditional programming, changing the role of backend developers. These platforms provide visual interfaces for:

1. API Creation: Building APIs through visual configuration rather than code
2. Workflow Automation: Creating business processes that integrate multiple systems
3. Data Integration: Connecting and transforming data from various sources
4. Application Logic: Defining business rules and conditional logic visually

While low-code platforms won’t replace traditional backend development, they are changing how backend developers spend their time—with more focus on complex integrations, performance optimization, and system architecture rather than routine business logic implementation.

Sources

1. Docker Documentation - Best Practices
2. Docker Local Environment Guide
3. Docker for Beginners: Crafting Your Backend Development Environment
4. Top 10 Must-Have Tools for Backend Developers
5. A Complete Guide on Backend Development Process

Conclusion

Backend development workflows have evolved dramatically with the adoption of containerization, automation, and cloud technologies. The most convenient modern workflows leverage Docker containers to create consistent, reproducible development environments that mirror production systems, eliminating common configuration conflicts and environment inconsistencies.

Effective backend development requires a comprehensive toolkit that addresses every aspect of the development lifecycle—from initial coding and testing through deployment and maintenance. Tools like Docker Compose for local development, CI/CD platforms for automation, and monitoring systems for observability form the foundation of modern backend workflows.

Best practices emphasize separation of concerns, with each service running in its own container, clear environment configurations, and comprehensive testing strategies. The integration of security and performance considerations throughout the development lifecycle ensures that applications are not only functional but also secure and performant.

As technology continues to evolve, backend developers must stay informed about emerging trends like serverless architecture, edge computing, and AI integration. These technologies are reshaping how backend systems are designed and deployed, creating new opportunities for innovation and efficiency.

Ultimately, the most successful backend development workflows balance technical excellence with business needs, creating systems that are not only well-engineered but also deliver real value to users and organizations. By adopting modern tools and practices, backend developers can build systems that are scalable, maintainable, and ready to meet the challenges of tomorrow’s digital landscape.