# Source: https://juno.build/docs/miscellaneous/architecture.md

# Architecture

Juno is your own self-contained execution space. Everything your app needs â frontend, backend logic, storage â gets bundled into a single deployable WebAssembly (WASM) container called a Satellite.

One artifact. One push. That's your app.

No DevOps. No backend boilerplate. No surprise complexity.

Juno's architecture is designed to give developers complete control and ownership. It combines familiar developer workflows with an environment that runs independently once deployed â without Juno's intervention.

  

![Juno architecture schema showing developer control flow](/assets/images/architecture-ea813c74e7ec12ec0989052392308143.png)

---

## How It Works

A typical Juno development flow looks like this:

1.  **Build your frontend** using Next.js, React, SvelteKit, Vue or any other framework you love (or none).
2.  **Add backend logic** (if needed) via serverless functions written in Rust or TypeScript.
3.  **Bundle everything into a Satellite** â a single WebAssembly container that holds your entire application, including its logic, state, and storage.
4.  **Deploy using the CLI or GitHub Actions.** No servers to configure. No infrastructure to manage.

Once deployed, your Satellite runs independently in an unstoppable environment, entirely under your control.

---

## Platform Services

Juno provides supporting services to manage your projects, while keeping everything under your ownership:

### Console

The Console is a platform for managing your projects. It runs as its own container, combining a user interface with orchestration logic.

It provides services such as:

*   Creating, upgrading, and deleting Satellites.
*   Managing authentication, storage, data, and application state.
*   Monitoring logs from serverless functions.
*   Setting custom domains.
*   Spinning up and reviewing analytics.

You can access the Console at [console.juno.build](https://console.juno.build).

**Note:**

The Console is not decentralized. It is maintained by Juno to provide a stable management platform and up-to-date developer experience. However, all applications, data, and infrastructure you deploy through it remain under your control.

In the future, there is a strong will to resolve this dependency by making the Console self-hostable or governed by a DAO, aligning it with the same principles of ownership and autonomy as the rest of the platform.

It is worth noting that Juno is fully open source. Anyone can review its source code at any time. And while not formally documented, the Console is already self-hostable today â offering anyone who wants full control over the entire stack the option to do so.

### Observatory

The Observatory is a proxy service used solely for developer notifications. When monitoring is enabled in a developer's Mission Control, events such as automatic top-up successes or failures trigger a message sent through the Observatory to notify the developer via email.

This setup ensures that each Mission Control does not need to maintain its own notification infrastructure. The Observatory only forwards messages â it does not monitor, modify, or access any application logic or data.

### CDN

Juno maintains a CDN that stores libraries, templates, and pre-built WASM code. These pre-built WASM containers are official module versions shipped by Juno. When a new release is available, it is uploaded to the CDN, allowing developers to upgrade e.g. their Satellites using the latest version.

While it functions as a CDN, technically it's not a traditional content delivery network. It is itself a Satellite.

---

## Developer-Owned Spaces

Juno's architecture is built on a microservices approach, where each component runs independently as its own WASM container, giving you modular control over your infrastructure.

### Satellites

Satellites are your applications. Each one is a self-contained unit that bundles:

*   Frontend assets
*   Default backend features
*   Custom serverless functions
*   Data and storage
*   Permissions and access control

### Orbiters

Orbiters provide analytics â a decentralized alternative to services like Google Analytics. Orbiters collect traffic, page views, and device information, under your ownership and without exposing user data to third parties.

### Mission Control

Mission Control is an optional monitoring service that automatically tracks and maintains your Satellites and Orbiters.

When enabled, it monitors [cycles](/docs/terminology.md#cycles) balances across your modules and automatically tops them up when needed, ensuring your applications stay running without manual intervention.

---

## CI/CD and Deployment

You can deploy and upgrade your Satellites using GitHub Actions or the Juno CLI.

*   Deployment automation is opt-in.
*   Juno does not control or interfere with your deployed app.
*   Once live, your apps remain running independently.

Each Satellite uses a role-based permission system managed via [access keys](/docs/miscellaneous/access-keys.md), letting you decide whether to retain full access, delegate writable access, or allow third parties to solely propose changes.

---

## Libraries, Tools, and Emulator

Juno provides many JavaScript libraries, Rust crates, templates and tooling to get started and integrate with your workflow. You can find all the code in the [Juno GitHub organization](https://github.com/junobuild).

It also provides an emulator for [local development](/docs/guides/local-development.md) that mimics as closely as possible the experience you get in production.