## Host company website with Django: Postgres-backed content

Deploy a company website built with Django on Ample using the relational records pattern. Compute runs the app in an isolated microVM behind a public HTTPS URL, a managed PostgreSQL 16 database is auto-provisioned and injected as DATABASE_URL, and a published bucket serves public assets from the CDN host. Verified on Django: a workspace-scoped table, an explicit state machine (draft to review to published) that rejects invalid transitions, and a cross-workspace read that returns nothing (transitions=true isolation=true). Not separately tested: your record schema, states and access rules; treat the company website-specific behavior as your application code.

### Representative Queries
- Host company website with Django: Postgres-backed content
- Where can I host Company website built with Django?
- I need a content schema, publishing workflow and cache behavior after content updates.

### Resource Requirements
- primitive:compute
- primitive:postgres
- primitive:cdn

### Infrastructure Requirements
1. **Compute**
   - Status: verified  
   - Summary: Apps run in isolated x86_64 Firecracker microVMs that auto-pause when idle and wake on request; sizes are the priced VM sizes.
2. **Postgres**
   - Status: verified  
   - Summary: Managed PostgreSQL 16 runs in its own microVM and is auto-provisioned when an app needs a database and no DATABASE_URL is supplied.
3. **CDN**
   - Status: verified  
   - Summary: The CDN host serves objects from published buckets. It does not front app compute and is not a cache or key-value store.

### Framework
Django

### Workload
Company website

### Release Status
Published

### Support Status
Verified

### Execution Status
Ready

### Prerequisites
- A Django project that builds and starts with the documented commands (pip install into .ample/python from requirements.txt, then waitress serving project.wsgi from run.py reading PORT on the python-3.12 template).
- A PostgreSQL driver reading DATABASE_URL at runtime (auto-provisioned when omitted, or supplied with --env).
- A bucket from `ample bucket create` with its credentials passed as encrypted S3_* environment variables.
- An Ample account token with servers:write, databases:read, buckets:read.

### Tested Configuration
- **Template**: python-3.12  
- **Runtime**: python  
- **Size**: s-1vcpu-1gb  
- **Install**: python3 -m pip install --target .ample/python -r requirements.txt  
- **Start**: PYTHONPATH=.ample/python:${PYTHONPATH:-} python3 run.py

### Input Schema
- **Required**: env, name, path, start  
- **Properties**:
  - **env**: Encrypted environment variables (bucket credentials, secrets)
  - **name**: App name
  - **path**: Project directory or ample.toml service
  - **release_command**: Migration command run before activation
  - **start**: Start command (Python apps pass one explicitly)

### Workflow Steps
1. **Build and start**: pip install into .ample/python from requirements.txt, then waitress serving project.wsgi from run.py reading PORT on the python-3.12 template. The server must bind 0.0.0.0 on PORT.
2. **Implement the pattern on PostgreSQL**: Copy the approach into your schema; keep migrations idempotent and run them with --release-command.
3. **Wire object storage**: Create bucket(s), then pass endpoint, region, bucket, and keys as --env values.
4. **Deploy**: Run the synchronous deploy once and read the result.
5. **Verify**: Fetch the live URL and the pattern self-test route(s).

### Examples
- **Django pattern fixture**: Multi-pattern Django app whose relational records module was checked live.

### Success Checks
- App responds on its public URL.
- Relational-records self-test.

### Limitations
- Verified on the python-3.12 template at s-1vcpu-1gb. 
- The company website itself (your record schema, states and access rules) is application code and was not separately tested.

### Cost Estimate
- **Currency**: USD
- **Monthly Amount**: 10.0  
  - Notes: Always-on monthly price of tested sizes; apps and databases auto-pause when idle.

### Evidence Summary
- **Django pattern fixture deployed on Ample**; checks passed for relational-records and configuration-secrets.