Akash Console Development Workflow Tools: Docker Compose and Turbo Repo Guide

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. 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 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. 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, a thin wrapper script that forwards arguments to docker compose while automatically selecting the correct configuration files. This script enables the root package.json to expose intuitive npm shortcuts:

# 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, this configuration defines task dependencies and caching strategies that optimize the development workflow.

Pipeline Configuration

The 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 leverages Turbo's filtering capabilities to provide granular development entry points. Developers can run specific applications without starting the entire monorepo:

# 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. 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:

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:

# 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:

# 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 wrapper script.
• Turbo Repo coordinates the JavaScript/TypeScript build pipeline via 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, 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 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 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 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. 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}