How to Deploy Your App to Chajio Cloud

What Is Chajio Cloud?

Chajio Cloud is a Platform-as-a-Service (PaaS) that takes care of the heavy lifting so you can focus entirely on writing code. You connect your GitHub repository, point it at your app, and Chajio Cloud handles the rest: cloning your code, detecting what language you are using, installing dependencies, building a container, routing traffic, and issuing SSL certificates, all automatically.

You do not touch a server. You do not write deployment scripts. You push code to GitHub and your app updates.

Plans and What Each One Gets You

Before signing up, it helps to know what plan fits your needs. Chajio Cloud currently offers three tiers:

All plans include automatic SSL, real-time build logs, environment variable management, and auto-deploy on git push.

Step 1 — Signing Up

Accounts on Chajio Cloud are created through the billing portal. When you purchase a plan, the system provisions your account automatically. Within a few minutes of your payment being confirmed, you will receive a welcome email containing your login credentials and the link to your dashboard.

Step 2 — Logging In and Exploring the Dashboard

Open the portal URL from your welcome email and log in. The dashboard is clean and task-focused. On the left you will see navigation for Applications, Deployments, Databases, GitHub, and Settings.

Step 3 — Connecting Your GitHub Account

Everything on Chajio Cloud deploys from a GitHub repository, so the first thing you need to do is connect your GitHub account. Click GitHub in the sidebar, then click Connect GitHub. You will be redirected to GitHub where you will be asked to authorize Chajio Cloud's application. This grants the platform read access to your repositories so it can clone your code at deployment time.

You only need to do this once. Once your account is linked, all your repositories and branches are available when creating applications.

Step 4 — Deploying Your First Application

Click Deploy New Application from the dashboard. You will see a form with the following fields:

Fill in the form for your app, click Create, and your first deployment starts immediately. The platform clones your repository, detects your language, installs dependencies, builds a container image, and starts routing traffic, all without you doing anything else.

Deploying a Python Application (Flask / FastAPI)

Your repository needs a requirements.txt file at the root. Auto deploy detects this file and automatically sets up a Python environment, installs your dependencies, and runs your application.

Here is a minimal Flask application:

flask==3.0.0
gunicorn==21.2.0

from flask import Flask, jsonify
import os

app = Flask(__name__)

@app.route("/")
def home():
    return jsonify({"message": "Hello from Chajio Cloud!", "status": "running"})

@app.route("/health")
def health():
    return jsonify({"status": "ok"})

if __name__ == "__main__":
    port = int(os.environ.get("PORT", 8000))
    app.run(host="0.0.0.0", port=port)

In the dashboard, set:

FLASK_ENV=production
SECRET_KEY=replace-with-a-long-random-string

For FastAPI, the setup is nearly identical. Replace the requirements:

fastapi==0.110.0
uvicorn==0.27.0

Deploying a Node.js Application (Express)

Node.js applications are detected by the presence of a package.json file. Auto deploy reads it, runs npm install, and uses your start script to boot the app.

{
  "name": "my-api",
  "version": "1.0.0",
  "scripts": {
    "start": "node index.js",
    "build": "echo 'No build step required'"
  },
  "dependencies": {
    "express": "^4.18.2",
    "dotenv": "^16.3.1"
  }
}

const express = require("express");
const app = express();

const PORT = process.env.PORT || 3000;

app.use(express.json());

app.get("/", (req, res) => {
  res.json({ message: "Hello from Chajio Cloud!", status: "running" });
});

app.get("/health", (req, res) => {
  res.json({ status: "ok" });
});

app.listen(PORT, "0.0.0.0", () => {
  console.log(`Server running on port ${PORT}`);
});

In the dashboard, set:

NODE_ENV=production
PORT=3000
DATABASE_URL=postgresql://user:password@host:5432/mydatabase

For a TypeScript Node.js app, add a build step:

{
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js"
  },
  "devDependencies": {
    "typescript": "^5.0.0",
    "@types/express": "^4.17.21",
    "@types/node": "^20.0.0"
  }
}

Auto deploy detects the build script, runs it first, then starts with your start script. No extra configuration needed.

Deploying a React Application

React is a frontend framework that compiles to static files. After the build, you need a small HTTP server to serve those files. The recommended approach is to use the serve package.

{
  "name": "my-react-app",
  "version": "1.0.0",
  "scripts": {
    "build": "vite build",
    "start": "npx serve dist -l 3000"
  },
  "dependencies": {
    "react": "^18.2.0",
    "react-dom": "^18.2.0"
  },
  "devDependencies": {
    "vite": "^5.0.0",
    "@vitejs/plugin-react": "^4.0.0",
    "serve": "^14.2.0"
  }
}

