runtm init web-app
cd web-app
runtm run

web-app/
├── runtm.yaml              # Deployment manifest
├── runtm.discovery.yaml    # Search metadata
├── Dockerfile              # Multi-stage build
├── frontend/
│   ├── package.json
│   ├── app/
│   │   ├── layout.tsx
│   │   ├── page.tsx
│   │   └── api/auth/[...all]/route.ts  # Auth routes (if enabled)
│   ├── components/
│   │   ├── auth/           # Auth components (if enabled)
│   │   └── ui/             # UI components
│   ├── lib/
│   │   ├── api.ts          # API client
│   │   ├── auth.ts         # Auth server (if enabled)
│   │   └── auth-client.ts  # Auth client (if enabled)
│   └── types/
├── backend/
│   ├── pyproject.toml
│   ├── app/
│   │   ├── main.py
│   │   ├── api/v1/
│   │   ├── services/
│   │   ├── core/
│   │   └── db/             # Database (if enabled)
│   └── tests/
├── README.md
├── AGENT.md
└── CLAUDE.md

// frontend/lib/api.ts
const API_URL = process.env.NEXT_PUBLIC_API_URL || '/api';

export async function fetchItems() {
  const response = await fetch(`${API_URL}/v1/items`);
  return response.json();
}

// frontend/components/ItemList.tsx
'use client';

import { useEffect, useState } from 'react';
import { fetchItems } from '@/lib/api';

export function ItemList() {
  const [items, setItems] = useState([]);

  useEffect(() => {
    fetchItems().then(setItems);
  }, []);

  return (
    <ul>
      {items.map((item) => (
        <li key={item.id}>{item.name}</li>
      ))}
    </ul>
  );
}

# backend/app/api/v1/items.py
from fastapi import APIRouter, Depends
from sqlalchemy.orm import Session
from app.db import get_db

router = APIRouter(prefix="/items", tags=["items"])

@router.get("/")
def list_items(db: Session = Depends(get_db)):
    # Your logic here
    return []

# runtm.yaml
features:
  database: true

// frontend/types/index.ts
export interface Item {
  id: number;
  name: string;
  created_at: string;
}

# backend/app/schemas/item.py
from pydantic import BaseModel
from datetime import datetime

class Item(BaseModel):
    id: int
    name: str
    created_at: datetime

# runtm.yaml
features:
  database: true  # Required
  auth: true

env_schema:
  - name: AUTH_SECRET
    type: string
    required: true
    secret: true

runtm secrets set AUTH_SECRET=$(openssl rand -base64 32)

// frontend/app/dashboard/page.tsx
import { AuthGuard } from '@/components/auth/AuthGuard';
import { Dashboard } from '@/components/Dashboard';

export default function DashboardPage() {
  return (
    <AuthGuard>
      <Dashboard />
    </AuthGuard>
  );
}

'use client';

import { useSession, signIn, signOut } from '@/lib/auth-client';

export function UserMenu() {
  const { data: session, status } = useSession();

  if (status === 'loading') return <span>Loading...</span>;
  if (!session) return <button onClick={() => signIn()}>Sign In</button>;

  return (
    <div>
      <span>{session.user.email}</span>
      <button onClick={() => signOut()}>Sign Out</button>
    </div>
  );
}

# Run both frontend and backend
runtm run

# Set tier to standard (required)
# This is already set in runtm.yaml

# Deploy
runtm deploy

# Build frontend
FROM node:20-alpine AS frontend-builder
WORKDIR /frontend
COPY frontend/package*.json ./
RUN npm ci
COPY frontend .
RUN npm run build

# Build backend
FROM python:3.11-slim AS backend-builder
WORKDIR /backend
COPY backend/pyproject.toml .
RUN pip install -e .
COPY backend .

# Runtime
FROM python:3.11-slim
# ... serves both frontend static files and backend API

# runtm.yaml
env_schema:
  - name: AUTH_SECRET
    type: string
    required: true
    secret: true
    description: "Session signing secret"
  
  - name: DATABASE_URL
    type: url
    required: false
    secret: true
    description: "External PostgreSQL (optional)"

runtm secrets set AUTH_SECRET=$(openssl rand -base64 32)