# Akash Console Development Workflow Tools: Docker Compose and Turbo Repo Guide > Master Akash Console development with Docker Compose and Turbo Repo. Streamline your workflow and run the full stack locally with simple npm commands. - Repository: [Akash Network/console](https://github.com/akash-network/console) - Tags: how-to-guide - Published: 2026-02-24 --- **Akash Console leverages Docker Compose for containerized local development and Turbo Repo for monorepo task orchestration, enabling developers to spin up the entire stack—including the console UI, API, indexer, and PostgreSQL—with single npm commands.** The `akash-network/console` repository is a complex monorepo containing multiple applications and services that require coordinated development workflows. Understanding the **Akash Console development workflow tools** is essential for contributors who need to run the console UI, stats UI, API, and indexer services simultaneously. This guide examines the Docker Compose configuration files and Turbo Repo pipeline that define the standardized development environment. ## Docker Compose Configuration for Local Development Docker Compose serves as the infrastructure backbone for Akash Console development, defining multi-service environments that include PostgreSQL databases, API servers, and indexer workers. The configuration is split across three specialized files located in `packages/docker/`. ### Development Environment Setup The primary development configuration resides in [`packages/docker/docker-compose.yml`](https://github.com/akash-network/console/blob/main/packages/docker/docker-compose.yml). This file defines the hot-reload development environment where code changes trigger automatic restarts without rebuilding containers. It orchestrates the PostgreSQL database, API service, indexer, and the console web interface, ensuring all components communicate through a shared Docker network. For production-like testing, [`packages/docker/docker-compose.prod.yml`](https://github.com/akash-network/console/blob/main/packages/docker/docker-compose.prod.yml) provides an environment that mirrors deployment configurations. This file disables hot-reload mechanisms and optimizes container settings for stability rather than development velocity. ### Build Configuration Continuous integration and image building workflows rely on [`packages/docker/docker-compose.build.yml`](https://github.com/akash-network/console/blob/main/packages/docker/docker-compose.build.yml). This configuration defines the build contexts and Dockerfiles used to create production images for the API, indexer, and web applications. It ensures that the CI pipeline builds images identically to how developers construct them locally. ### Wrapper Script and NPM Shortcuts To simplify command execution, the repository includes [`packages/docker/script/dc.sh`](https://github.com/akash-network/console/blob/main/packages/docker/script/dc.sh), a thin wrapper script that forwards arguments to `docker compose` while automatically selecting the correct configuration files. This script enables the root [`package.json`](https://github.com/akash-network/console/blob/main/package.json) to expose intuitive npm shortcuts: ```bash # Start the full development stack with hot-reload and database restore npm run dc:up:dev # Build production images using the CI configuration npm run dc:build # Stop all services and remove volumes npm run dc:down ``` These commands abstract the complexity of managing multiple Docker Compose files, allowing developers to focus on application code rather than container orchestration syntax. ## Turbo Repo Monorepo Orchestration While Docker Compose handles infrastructure, **Turbo Repo** manages the JavaScript/TypeScript build pipeline and development server coordination across the monorepo. Located at [`turbo.json`](https://github.com/akash-network/console/blob/main/turbo.json), this configuration defines task dependencies and caching strategies that optimize the development workflow. ### Pipeline Configuration The [`turbo.json`](https://github.com/akash-network/console/blob/main/turbo.json) file declares tasks such as `build`, `dev`, `lint`, and `test`, specifying which packages depend on others. For example, building the console UI application requires the shared UI components to compile first. Turbo automatically parallelizes independent tasks while respecting these dependency graphs, significantly reducing build times through its remote and local caching mechanisms. ### Filtered Development Commands The root [`package.json`](https://github.com/akash-network/console/blob/main/package.json) leverages Turbo's filtering capabilities to provide granular development entry points. Developers can run specific applications without starting the entire monorepo: ```bash # Run only the console UI and its API dependencies npm run console:dev # Run the console UI without starting the PostgreSQL container npm run console:dev:no-db # Start the statistics dashboard independently npm run stats:dev ``` These commands utilize Turbo's `--filter` arguments to isolate specific applications (`console-web`, `stats-web`, `api`, `indexer`) while maintaining the dependency relationships defined in [`turbo.json`](https://github.com/akash-network/console/blob/main/turbo.json). The system watches file changes and hot-reloads only the affected packages, conserving system resources during development. ## Practical Development Workflows Combining Docker Compose and Turbo Repo enables several standardized workflows for contributing to Akash Console. ### Full Stack Development To replicate the complete production environment locally, including the PostgreSQL database with restored backups: ```bash git clone https://github.com/akash-network/console.git ./akash-console cd akash-console # Start all services via Docker Compose wrapper npm run dc:up:dev ``` This command sequence initializes the database, API server, indexer, and web interfaces with hot-reload enabled across all services. ### Isolated Frontend Development When working exclusively on UI components without requiring blockchain data or database persistence: ```bash # Run console UI with Turbo, skipping Docker infrastructure npm run console:dev:no-db ``` This approach leverages Turbo Repo to start only the `console-web` application and its immediate code dependencies, bypassing the PostgreSQL and indexer services that would normally run via Docker Compose. ### Production Image Building To verify that applications build correctly for deployment: ```bash # Build all production images using the CI configuration npm run dc:build ``` This executes `docker compose -f docker-compose.build.yml build`, creating optimized images for the API, indexer, and web applications exactly as the continuous integration pipeline does. ## Summary The **Akash Console development workflow tools** center on two complementary systems: - **Docker Compose** manages the infrastructure layer through three specialized configuration files in `packages/docker/`, orchestrating PostgreSQL, API services, and indexers with a convenient [`dc.sh`](https://github.com/akash-network/console/blob/main/dc.sh) wrapper script. - **Turbo Repo** coordinates the JavaScript/TypeScript build pipeline via [`turbo.json`](https://github.com/akash-network/console/blob/main/turbo.json), enabling filtered development commands that run specific applications (`console-web`, `stats-web`) with intelligent caching and parallel execution. Together, these tools provide the `npm run` shortcuts defined in the root [`package.json`](https://github.com/akash-network/console/blob/main/package.json), allowing developers to launch the full stack with `npm run dc:up:dev` or isolated services with `npm run console:dev`. ## Frequently Asked Questions ### How do I start only specific services in Akash Console development? Use Turbo Repo's filtered commands defined in the root [`package.json`](https://github.com/akash-network/console/blob/main/package.json) to run specific applications without starting the entire infrastructure. For example, `npm run console:dev:no-db` starts only the console UI and its API dependencies while skipping the PostgreSQL Docker container. Alternatively, use the Docker Compose wrapper with specific service names: `./packages/docker/script/dc.sh up api postgres` to selectively start infrastructure components. ### What is the difference between docker-compose.yml and docker-compose.prod.yml in Akash Console? The [`packages/docker/docker-compose.yml`](https://github.com/akash-network/console/blob/main/packages/docker/docker-compose.yml) file configures the hot-reload development environment where code changes trigger automatic restarts and volumes mount source code into containers for live editing. In contrast, [`packages/docker/docker-compose.prod.yml`](https://github.com/akash-network/console/blob/main/packages/docker/docker-compose.prod.yml) disables hot-reload mechanisms, optimizes container settings for stability, and mirrors production deployment configurations for testing releases locally. Developers typically use the development file for daily coding and the production file only when verifying deployment-specific behavior. ### How does Turbo Repo improve build performance in the Akash Console monorepo? Turbo Repo improves performance through intelligent task scheduling and caching defined in [`turbo.json`](https://github.com/akash-network/console/blob/main/turbo.json). It automatically parallelizes independent tasks while respecting dependency graphs—building shared UI components before applications that depend on them. The system maintains both local and remote caches, preventing redundant rebuilds when code hasn't changed, while filtered commands allow developers to build or run only specific applications rather than the entire monorepo. ### Can I run the Akash Console UI without starting the PostgreSQL database? Yes, the repository provides specific npm scripts that leverage Turbo Repo to run the frontend applications independently of the Docker infrastructure. Execute `npm run console:dev:no-db` to start the console UI and its required API dependencies without initializing the PostgreSQL container or indexer services. This workflow is ideal for frontend developers making UI-only changes who do not require live blockchain data or database persistence, as it consumes fewer system resources and starts faster than the full Docker Compose stack.