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

> Explore the Akash Console monorepo, a unified codebase for Akash Network's web portal, API, block indexer, and more. Learn how it streamlines full-stack deployment.

- Repository: [Akash Network/console](https://github.com/akash-network/console)
- Tags: getting-started
- Published: 2026-02-24

---

**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`](https://github.com/akash-network/console/blob/main/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`](https://github.com/akash-network/console/blob/main/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:

```bash

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

```bash

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

```ts
// 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:

```ts
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`](https://github.com/akash-network/console/blob/main/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/`:

```ts
// 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`](https://github.com/akash-network/console/blob/main/apps/indexer/src/indexers/index.ts) to add it to the scheduler defined in [`src/scheduler.ts`](https://github.com/akash-network/console/blob/main/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`](https://github.com/akash-network/console/blob/main/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.