VITE_API_URL=https://api.yourapp.com
VITE_APP_NAME=My Awesome App

const apiUrl = import.meta.env.VITE_API_URL;

fetch(`${apiUrl}/api/users`)
  .then(res => res.json())
  .then(data => console.log(data));

Using a Custom Dockerfile

If your app has specific system-level dependencies, uses an unusual runtime, or you simply prefer full control over the build environment, you can provide your own Dockerfile. Set the Build Pack to dockerfile in the dashboard form, and Chajio Cloud will use your file instead of Auto deploy.

# Build stage
FROM node:20-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Production stage
FROM node:20-alpine AS production

WORKDIR /app
COPY package*.json ./
RUN npm ci --production
COPY --from=builder /app/dist ./dist

EXPOSE 3000
CMD ["node", "dist/index.js"]

FROM python:3.12-slim

RUN apt-get update && apt-get install -y \
    libpq-dev \
    gcc \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .

EXPOSE 8000
CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:8000", "--workers", "2"]

Managing Environment Variables

Environment variables are secrets and configuration values your app needs at runtime — database credentials, API keys, feature flags, and so on. You never hardcode these in your source code.

On the application detail page, go to the Environment Variables tab and add each variable as a key-value pair:

DATABASE_URL      postgresql://user:pass@host:5432/mydb
REDIS_URL         redis://host:6379
API_SECRET_KEY    a-long-random-secret-string
SMTP_HOST         smtp.mailprovider.com
SMTP_PORT         587
NODE_ENV          production

These are injected into your container at startup. Your application reads them with os.environ.get("DATABASE_URL") in Python or process.env.DATABASE_URL in Node.js.

After adding or changing variables, you need to trigger a new deployment. Variables do not hot-reload into a running container.

Adding a Custom Domain and SSL

By default, your app is accessible on a Chajio Cloud subdomain immediately after deployment. To use your own domain, go to your application's detail page and enter your domain name — for example, myapp.example.com.

Then log in to your DNS provider and add a record pointing to the Chajio Cloud server. For a subdomain, use a CNAME record. For a root domain like example.com, use an A record with the server's IP address provided in your dashboard or welcome email.

SSL is completely automatic. The moment your DNS record propagates and Chajio Cloud can verify domain ownership, it requests a certificate from Let's Encrypt. The certificate is installed, HTTP traffic is redirected to HTTPS, and renewal happens in the background well before the certificate expires. You never think about certificates again.

DNS propagation can take anywhere from a few minutes to 48 hours depending on your provider and TTL settings.

Adding a Managed Database

Go to Databases in the sidebar and click Create Database. Choose from:

After creation, your connection string is shown. Copy it immediately — for security reasons it is only displayed once. Add it to your application as an environment variable. The connection is internal to the platform and does not traverse the public internet.

Auto-Deploy: Ship Without Leaving Your Editor

When you enable Auto-deploy on an application, Chajio Cloud watches the configured branch for new commits. Any push to that branch — whether it is from you, a collaborator, or a merged pull request automatically triggers a deployment.

# Make your changes locally
git add .
git commit -m "feat: add user authentication"
git push origin main

# That's it. Chajio Cloud picks it up and deploys automatically.

Deployment Limits and Upgrading Your Plan

Each plan comes with a monthly deployment count: Starter allows 30, Professional allows 75, and Business allows 150. The counter resets at the start of each billing cycle. If you hit the limit before the cycle ends, new deployments are blocked and the dashboard will notify you and prompt you to upgrade. Upgrading through the billing portal instantly increases your limits. No redeployment or downtime required.

Common Issues and How to Fix Them

Summary

Chajio Cloud removes the operational complexity from deploying web applications. You write code, push to GitHub, and your app is live with HTTPS, custom domains, environment variable management, managed databases, and real-time build logs all included.

The workflow in its simplest form is:

1. Sign up and receive your credentials.
2. Log in to the dashboard.
3. Connect your GitHub account.
4. Click Deploy New Application, fill in the form, and create.
5. Watch the build logs as your app comes to life.
6. Add your custom domain and environment variables.
7. Enable auto-deploy so every git push ships your latest code.

Whether you are shipping a Python API, a Node.js backend, a React frontend, or anything else, the process is the same. Chajio Cloud handles the infrastructure so you can spend your time building features instead of managing servers.