What Is the Akash Console Monorepo? A Complete Guide to the Full-Stack Deployment Portal

The Akash Console monorepo is a unified repository that bundles all services, shared libraries, and infrastructure needed to run the Akash Network's web-based deployment portal, statistics site, API layer, block indexer, and supporting tooling in a single cohesive codebase.

The akash-network/console repository on GitHub serves as the single source of truth for the entire Akash Console stack. By consolidating the UI applications, backend services, and shared TypeScript libraries into one TurboRepo-managed workspace, developers can develop, test, and deploy the full suite of Akash web services together without managing disparate repositories.

Architectural Overview of the Akash Console Monorepo

The monorepo is organized into distinct layers, each housed in specific directories under apps/ and packages/. This structure enables clear separation of concerns while allowing seamless code sharing across the stack.

UI Applications

The frontend layer contains two primary Next.js applications:

• Deploy-Web (apps/deploy-web): The main web interface where users launch Docker containers on the Akash Network with just a few clicks.
• Stats-Web (apps/stats-web): A public statistics site displaying network-wide metrics, provider statuses, and deployment trends.

Backend API

Located in apps/api, this service exposes a REST/Swagger interface consumed by the UI applications. It handles authentication, billing logic, wallet-balance checks, and serves as the intermediary between the frontend and the blockchain data stored in PostgreSQL.

Indexer

The apps/indexer directory contains a block-streaming service that connects to Akash RPC nodes, parses new blocks in real-time, and writes structured data—such as providers, leases, deployments, and pricing information—into the shared PostgreSQL database. This enables the UI to query current network state without hitting the blockchain directly for every request.

Provider-Proxy

Housed in apps/provider-proxy, this lightweight service acts as a CORS-friendly bridge. It allows the browser-based UI to reach provider endpoints that require TLS client certificates, bypassing browser security restrictions that would otherwise block these requests.

Tx-Signer

The apps/tx-signer service is a small, specialized microservice that signs and broadcasts transactions on behalf of the UI. When a user initiates a deployment, the frontend calls this service to handle the cryptographic signing with the user's wallet before submitting to the Akash network.

Shared Packages

The packages/ directory contains reusable TypeScript libraries—including utilities, type definitions, UI components, and configuration—that are shared across all applications. This ensures type safety and prevents code duplication between the frontend and backend services.

Infrastructure

Root-level configuration files orchestrate the entire stack:

• docker-compose.yml and docker-compose.*.yml files manage the PostgreSQL database and service orchestration for local development.
• .helm/ directories contain Kubernetes charts for production deployments.
• turbo.json configures the TurboRepo build graph, optimizing task execution across the monorepo.

How the Components Work Together

Understanding the data flow reveals why the monorepo structure is essential for maintaining consistency across services.

1. Data Synchronization: The Indexer continuously syncs new blocks from configured RPC nodes, parsing messages and populating PostgreSQL tables used by both the Deploy-Web UI and the Stats-Web site.

2. User Interactions: When a user browses deployments in apps/deploy-web, the UI fetches data from the API (apps/api), which queries the Indexer database to display real-time provider status and lease information.

3. Transaction Flow: Upon clicking Deploy, the UI calls the Tx-Signer (apps/tx-signer) to cryptographically sign the transaction with the user's wallet, then broadcasts it to the Akash network.

4. Provider Communication: The Provider-Proxy (apps/provider-proxy) enables the UI to query provider endpoints directly, handling TLS client certificates that browsers cannot manage due to CORS restrictions.

All services share the same PostgreSQL instance managed via Docker Compose and import common TypeScript types from the packages/ folder, ensuring end-to-end type safety.

Getting Started with the Akash Console Monorepo

The TurboRepo configuration enables rapid local development with a single command structure.

Running the Full Stack Locally

To spin up the entire ecosystem—including the database, API, Indexer, and UI—execute the root-level npm scripts:

# Clone and enter the repository

git clone https://github.com/akash-network/console.git
cd console

# Build Docker images (optional; Turbo will also build on-the-fly)

npm run dc:build

# Start everything in development mode

npm run dc:up:dev

