Quick Start

Deploy a live, HTTPS-served app on Effixo — three ways, same result.

Setup (once)

1. Get access. Effixo is invite-only during the design-partner phase — ask for an invite, accept it, and sign in to the console with GitHub. We'll send you the efx binary for your platform as part of onboarding.

2. Create an API key in the console under Teams → API Keys.

3. Log in:

$ efx login --api-key efx_xxx
✓ logged in

Method 1 — Pure CLI

An app is the top-level grouping; services are the deployable workloads inside it.

$ efx apps create acme
$ efx services create --app acme --name web \
    --image nginxinc/nginx-unprivileged:stable-trixie-perl \
    --port 8080/http --route 8080:/
→ live at https://<service-id>.effixo.app
$ efx services list --app acme

Add a managed database

$ efx database create --app acme --name main --wait
✓ READY — binding POSTGRES_MAIN_URL
$ efx services update web --app acme --database main
# your service now has POSTGRES_MAIN_URL injected as an env var

Scale to zero

$ efx services update web --app acme --scale-to-zero --idle-after 60
# 60s without traffic → sleeps to 0 pods; next request wakes it in ~2s

Method 2 — Taskfile

Wrap the same commands in a Taskfile for repeatable team deploys. Every task is idempotent: --upsert makes create-or-update safe to re-run, and --wait blocks until managed resources are READY — so task all works on a fresh org and as a no-op re-run.

# Taskfile.yaml
version: '3'

vars:
  APP: acme
  IMAGE: ghcr.io/acme/web:latest

tasks:
  all:
    desc: full stack bring-up (app, database, web)
    cmds:
      - task: app
      - task: database
      - task: deploy
      - task: status

  app:
    cmds:
      - efx apps create {{.APP}} --upsert

  database:
    desc: managed postgres — blocks until READY
    cmds:
      - efx database create --app {{.APP}} --name main --upsert --wait

  deploy:
    desc: web service with the database attached (URL injected as env var)
    cmds:
      - >-
        efx services create --app {{.APP}} --name web
        --image {{.IMAGE}}
        --port 8080/http --route 8080:/
        --database main
        --scale-to-zero --idle-after 60
        --upsert

  status:
    cmds:
      - efx services list --app {{.APP}}

  url:
    desc: print the live URL
    cmds:
      - >-
        WEB_ID=$(efx services list --app {{.APP}} -o json |
        jq -r '.services[] | select(.name=="web") | .id');
        echo "https://$WEB_ID.effixo.app/"

  teardown:
    cmds:
      - efx services delete web --app {{.APP}} --yes || true
      - efx database delete main --app {{.APP}} --yes || true
      - efx apps delete {{.APP}} || true

$ task all
✓ app · ✓ database READY — binding POSTGRES_MAIN_URL · ✓ web deployed
$ task url
https://<service-id>.effixo.app/
# run it again — everything upserts, nothing breaks
$ task all

Method 3 — Score spec

Effixo speaks Score, the platform-agnostic workload spec. Declare the workload once; efx apply is idempotent — re-running updates the service in place. Git stays the source of truth.

# score.yaml
apiVersion: score.dev/v1b1
metadata:
  name: web

containers:
  web:
    image: ghcr.io/acme/web:latest
    variables:
      GREETING: hello
    resources:
      limits:
        memory: "256Mi"

service:
  ports:
    www:
      port: 80
      targetPort: 8080

resources:
  db:
    type: postgres

$ efx apply score.yaml --app acme
Provisioning database "db" ... READY — binding POSTGRES_DB_URL
Created service "web" (a1b2c3d4)
# edit score.yaml, apply again — rolls a new deployment
$ efx apply score.yaml --app acme

Score resources are provisioned automatically: postgres → managed database, redis → managed cache — connection URLs injected as env vars. Memory limits map to instance sizes. Private registries: --registry-secret.

What's next