# Alchemist Production Workloads: Non-Chat Examples

Concrete examples of what Alchemist can build beyond chat agents: REST APIs, backend services, service-to-service integrations, workers, scheduled jobs, event processors, data pipelines, and conventional web applications. AI does the engineering; no AI has to run in the resulting software.

---

import Callout from "../../../components/docs/Callout.astro";

Alchemist builds and ships software through tickets. AI agents do the engineering
work; what they produce runs as ordinary, deterministic software. This page covers
the range of production workloads you can ask Alchemist to build, with concrete
examples for each type.

> **Note:** None of the workload types below require an AI, LLM, chatbot, or conversational
> interface in the deployed runtime. The AI is on the engineering side (planning,
> coding, testing, reviewing, deploying). The software it ships can be as conventional
> as any service written by a human developer. See [Alchemist Architecture: The Two
> Planes](/docs/guides/alchemist-architecture) for the full structural breakdown.

## REST APIs and backend services

Alchemist can build and maintain HTTP APIs that other systems call:

- **Internal APIs** that expose business logic to a frontend or mobile app.
- **Partner APIs** that external services call on a published schedule or event.
- **Admin APIs** that back an internal tooling surface (dashboard, operations console).
- **Webhook receivers** that accept inbound calls from third-party services (Stripe,
  GitHub, Twilio, etc.) and process them against your data layer.

**Example ticket:** "Add a `POST /api/orders/bulk-import` endpoint that accepts a
JSON array of order objects, validates each against the order schema, writes valid
rows to the `orders` table, and returns a summary of successes and failures."

## Backend services

Alchemist can build self-contained services that run independently of any UI:

- **Calculation services** that other services call for pricing, routing, or scoring.
- **Transformation services** that normalize and enrich incoming data before it
  reaches a database or downstream system.
- **Auth and token services** that issue and validate credentials for internal callers.

**Example ticket:** "Build a `pricing-service` that accepts a `cart_id`, fetches
applicable discount rules from the `promotions` table, calculates the final total,
and returns a breakdown. Expose it over an internal HTTP endpoint."

## Service-to-service integrations

Alchemist can write the glue code that connects two existing systems:

- **CRM-to-billing sync**: push customer status changes from Salesforce to Stripe.
- **Inventory-to-warehouse**: write order lines from your ERP into a 3PL's API.
- **Identity bridge**: replicate user records between an IDP and an internal users
  table on a schedule or triggered by a webhook.

**Example ticket:** "When a Salesforce `Account` is marked `Churned`, call the
Stripe API to cancel all active subscriptions for that account's customer ID and
write a row to `churns_log` with the timestamp and reason."

## Workers and background job processors

Alchemist can build persistent workers that consume from a queue or topic:

- **Queue consumers** (SQS, RabbitMQ, Kafka, Pub/Sub) that process messages and
  write results to a database or downstream API.
- **Retry workers** that pick up failed operations from a dead-letter queue and
  re-attempt them with backoff.
- **Batch processors** that drain a work queue in parallel within a time window.

**Example ticket:** "Build a worker that reads `image_resize` messages from the
SQS queue, fetches the source image from R2, resizes it to three target dimensions,
writes each variant back to R2, and marks the job `complete` in the `image_jobs`
table."

## Scheduled jobs and cron-style tasks

Alchemist can build and schedule periodic jobs:

- **Nightly aggregation jobs** that roll up daily metrics into a reporting table.
- **Reconciliation jobs** that compare two system states and log or resolve
  discrepancies.
- **Cleanup jobs** that purge soft-deleted rows or expired sessions on a schedule.
- **Export jobs** that generate and deliver CSV, JSON, or PDF reports to an S3
  bucket or FTP target.

**Example ticket:** "Run a cron job at 03:00 UTC every day that queries
`orders` for the prior 24 hours, aggregates revenue by SKU category, and
upserts the results into `daily_revenue_summary`. Send an error notification
to the `#data-alerts` Slack channel if the job fails."

## Event processors

Alchemist can build event-driven pipelines that react to state changes:

- **Domain event handlers** that listen for internal events (user created,
  order placed, payment failed) and trigger downstream actions.
- **CDC processors** that react to database change streams.
- **Webhook fan-out services** that receive a single inbound event and
  dispatch it to multiple downstream consumers.

**Example ticket:** "Subscribe to the `payment.failed` event on the internal
event bus. For each failure, look up the subscription record, increment the
`failure_count`, and trigger a retry if `failure_count` is less than 3; otherwise
mark the subscription `suspended` and enqueue a dunning email."

## Data pipelines

Alchemist can build ELT/ETL pipelines that move and transform data between
systems:

- **Ingestion pipelines** that pull from a source API or file drop, transform
  the records, and write to a data warehouse or analytics DB.
- **Sync pipelines** that keep two databases consistent with incremental
  change detection.
- **Reporting pipelines** that join multiple tables, apply business rules, and
  materialize summary tables for a BI tool.

**Example ticket:** "Build a nightly pipeline that pulls Shopify orders placed in
the last 24 hours via the REST API, joins them against the `customers` table in
Postgres, and writes the enriched rows to the `shopify_orders` BigQuery table,
replacing any existing rows for the same order ID."

## Conventional web applications

Alchemist can build and maintain web applications that have no conversational
interface at all:

- **Internal admin dashboards** for operations, support, or finance teams.
- **Partner portals** where external companies log in and manage their account
  data.
- **Consumer-facing apps** with forms, tables, charts, and standard CRUD workflows.

**Example ticket:** "Build an internal operations portal at `/ops` that shows a
paginated, filterable table of all open support tickets from the `tickets` table,
lets an admin change the `assignee` field inline, and shows a sidebar with daily
open/closed counts."

## Related reading

- [Alchemist Architecture: The Two Planes](/docs/guides/alchemist-architecture) --
  how the development side (agents, tickets, review) and the production side
  (whatever you actually deploy) stay completely separate.
- [Alchemist: Getting Started](/docs/guides/alchemist-getting-started) -- create a
  project and ship your first ticket.
- [Alchemist Tickets: Autonomous Development](/docs/guides/alchemist-tickets) --
  the full ticket-to-deploy lifecycle.