This command orchestrates all services defined in the Docker Compose files, exposing the Deploy UI, Stats site, API endpoints, and Indexer simultaneously.

Running Individual Applications

For frontend-focused development, you can run the Deploy UI independently while relying on Docker for background services:

# Install dependencies once at the root

npm install

# Run only the Deploy UI with hot-reload

npm run console:dev

The Docker Compose environment continues to provide the PostgreSQL database and API, allowing isolated UI development against live backend data.

Working with Shared Packages

Adding functionality to the shared libraries immediately propagates across all applications. For example, creating a utility in packages/utils makes it available to every app in the workspace:

// packages/utils/src/format.ts
export function formatBytes(bytes: number): string {
  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
  let i = 0;
  while (bytes >= 1024 && i < units.length - 1) {
    bytes /= 1024;
    i++;
  }
  return `${bytes.toFixed(1)} ${units[i]}`;
}

Import this in any application:

import { formatBytes } from '@akashnet/utils';
console.log(formatBytes(12345678)); // → "11.8 MB"

Because packages/utils is listed as a workspace dependency in the root package.json, TurboRepo automatically rebuilds any application that imports modified shared code.

Customizing the Indexer and Adding Features

The Indexer architecture supports scheduled tasks for custom data aggregation. To add a new indexing job, extend the base Indexer class in apps/indexer/src/indexers/:

// apps/indexer/src/indexers/providerStatsIndexer.ts
import { Indexer } from '../../src/indexer';

export default class ProviderStatsIndexer extends Indexer {
  // Execute every 15 minutes
  static readonly interval = 15 * 60 * 1000;

  async run() {
    // Custom logic to aggregate provider metrics
    await this.providerService.refreshMetrics();
  }
}

Register the new indexer in apps/indexer/src/indexers/index.ts to add it to the scheduler defined in src/scheduler.ts. The Indexer will automatically invoke your task at the specified interval, writing results to the PostgreSQL store for API consumption.

Summary

• The Akash Console monorepo consolidates the Deploy UI, Stats site, API, Indexer, Provider-Proxy, and Tx-Signer into a single TurboRepo-managed repository at akash-network/console.
• Shared packages in packages/ provide type-safe utilities and components used across all TypeScript applications, eliminating code duplication.
• TurboRepo and Docker Compose enable one-command local development (npm run dc:up:dev) that spins up the entire stack including PostgreSQL.
• The Indexer streams blockchain data into PostgreSQL, enabling fast queries for the UI while the Provider-Proxy solves browser CORS limitations when contacting providers.
• Helm charts in .helm/ directories support Kubernetes deployments, maintaining infrastructure-as-code alongside application logic.

Frequently Asked Questions

What is the purpose of the Akash Console monorepo?

The Akash Console monorepo serves as the single source of truth for all code, Docker images, and configuration required to run the Akash Network's deployment portal. It bundles the web UI, backend API, block indexer, and supporting microservices into one repository, enabling developers to build, test, and deploy the full stack together rather than managing separate repositories for each component.

How does the Akash Console monorepo handle code sharing between applications?

The repository uses TurboRepo to manage workspaces defined in the root package.json, which includes apps/* and packages/* directories. Shared TypeScript libraries—such as utilities, types, and UI components—live in packages/ and are imported by applications using workspace references (e.g., @akashnet/utils). This ensures type safety and automatic rebuilds when shared code changes.

What services are included in the Akash Console monorepo?

The monorepo contains Deploy-Web (apps/deploy-web) for container deployments, Stats-Web (apps/stats-web) for network analytics, a REST API (apps/api) for business logic, a block Indexer (apps/indexer) for chain data synchronization, a Provider-Proxy (apps/provider-proxy) for CORS handling, and a Tx-Signer (apps/tx-signer) for transaction broadcasting. All services share a PostgreSQL database and common libraries.

How do I deploy the Akash Console monorepo to production?

Production deployments utilize the Helm charts located in .helm/ directories throughout the repository. These charts define Kubernetes configurations for each service, while Docker Compose files handle local orchestration. The repository's CI/CD pipelines build container images from the monorepo's Dockerfile definitions, enabling consistent deployment from the same codebase used in development.

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