Curated, admin-reviewed recipes anyone can install with one command — or submit your own for review.
AI 2
LLM Gateway / Proxy
A lightweight proxy in front of one or more LLM providers, with Redis for response caching and rate limiting — the pattern in front of the pattern, not another RAG pipeline.
by @ops
Python + Postgres + Redis: AI Agent Orchestration / Tool-calling Gateway
Manages multi-step agent tool-calls and orchestration state, a worker processing agent steps async — distinct from the LLM Gateway/Proxy recipe: that's caching and rate limiting in front of model calls, this is the orchestration layer coordinating an agent's actual multi-step work.
by @ops
AI/ML 8
AI Content Classification & Moderation
Auto-classification via an LLM (toxicity, spam, category tagging) with a worker to process items async and Redis to avoid re-classifying the same content twice. Distinct from the Content Moderation Pipeline recipe: that's the human-review queue; this is the AI doing the first pass.
by @ops
Go + Redis: Distributed Feature Store for ML Model Serving
Low-latency feature lookups for ML models at inference time — a real MLOps pattern distinct from anything else in the catalog's AI/ML section: this doesn't call an LLM or process embeddings, it serves pre-computed features fast enough for real-time model inference.
by @ops
Podcast/Video Transcription & Captioning Service
Audio/video files land in MinIO, a Celery worker runs speech-to-text and generates captions/transcripts stored in Postgres. Distinct from AI Content Classification: that classifies existing text, this creates text from audio in the first place.
by @ops
Python + pgvector + MinIO: Duplicate Image/Media Detection Backend
Perceptual-hash and embeddings-based detection of duplicate or near-duplicate images, a worker processing uploads and comparing against stored vectors — a distinct application of pgvector from document search or recommendations: finding near-identical media, not similar meaning.
by @ops
Python + pgvector + Redis: AI SaaS Starter
A production-ready backend for LLM-powered products: FastAPI-style Python API, Postgres with pgvector for embeddings and semantic search, Redis for response caching and rate limiting, and a background worker for async completions and embedding jobs.
by @ops
Python + pgvector + Redis: Product Recommendation Engine
Embeddings-based product similarity and recommendations, a worker computing recommendation sets on a schedule — distinct from Semantic Document Search: that finds documents by meaning, this recommends catalog items by similarity, an e-commerce-shaped application of the same underlying technique.
by @ops
Python + pgvector: Semantic Document Search
Embeddings-backed search over a document corpus — distinct from the AI SaaS Starter (that's a RAG chat product) and Search-as-a-Service (Meilisearch keyword search): this is specifically finding documents by meaning, not exact terms.
by @ops
Python + Postgres + MinIO: Text-to-Speech (TTS) Synthesis Pipeline
Generates audio from text via a worker, storing output in MinIO — the reverse direction from the Transcription/Captioning recipe: that turns audio into text, this turns text into audio.
by @ops
API 10
API Changelog & Deprecation Notice Service
Tracks API version changes and surfaces deprecation notices to integrators — distinct from the Developer Portal recipe: that's onboarding docs, this is telling existing integrators something is about to break.
by @ops
API Documentation & Developer Portal Backend
Hosting OpenAPI specs and self-service API key issuance for external developers — distinct from the Public API Product recipe: that one meters and rate-limits usage; this one is the docs/onboarding surface a developer sees before they ever make a call.
by @ops
API Gateway & Rate Limiter
A lightweight reverse-proxy layer with Redis-backed rate limiting, meant to sit in front of whatever backend you already have — not another full API of its own. The thing every API ends up needing once real traffic (or one bad actor) shows up.
by @ops
Deno + Postgres + Redis: Edge API Starter
A modern edge-friendly API backend: Deno's secure-by-default runtime with native TypeScript, Postgres for relational data, and Redis for caching and rate limiting at the edge.
by @ops
Deno + Redis: Edge Function Router / Dispatch Gateway
Routes requests to different edge functions based on path/header rules, Redis holding routing config for fast lookups — distinct from rate-limiting gateways: this is about dispatch/routing to the right function, not throttling traffic to one backend.
by @ops
Go + Postgres + Redis: Multi-tenant Rate-Limited API Gateway
Per-tenant quotas and rate limits in front of a multi-tenant SaaS backend, tenant identity resolved from Postgres, limits enforced via Redis — distinct from the general API Gateway & Rate Limiter recipe: that's single-tenant, this is quota isolation between customers sharing one deployment.
by @ops
GraphQL API
Node API service with Postgres, sized for a GraphQL server (Apollo, Yoga, or similar) instead of assuming REST.
by @ops
OAuth / Connected-Apps Management Backend
Being an OAuth provider for third-party apps connecting to YOUR platform — app registration, scopes, and token issuance. Distinct from the Public API Product and Dev Portal recipes: those are about developers calling your API directly; this is 'Sign in with [Your Platform]' for other people's apps.
by @ops
Public API Product Starter
For when the API IS the product: API key issuance, per-key tiered rate limits, and usage tracking in Postgres + Redis. Distinct from the API Gateway recipe — that's a proxy in front of an existing backend; this is a complete API product with developer-facing accounts.
by @ops
Rust + Postgres + Meilisearch
A Rust API backed by Postgres with Meilisearch for fast, typo-tolerant full-text search.
by @ops
Analytics 20
BI Reporting & Warehouse Query Layer
Fast aggregate queries over ClickHouse for internal dashboards — distinct from ETL (which moves data in), Reverse ETL (which pushes data out), and Scheduled Reports (which generates and delivers files): this is live query serving for a BI tool or internal dashboard.
by @ops
Customer Data Platform / Unified Profile Backend
Merges customer data from multiple sources into one resolved profile via a worker doing the identity resolution — distinct from generic analytics: this is specifically about having one true record per customer, not aggregate reporting.
by @ops
Customer Health Score & Churn Signals
Engagement events rolled up into a health/churn-risk score per account, computed by a worker on a schedule rather than live on every dashboard load. For B2B SaaS teams who need to know which accounts are quietly disengaging before the cancellation email arrives.
by @ops
Deno + Postgres + Redis: URL Shortener & Link Analytics
Short-link generation, redirect handling, and click analytics — Redis for the redirect lookup that needs to be near-instant, Postgres for the click history behind it.
by @ops
Go + ClickHouse + Kafka
An event-ingestion pipeline: a Go API publishing to Kafka, with ClickHouse as the analytics store.
by @ops
Go + ClickHouse + Redis: Real-time Fraud Scoring at Scale
A worker scoring transaction streams against ClickHouse-stored patterns at real production volume — distinct from the Node-based Fraud & Anomaly Detection recipe: same problem, built for a much higher event-volume ceiling.
by @ops
Go + ClickHouse: A/B Test Statistical Significance Engine
A worker computing statistical significance over ClickHouse-scale event volume — distinct from the A/B Testing & Experimentation recipe: that assigns variants and tracks results, this is the heavier analytical engine crunching the numbers at real production traffic volume.
by @ops
Go + Postgres + Redis: Infrastructure Cost Allocation / Chargeback Backend
Allocates cloud infrastructure costs to internal teams or tenants sharing a deployment, a worker computing allocation runs — a real, timely FinOps pattern distinct from Usage Metering & Billing (that bills external customers, this apportions internal cost).
by @ops
Go + Postgres + Redis: Weather Data Aggregation & Threshold Alerting
Pulls weather data on a schedule and alerts when conditions cross a defined threshold — a worker doing the polling and evaluation, useful for agriculture, logistics, or event-planning use cases needing weather-aware automation.
by @ops
IoT Device Telemetry Ingestion
High-volume sensor/device data landing straight in ClickHouse, Redis buffering ahead of it — built for write volume a normal Postgres table would choke on. The same ingestion shape as the Logging & Metrics recipe, aimed at device telemetry instead of application logs.
by @ops
Marketing Attribution & UTM Tracking Backend
Campaign source/UTM tracking at real traffic volume via ClickHouse — distinct from generic analytics or the BI Reporting recipe: this is specifically "which channel actually drove this signup," not general event aggregation.
by @ops
PHP + Postgres + Redis: Self-hosted Privacy-first Web Analytics
Pageview and event tracking without cookies or third-party trackers — a self-hosted, privacy-respecting alternative pattern to sending every visitor's data to an external analytics vendor.
by @ops
Python + ClickHouse + Kafka: Data Warehouse ETL Pipeline
A data engineering ETL/ELT pipeline: Python for its rich data-tooling ecosystem, Kafka as the ingestion backbone decoupling producers from processing, and ClickHouse as the analytical warehouse built for fast aggregate queries over large volumes.
by @ops
Python + ClickHouse: Cohort Retention Analysis Backend
Computes retention curves by signup cohort at real event volume, a worker running the rollups — distinct from Customer Health Score & Churn Signals: that scores individual accounts, this analyzes retention patterns across entire cohorts over time.
by @ops
Python + Postgres + Redis: Customer Segmentation & Cohort Tagging Engine
Rule-based and behavioral customer segmentation for marketing use, a worker computing segment membership on schedule — distinct from Cohort Retention Analysis: that measures retention curves over time, this tags customers into segments for targeting, a different downstream use.
by @ops
Python + Postgres: Carbon Footprint / ESG Tracking Backend
Emissions data collection and ESG reporting metrics, a worker computing rollups on schedule — a genuinely growing-relevance category, not yet touched anywhere else in the catalog.
by @ops
Python + Postgres: Research Data Pipeline with Provenance Tracking
A data pipeline that records exactly where every dataset and transformation came from, a worker processing runs and logging lineage — distinct from generic ETL: built for research/pharma contexts where reproducibility and provenance are the actual requirement, not just moving data.
by @ops
Rust + Kafka + ClickHouse: IoT Telemetry Ingestion
A high-throughput device telemetry pipeline: a Rust ingestion API built for low-latency, high-volume writes, Kafka absorbing bursty device traffic, and ClickHouse as the analytical store for time-series queries at scale.
by @ops
Scheduled Reports & Data Export
Batch report generation on a schedule — CSV/PDF export, delivered async by a worker instead of generated inline and blocking a request. Distinct from real-time analytics: this is the "email me the weekly numbers" pattern, done properly.
by @ops
Session Recording & Replay Backend
Captures UI interaction events for session replay, storing recordings in MinIO with a worker processing them for playback — distinct from generic logging/metrics: this is specifically "watch what the user did," not application telemetry.
by @ops
Auth & Identity 4
Auth / SSO starter
Session-based auth with OAuth-ready config — Postgres for users, Redis for sessions. The starting point every team currently has to build from scratch.
by @ops
Go + Postgres + Redis: Social Login Aggregator / Identity Broker
Unifies multiple OAuth providers behind one identity record — distinct from the basic Auth/SSO starter: this specifically handles linking several social logins to a single account and reconciling identity across them.
by @ops
Java (Spring) + Postgres: SCIM Provisioning & Enterprise Directory Sync
Automatic user provisioning/deprovisioning via SCIM, a worker syncing against an enterprise identity provider — the real enterprise-B2B requirement most SaaS auth starters skip entirely: when an employee leaves, access needs to disappear without a support ticket.
by @ops
Passwordless / MFA Auth Starter
WebAuthn/passkey and TOTP-ready authentication, not just sessions — a genuinely different pattern than a basic login/SSO starter, for teams building auth people actually expect in 2026: no password to leak, a second factor by default.
by @ops
Backend 73
.NET + Postgres + Redis: Field Sales CRM & Visit Tracking
Sales rep visit logging, territory assignment, and account history — a genuinely common field-sales vertical not yet in the catalog, distinct from the Field Service Technician recipe (that's repair/installation work, not sales visits).
by @ops
.NET + Postgres + Redis: Fintech-oriented Baseline
A security-conscious starting point for financial and payments-adjacent backends: .NET API, Postgres for ledger/transaction records, and Redis for session and rate-limit state. This is a starting baseline only, not a certified or verified PCI-DSS/regulatory-compliant stack — your own security and compliance review is still required before handling real financial data.
by @ops
.NET + Postgres + Redis: Insurance Policy Quoting Engine
Rate calculation and quote generation before a policy exists — distinct from Insurance Claims Processing: that handles claims after something happens, this is underwriting math and quote state before a customer ever buys.
by @ops
.NET + Postgres + Redis: Retail Point-of-Sale (POS) Backend
In-person transaction handling, cash drawer reconciliation, and receipt records — distinct from e-commerce/inventory recipes built around online orders: this is the in-store, register-shaped side of retail.
by @ops
.NET + Postgres + Redis: Warehouse Management System (WMS) Backend
Bin locations, pick routes, and receiving records — distinct from Inventory & Order Management: that's e-commerce-facing stock/order data, this is the physical warehouse-operations layer underneath it.
by @ops
Audit Log / Activity Trail Service
An append-only activity trail — who did what, when, to which record — as its own service instead of scattered console.logs or an afterthought column. Redis buffers writes so logging never blocks the request that triggered it.
by @ops
Bulk CSV Import & Data Validation Service
User-uploaded bulk file processing — row-by-row validation and async import via a worker, with a real error report instead of a silent partial failure. Distinct from ETL: that pulls from external systems on a schedule; this is a user clicking 'import' on their own file, right now.
by @ops
Bun + Postgres + Redis: License Validation & Anti-Piracy Check-in Service
Ongoing runtime license validation for desktop/plugin software — distinct from Digital Asset & License Delivery: that issues a license at purchase, this is the repeated phone-home check every time the software actually runs.
by @ops
Content Moderation Pipeline
A flag-and-review queue for user-generated content — Postgres for submissions and moderation decisions, Redis for the queue, a worker for automated pre-screening before a human ever looks at it. For any platform with comments, uploads, or listings that aren't pre-vetted.
by @ops
Customer Onboarding Progress Tracking
Onboarding checklist steps and completion state per account — distinct from Drip Campaigns: that's the emails sent during onboarding, this is tracking whether the user actually did the things.
by @ops
Data Deduplication & Entity Resolution Service
Matching and merging likely-duplicate records (contacts, customers, companies) via a worker doing the actual resolution — the backend behind "these two records are probably the same person" at any real scale of data.
by @ops
Document Generation Service
PDF/invoice generation as its own service — templates and records in Postgres, a worker that generates documents asynchronously instead of blocking a request while a PDF renders.
by @ops
Dynamic Pricing / Rate Card Engine
Real-time price calculation from rules (demand-based, time-based, tiered) — distinct from Usage Metering (bills for consumption) and Membership (gates access): this recipe just calculates what something costs right now, it doesn't bill or gate anything itself.
by @ops
Elixir + MySQL + Mailpit
A Phoenix-style Elixir API on MySQL instead of Postgres, with local email testing via Mailpit.
by @ops
Elixir + Postgres + Redis: IoT Device Fleet Command & Control
Sending commands TO a device fleet and tracking acknowledgment state — distinct from the Rust + Kafka + ClickHouse IoT Telemetry recipe: that ingests data FROM devices, this is the reverse direction, a control plane rather than an ingestion pipeline.
by @ops
Elixir + Postgres + Redis: Smart Home Automation Rules Engine
If-this-then-that automation logic evaluated against device state — distinct from IoT Fleet Command & Control: that sends commands and tracks device state, this is the rules/automation LAYER deciding when those commands should fire.
by @ops
File Upload & Media Processing
Postgres for records, MinIO for S3-compatible object storage, and a background worker already wired in for the actual processing — resizing images, transcoding video, generating thumbnails — instead of doing it inline and blocking the request.
by @ops
Fraud & Anomaly Detection Scoring Backend
Scores transactions/events against rules and patterns via a worker, flagging anomalies for review — distinct from the Audit Log recipe: that records what happened, this decides whether what happened looks wrong.
by @ops
Go + Postgres + Redis: Multi-warehouse Inventory Allocation & Routing Engine
Decides which warehouse should fulfill a given order based on stock and proximity — distinct from the Warehouse Management System recipe: that's single-warehouse physical operations, this is the routing decision across multiple locations.
by @ops
Go + Postgres: IT Access Request & Approval Workflow
Requesting access to an internal system or tool, with an approval chain before it's granted — a common enterprise IT pattern distinct from Employee Onboarding (broader checklist) and generic approval workflows elsewhere: this is specifically access-grant requests.
by @ops
Internal Admin / Back-office Tool Backend
A CRUD-heavy backend shaped for internal tooling — the API behind an admin panel or ops dashboard, not a public product. Postgres for records, Redis for session/cache, nothing over-engineered for a tool only your own team uses.
by @ops
Java (Spring) + Kafka + Postgres: Event Sourcing / CQRS Reference Backend
A reference implementation of the event-sourcing/CQRS pattern — Kafka as the event log, a worker rebuilding read models from events. For teams who want this specific architectural pattern as a starting point, not a business vertical.
by @ops
Java (Spring) + Kafka + Postgres: Order Saga / Distributed Transaction Backend
Saga orchestration for multi-step transactions across services — Kafka carrying saga events, a worker managing compensation logic when a step fails partway through. For teams past a single-database transaction being enough.
by @ops
Java (Spring) + Postgres + Redis: Healthcare-oriented Baseline
A security-conscious starting point for patient-data-adjacent backends: Spring Boot API, Postgres for structured clinical/administrative records, and Redis for session state. This is a starting baseline only, not a certified or verified HIPAA/regulatory-compliant stack — your own security and compliance review is still required before handling real patient data.
by @ops
Java (Spring) + Postgres + Redis: University Enrollment & Registration Backend
Semester registration, course capacity, and waitlist handling — distinct from the Course & Learning Management baseline (content/progress) and Applicant Tracking (hiring): this is specifically the enrollment/registration period every term, with real capacity-limit concurrency concerns.
by @ops
Java (Spring) + Postgres + Redis: Vehicle/Equipment Leasing & Depreciation Tracking
Lease terms, depreciation schedules, and asset lifecycle records, a worker running scheduled depreciation calculations — a genuine fintech-adjacent vertical distinct from anything else in the catalog.
by @ops
Java (Spring) + Postgres: Batch Payroll Processing Backend
Pay periods, batch calculation runs, and a worker processing payroll on schedule — a vertical baseline distinct from Expense Reporting and Timesheets: those track hours and claims, this is the actual pay-run calculation and record-keeping.
by @ops
Java (Spring) + Postgres: Clinical Trial Data Capture (EDC) Backend
Structured research data capture for clinical trials — distinct from the general Healthcare-oriented Baseline: that's patient-data-adjacent backends broadly, this is specifically regulated trial data capture with its own audit and protocol-adherence requirements.
by @ops
Java (Spring) + Postgres: Government Benefits Case Management
Benefit applications, case worker assignment, and eligibility decision records — distinct from Grant Application & Review: that's discretionary funding decisions, this is structured public-sector benefits processing with its own compliance shape.
by @ops
Java (Spring) + Postgres: Loan Origination & Underwriting Backend
Loan applications, underwriting decision records, and approval workflow — distinct from the Insurance Quoting Engine: same shape of problem, different regulated vertical, real lending-specific data model.
by @ops
Java (Spring) + Postgres: Manufacturing Quality Control & Defect Tracking
Inspection records, defect classification, and batch quality data — a real industrial vertical, distinct from Supply Chain Traceability (that follows a product through custody, this evaluates whether it passed quality checks along the way).
by @ops
Java (Spring) + Postgres: Membership Association & Dues Management
Membership records, dues billing cycles, and renewal tracking for professional associations or unions — a worker processing dues billing runs. Distinct from Membership & Tiered Access: that's SaaS feature-gating, this is real association-membership administration with its own renewal rules.
by @ops
Java (Spring) + Postgres: Supply Chain Traceability & Chain-of-Custody
Batch/lot tracking through a supply chain with a full chain-of-custody record — distinct from Fleet Tracking (vehicles) and Vendor Management (supplier relationships): this tracks the product itself moving through custody, food-safety and pharma-adjacent.
by @ops
Java (Spring) + Postgres: Utility Billing & Meter Reading Backend
Physical meter readings and utility billing calculation, a worker processing reading batches into bills — distinct from Usage Metering & Billing: that's SaaS API consumption, this is real utility meters (water/gas/electric) and their own billing cycle rules.
by @ops
Multi-tenant SaaS Starter
Tenant-scoped Postgres schema convention with Redis for tenant-aware sessions and caching — the foundation every B2B SaaS ends up needing, built in from the start instead of retrofitted after the first enterprise customer asks for data isolation.
by @ops
Node + Postgres + Redis: Applicant Tracking Baseline
Job postings, applications, and interview-stage pipeline state — the backend behind an ATS or internal hiring tool, with Redis for the pipeline-board views that need to stay fast.
by @ops
Node + Postgres + Redis: Course & Learning Management Baseline
A starting point for course/lesson-structured products: enrollment, progress tracking, and completion state in Postgres, Redis for session/progress caching. Vertical-flavored baseline, same pattern as the Fintech and Healthcare starters — not a certified LMS/SCORM-compliant stack.
by @ops
Node + Postgres + Redis: Crowdfunding Campaign Baseline
Time-boxed campaigns with funding goals and reward tiers, Stripe-connected, a worker handling pledge capture at campaign close. Distinct from Nonprofit Donor & Campaign: that's ongoing fundraising relationships, this is one campaign with a deadline and a goal.
by @ops
Node + Postgres + Redis: Dating & Matching Algorithm Baseline
Profile compatibility scoring, swipe/match state, and mutual-match detection — a starting shape for any two-sided matching product, not just dating specifically.
by @ops
Node + Postgres + Redis: Employee Directory & Org Chart Baseline
Employee records, reporting lines, and org structure as queryable data — a simple internal-tooling vertical baseline, same pattern as the other Backend baselines.
by @ops
Node + Postgres + Redis: Equipment & Asset Tracking Baseline
Owned equipment, assignment/checkout history, and maintenance schedules — distinct from Inventory & Order Management: that's sellable stock moving through a sale, this is owned assets that come back.
by @ops
Node + Postgres + Redis: Event Registration & Ticketing Baseline
Event listings, ticket tiers, registration, and check-in state, with Stripe wired in for paid tickets. The backend behind an event platform, not a generic e-commerce checkout.
by @ops
Node + Postgres + Redis: Expense Reporting & Reimbursement Baseline
Expense claims, receipt records, and approval-chain state — distinct from Timesheet: that tracks hours worked, this tracks money employees are owed back.
by @ops
Node + Postgres + Redis: Field Service Dispatch Baseline
Work orders, technician assignment, and job status in the field — distinct from Booking & Appointment Scheduling: that's the customer reserving a slot, this is dispatching someone to actually do the work.
by @ops
Node + Postgres + Redis: Fleet & Vehicle Tracking Baseline
Vehicle location, maintenance schedules, and driver assignment — the logistics-vertical counterpart to Geofencing & Location Tracking, focused on a managed fleet rather than general mobile location features.
by @ops
Node + Postgres + Redis: Franchise & Multi-location Operations Baseline
Per-location performance, compliance checklists, and franchisee records rolled up to an owner view — a starting shape for any multi-location operator, not a single-site business.
by @ops
Node + Postgres + Redis: Grant Application & Review Baseline
Grant applications, reviewer assignment, and scoring/decision workflow — distinct from Nonprofit Donor & Campaign: that's fundraising, this is giving money away in a structured, auditable way.
by @ops
Node + Postgres + Redis: Nonprofit Donor & Campaign Baseline
Donor records, campaigns, and recurring-donation billing via Stripe, with a worker handling the recurring charge cycle. A vertical baseline for donation/fundraising platforms specifically, not generic subscription billing.
by @ops
Node + Postgres + Redis: Physical Access Control / Badge System Baseline
Badge/access records, door-event logs, and access-group permissions — a real, if niche, vertical baseline for office/facility access systems.
by @ops
Node + Postgres + Redis: Procurement & Purchase Order Baseline
Vendors, purchase orders, and approval workflow before money leaves the building — distinct from Inventory & Order Management: that's selling stock, this is buying it.
by @ops
Node + Postgres + Redis: Property & Lease Management Baseline
Listings, leases, tenants, and maintenance requests as structured records — the operational backend behind a property management product, not a public listings site.
by @ops
Node + Postgres + Redis: Vendor & Supplier Management Baseline
Vendor onboarding, contract terms, and performance/scorecard tracking over time — distinct from Procurement: that's the transactional PO flow, this is the ongoing vendor relationship.
by @ops
Node + Postgres: Insurance Claims Processing Baseline
Claims intake, adjudication status, and document attachment records, with a worker processing claims through their status pipeline. A starting baseline for claims-adjacent backends — not a certified or regulator-approved insurance system.
by @ops
PHP + MySQL + Redis: Legacy CMS Migration Bridge
An API layer in front of an existing legacy MySQL-backed CMS database, Redis caching the translation layer — for teams modernizing incrementally instead of doing a risky big-bang rewrite of a system still running production content.
by @ops
PHP + Postgres + RabbitMQ
A queue-driven PHP backend (no framework baked in) using Postgres and RabbitMQ for async job processing.
by @ops
PHP + Postgres + Redis: Digital Signage / Content Scheduling Backend
Manages what displays on screens/kiosks and when, a worker handling scheduled content swaps — a real, distinct vertical for anyone managing physical displays, not yet touched anywhere in the catalog.
by @ops
PHP + Postgres + Redis: Real Estate Listing Syndication Backend
Syndicating property listings out to multiple external platforms with a worker handling the sync — distinct from Property & Lease Management: that's landlord/tenant/lease operations, this is MLS-style multi-platform listing distribution.
by @ops
PHP + Postgres + Redis: Restaurant Kitchen Display System (KDS)
Order routing to kitchen prep stations with timing/status tracking — distinct from Food Order & Delivery Tracking: that's the customer-facing order lifecycle, this is what happens on the kitchen's screen the moment an order comes in.
by @ops
Python + MariaDB + Redis: Legacy-friendly Baseline
A Python backend built around MariaDB — a natural fit for teams migrating off older MySQL-family systems without a database rewrite — with Redis for caching and session state layered on top.
by @ops
Python + Postgres + Redis: Employee Onboarding & Offboarding Checklist Automation
IT provisioning, equipment, and paperwork checklists for new hires and departing employees, a worker tracking completion — distinct from Customer Onboarding Progress Tracking: that's product feature adoption, this is internal HR/IT process for actual employees.
by @ops
Python + Postgres + Redis: Personal Finance Budgeting & Categorization Backend
Transaction categorization and budget tracking for a consumer finance app — distinct from the Ledger recipe (business double-entry accounting) and Digital Wallet (stored value): this is the Mint/YNAB-shaped personal budgeting category.
by @ops
Ruby + Postgres + Redis: B2B Contract Lifecycle & Renewal Management
Contract terms, renewal dates, and auto-renew/notice-period tracking with a worker flagging upcoming renewals — distinct from Subscription Dunning: that's payment-failure recovery, this is the contractual side of B2B relationships, often on annual terms with no billing event to hook into.
by @ops
Ruby + Postgres + Redis: Gradebook & Assessment Backend
Assignments, scores, and grade calculation as structured records — distinct from the Course & Learning Management baseline: that tracks enrollment/progress through content, this is specifically grading and assessment.
by @ops
Ruby + Postgres + Redis: Podcast Dynamic Ad Insertion
Per-listener dynamic ad insertion into podcast audio feeds, with Redis for fast ad-slot decisioning at request time — distinct from Server-Side Ad Serving: that's general web ad placement, this is specifically audio/podcast-feed insertion.
by @ops
Ruby + Valkey + MinIO
A lean Ruby API (no Rails) using Valkey for caching and MinIO for S3-compatible object storage.
by @ops
Rust + Postgres + Redis + Kafka: Order Matching Engine
A price-time-priority order book and matching engine — Kafka carrying order events, Redis for the live book state, Postgres for settled trade history. Infrastructure pattern for anyone building a market/exchange-shaped product, not investment guidance.
by @ops
Rust + Postgres + Redis: Sports/Event Odds Pricing Engine
Real-time odds calculation from event probabilities — infrastructure for computing and updating prices as conditions change, the same low-latency pricing-engine shape as the RTB Ad Exchange and Order Matching recipes, applied to a different domain.
by @ops
Rust + Postgres: Cryptographic Key Management Service
Key lifecycle, rotation tracking, and signing-operation records in Postgres, Rust for the performance and memory-safety a crypto-adjacent service actually wants. Distinct from Secrets & Config Management: that's general app secrets, this is specifically key material and signing operations.
by @ops
Rust + Redis + Kafka: Real-time Bidding (RTB) Ad Exchange Backend
Sub-100ms bid-request handling for a real-time bidding ad exchange — Kafka carrying bid events, Redis for the fast auction state. Distinct from Server-Side Ad Serving: that places ads directly, this is the exchange protocol connecting multiple bidders on a strict clock.
by @ops
Server-Side Ad Serving Backend
Ad slot definitions, targeting rules, and impression/click tracking served server-side — a real, distinct vertical for anyone building ad-supported placements without relying entirely on a third-party ad network.
by @ops
Social Graph / Follow-Feed Backend
Following/followers as a real graph, with Redis-cached feed generation instead of an expensive JOIN on every page load. The same shape of problem Stacktora's own Vault profile/follower system has to solve.
by @ops
Time Tracking & Timesheet Backend
Time entries, projects, and approval state in Postgres, Redis for the active-timer state that needs to be fast. The backend behind any internal time-tracking or client-billing-hours tool.
by @ops
Waitlist & Invite-code Access Backend
Signup waitlists, position tracking, and invite-code-gated access — the backend behind a controlled rollout or invite-only launch, not a full membership system.
by @ops
Background Jobs 4
Data Pipeline / ETL Starter
Python + Kafka + a Celery worker for real batch/stream data processing — scheduled transforms and event-driven pipelines, not an on-demand job queue. Distinct from the Job Queue & Scheduler recipe: that's request-triggered background work, this is data moving on its own schedule.
by @ops
Go + Postgres + Redis: Distributed Cron / Scheduled Task Runner
Scheduled tasks that run exactly once across multiple app instances — Redis-backed leader election so a scaled-out deployment doesn't run the same cron job N times. Distinct from Job Queue & Scheduler: that's a general queue, this specifically solves multi-instance double-execution.
by @ops
Job Queue & Scheduler
A dedicated background-job starter — Redis-backed queue plus Postgres for job records, with a worker process already wired in. Not tied to one specific web framework's job-queue convention.
by @ops
Reverse ETL / Data Warehouse Sync
Pushing data FROM your app OUT to external tools (a CRM, a spreadsheet, an ads platform) on a schedule — the opposite direction from the Data Pipeline/ETL recipe, which pulls data in. A worker handles the sync so it never blocks a request.
by @ops
Compliance 13
.NET + Postgres: Regulatory Filing & Reporting Deadline Tracker
Tracks regulatory filing deadlines (tax, compliance reports) with a worker flagging upcoming due dates — distinct from Vendor Risk and Certification tracking: this is specifically about deadlines and filings, not vendor assessment or control evidence.
by @ops
.NET + Postgres: Vendor Security Questionnaire & Third-party Risk Tracking
Vendor security questionnaires, response tracking, and risk scoring for third-party vendor assessment — distinct from Compliance Certification & Audit Evidence: that tracks YOUR OWN controls, this assesses the vendors and partners you depend on.
by @ops
Compliance Certification & Audit Evidence Tracker
Tracks control status and collects audit evidence for certifications like SOC 2 or ISO 27001 — distinct from GDPR/Consent/Retention: those handle user data rights, this is evidence that YOUR controls are actually being followed.
by @ops
Consent Management Platform
Cookie/privacy consent capture and an auditable record of what a user agreed to and when — distinct from the GDPR Data Rights recipe: that handles export/deletion requests after the fact, this is the consent record those requests get checked against.
by @ops
Data Masking & Synthetic Test Data Generator
Generates realistic-but-fake data for staging/test environments via a worker, so real customer data never has to leave production. A genuine compliance concern hiding as a DevOps convenience.
by @ops
Data Retention & Archival Policy Service
Scheduled, policy-driven data lifecycle enforcement — archive after X, delete after Y, per data type — with a worker that actually executes retention policy instead of it living only in a document nobody enforces. Distinct from the GDPR recipe: that's user-initiated requests, this runs on its own schedule.
by @ops
GDPR / Data Rights Request Service
A backend for handling data export and deletion requests properly — request intake, an auditable trail of what was done and when, and a worker to actually walk through deleting/exporting across tables instead of a manual one-off SQL script every time someone asks.
by @ops
Go + Postgres + Redis: API Key Rotation & Credential Lifecycle Management
Scheduled rotation of API keys and credentials with a worker managing the rotation cycle and history — distinct from Secrets & Config Management: that's storage, this is specifically the rotation lifecycle and audit trail of when keys changed.
by @ops
Go + Postgres: Container Vulnerability Scan Tracking Backend
Stores and trends container image vulnerability scan results over time, a worker ingesting scan output — for teams who run the scans already but have nowhere to track findings across builds and see whether things are getting better or worse.
by @ops
Legal Contract & E-signature Workflow
Contract versioning, signature status tracking, and an auditable record of who signed what and when, with a worker processing signature events. A compliance-adjacent pattern: the paper trail matters as much as the contract itself.
by @ops
Python + Postgres: Compliance Training & Certification Tracking
Mandatory employee training assignments and certification expiry tracking, a worker flagging upcoming renewals — distinct from Compliance Certification & Audit Evidence (that's YOUR OWN organizational controls): this tracks individual employees' required training and cert status.
by @ops
Python + Postgres: Policy-as-Code Validation Engine
Validates infrastructure or application configuration against declared policy rules, similar in spirit to Stacktora's own company.stacktora.json enforcement — generalized as a standalone service for validating any structured config against any rule set.
by @ops
Rust + Postgres: Tamper-evident Immutable Audit Ledger
Hash-chained audit records where altering history breaks the chain and is provably detectable — distinct from the standard Audit Log / Activity Trail recipe: that's a normal append-only log, this is cryptographically tamper-evident for a much higher assurance bar.
by @ops
Content 12
Bun + MongoDB + Meilisearch: Knowledge Base / Docs Search
A documentation/knowledge-base platform: Bun API for fast cold starts and low-latency responses, MongoDB for flexible article/page storage, and Meilisearch for instant, typo-tolerant search across the whole knowledge base.
by @ops
Bun + Postgres + Redis: Link-in-Bio / Micro-landing Page Backend
Profile pages, link blocks, and click tracking — the backend behind a Linktree-style micro-landing product, with Bun's fast cold starts suiting a high-traffic, low-compute-per-request workload.
by @ops
Comment System & Threaded Discussions
Nested comment threads with moderation-ready structure — distinct from the CMS recipe (published content) and Chat (real-time messaging): this is asynchronous, threaded discussion attached to a piece of content.
by @ops
Deno + Postgres + MinIO: Headless-to-Static Publishing Pipeline
Builds and publishes static site output FROM headless CMS content, a worker running the build and storing output in MinIO — distinct from the Headless CMS recipe: that serves content dynamically, this compiles it to static output on a schedule or webhook trigger.
by @ops
Go + Postgres + Redis: Content Translation Workflow Backend
Translator assignment and review/approval stages for full content pieces — distinct from Localization/String Management: that's key-value UI string translation, this is a workflow for translating whole articles or pages with human review steps.
by @ops
Headless CMS Backend
A structured content API — Postgres for content models and versioning, Redis caching in front so reads stay fast under real traffic. Bring your own frontend; this is just the content backend done properly instead of hand-rolled.
by @ops
Internal Wiki / Knowledge Base Backend
Structured internal docs with real search — Postgres for pages and revisions, Meilisearch so finding something doesn't mean scrolling through a folder tree. The backend shape behind any internal knowledge base or team wiki.
by @ops
Music/Audio Streaming Metadata & Playback Tracking
Track/catalog metadata in Postgres, playback events landing in ClickHouse for the volume a real streaming product generates — royalty/analytics-ready from day one instead of bolted on after the fact.
by @ops
PHP + Postgres + Elasticsearch + Redis: CMS/Content Platform Starter
A headless CMS / content platform backend: PHP API, Postgres for content and structured records, Elasticsearch for fast full-text and faceted search across content, and Redis for page/query caching.
by @ops
Podcast & RSS Feed Hosting Backend
Episode hosting via MinIO and RSS feed generation from Postgres-stored episode metadata — a specific, real pattern distinct from generic file upload/media processing, which just resizes and transcodes without any feed/publishing model.
by @ops
Ruby + Postgres + Redis: Community Forum & Reputation System
Threads, voting, and karma/reputation scoring — distinct from the Comment System recipe: that's simple threaded discussion attached to content, this is a full forum with its own reputation economy driving what surfaces.
by @ops
Survey & Forms Backend
Structured form/survey definitions and response storage in Postgres — distinct from the Headless CMS recipe: this is about capturing structured input, not serving published content.
by @ops
DevOps 10
A/B Testing & Experimentation Platform
Variant assignment (consistent per user, not re-randomized every request) and results tracking in Postgres, Redis for fast assignment lookups. Distinct from Feature Flags: flags are an on/off switch, this is measuring which variant actually wins.
by @ops
Deno + Postgres: Webhook-triggered Static Site Rebuild/Deploy Service
Receives a webhook (content change, git push) and triggers a static site rebuild, a worker running the actual build/deploy job and recording build history. Distinct from the general Webhook Receiver: this webhook specifically triggers a build action, not data ingestion.
by @ops
Feature Flags & Remote Config Service
A self-hosted feature-flag and remote-config backend — Postgres for flag definitions and targeting rules, Redis for fast reads at request time. For shipping behind flags instead of long-lived branches, without paying for a third-party flagging service.
by @ops
Go + Postgres + MinIO: Container/Artifact Registry Metadata Backend
Image tags, artifact versions, and retention policy as queryable Postgres records, with MinIO storing the actual artifacts — distinct from Vulnerability Scan Tracking: that tracks scan findings, this is the registry itself, storing and indexing what got built.
by @ops
Go + Postgres + Redis: Ephemeral Preview Environment Orchestrator
Spins up and tears down per-PR preview environments, a worker managing the actual orchestration and Redis tracking active environment state — the backend behind 'every pull request gets its own live preview URL.'
by @ops
Go + Postgres + Redis: Internal Service Catalog & Ownership Registry
A Backstage-style catalog of internal services, their owning teams, and metadata — a real platform-engineering pattern for organizations with enough internal services that 'who owns this and what does it do' stops being obvious.
by @ops
Go + Postgres: API Mocking & Contract Testing Service
Serves mock responses matching a defined API contract, so frontend teams can build against an API before the real backend exists — a dev-tooling pattern, distinct from anything customer-facing in this catalog.
by @ops
Python + Postgres + Redis + LocalStack: Serverless Local-Dev Starter
A serverless-style backend developed entirely against local AWS emulation: Python API, Postgres for relational data, Redis for caching, and LocalStack standing in for S3, SQS, and other AWS services — full local development with zero real AWS cost or credentials needed.
by @ops
Python + Postgres: Configuration Drift Detection Service
Compares live infrastructure state against declared configuration on a schedule and flags drift — the same problem Stacktora's own compliance auditing solves for a single stacktora.json, generalized as its own standalone service.
by @ops
Translation & Localization String Management
A self-hosted string/translation management service — keys, locales, and translation status per string, Redis-cached for fast lookups at request time. For teams past spreadsheet-based translation handoffs.
by @ops
E-commerce 15
Bun + Postgres + Redis: Freelance/Gig Marketplace with Milestone Payments
Project milestones, escrow-style payment release via Stripe Connect, and dispute state, a worker processing milestone payouts — distinct from the general Marketplace and Escrow recipes: this is specifically freelance-work-shaped, with milestones instead of a single transaction.
by @ops
Coupon & Promotion Engine
Discount codes, promotion rules (percentage, fixed amount, BOGO), and redemption tracking with Redis guarding against a code being used past its limit under concurrent requests. The part of checkout that's deceptively easy to get wrong at the edges.
by @ops
Digital Asset & License Delivery
Selling downloads or license keys instead of physical goods — secure, expiring download links and license activation state in Postgres, Redis for fast validation on every activation check. Distinct from a physical-goods storefront or a marketplace.
by @ops
Food Order & Delivery Tracking Backend
Order lifecycle from placed through delivered, with Redis for live status that needs to update in near-real-time. Distinct from the Marketplace recipe: this is a linear order-to-delivery pipeline, not multi-vendor listings.
by @ops
Inventory & Order Management
Stock levels, orders, and fulfillment state as first-class Postgres records, with Redis for cart/session speed — the operational backend behind a storefront, not the storefront itself. Distinct from a checkout/payments starter: this is what happens after the payment succeeds.
by @ops
Inventory Reservation & Overselling Prevention
Redis-backed distributed locking around the checkout moment so two customers can't both buy the last unit — distinct from Inventory & Order Management: that tracks stock levels generally, this specifically prevents overselling under real concurrency.
by @ops
Loyalty & Rewards Points Program
Points accrual and redemption as a real ledger of transactions, not a single mutable balance column — distinct from Coupon & Promotion (single-use codes) and Referral (attribution/payouts): this is an ongoing points economy.
by @ops
Node + Postgres + Redis + MinIO + RabbitMQ: Marketplace Starter
A multi-vendor marketplace backend: Node API, Postgres for catalog/inventory/orders, Redis for cart/session caching, MinIO for product image storage, and RabbitMQ for async order and fulfillment processing.
by @ops
PHP + Postgres + Redis: Influencer Campaign Tracking & Payout
Content/post tracking against campaign terms and performance-based payout tiers via Stripe, a worker processing payout runs — distinct from the Referral Program recipe: that's a simple referred-by-code system, this tracks actual campaign content and negotiated performance terms.
by @ops
PHP + Postgres + Redis: Print-on-Demand Order Routing Backend
Routes print-on-demand orders to different fulfillment vendors based on product type and location, a worker handling the routing decision and vendor hand-off — distinct from Marketplace and Food Delivery: this is vendor-routing logic specific to print/merch fulfillment.
by @ops
Referral Program Backend
Referral codes, attribution tracking, and reward payouts as first-class records — distinct from a coupon engine: this tracks who referred whom and what they're owed for it, not just a discount at checkout.
by @ops
Ruby + Postgres + Redis: Gift Registry & Wishlist Backend
Registries, wishlists, and purchase-reservation state (so two people don't buy the same gift) — a real, distinct e-commerce pattern with its own concurrency concern nothing else in the catalog handles.
by @ops
Shipping Label & Fulfillment Backend
Order-to-label generation and carrier hand-off, with a worker processing fulfillment asynchronously — distinct from Food Order & Delivery Tracking: that's a live delivery pipeline, this is print-a-label-and-ship.
by @ops
Two-sided Marketplace Backend
Vendors, listings, and buyers as first-class concepts, with Stripe Connect wiring for split payouts. Distinct from a single-storefront e-commerce backend: multi-party accounts and payouts are the actual hard part of a marketplace, not the product listing.
by @ops
Warranty & RMA Management
Return/warranty claim intake, status tracking, and resolution state — the backend behind the part of e-commerce that happens after the sale, when something needs to come back.
by @ops
Full-stack 2
Bun + Postgres + Redis: Real-time Dashboard Full-stack Starter
A genuine full-stack starter for live-updating dashboards — Bun's fast cold starts and native WebSocket support suiting a product where the dashboard needs to feel instant, not just correct.
by @ops
Node + Vite/React + Postgres + Redis: Full-stack SaaS Starter
A genuine full-stack SaaS starter — Node API and a Vite + React frontend wired together out of the box, Postgres for accounts and application data, and Redis for sessions and caching. Run one sync and get a working frontend and backend talking to each other, not just an API.
by @ops
Infrastructure 12
Deno + Redis: CDN Purge Coordination Service
Coordinates CDN edge-cache purges when underlying data changes — distinct from general cache invalidation: this is specifically about telling a CDN 'this URL is stale now,' not app-level in-memory cache coherence.
by @ops
Elixir + Postgres: Background Jobs Microservice
A pure queue-consumer microservice, no public HTTP API surface — Elixir's native concurrency plus a Postgres-backed job queue (the same pattern as Oban) for reliable, retryable background processing. Postgres alone is the queue backend here; no separate broker like Redis or RabbitMQ is needed.
by @ops
Go + Mailpit + Redis + RabbitMQ: Notification Delivery Service
A dedicated notification/delivery microservice: Go for efficient concurrent delivery workers, RabbitMQ queuing outbound notifications so spikes never get dropped, Redis for delivery-status and dedup tracking, and Mailpit for safe local email testing without hitting a real inbox.
by @ops
Go + Postgres + Redis: Smart Parking / Space Availability Backend
Real-time space-occupancy tracking and availability queries, Redis for the fast lookups a live parking-availability map needs — a smart-city-shaped IoT application distinct from generic device telemetry.
by @ops
Go + Postgres: DNS Record Management & Zone Sync Backend
Programmatic DNS record and zone management as structured Postgres records — real infrastructure-automation surface for teams managing DNS across many domains or subdomains without a manual dashboard.
by @ops
Go + Redis + NATS: Distributed Lock & Coordination Service
A distributed locking and leader-election primitive as its own service — Redis for the lock state, NATS for coordination messaging across instances. The low-level infra piece that sits underneath 'only one instance should do this at a time.'
by @ops
Rust + Postgres + MinIO: Backup & Snapshot Orchestration Service
Scheduled backups and snapshot management, storing snapshots in MinIO with a worker handling the actual backup runs and retention. Distinct from Data Retention & Archival: that's deletion policy, this is making sure backups actually happen and are recoverable.
by @ops
Rust + Postgres + Redis: Digital Twin State Synchronization Backend
Maintains a queryable virtual model kept in sync with real physical device/system state — distinct from IoT Telemetry Ingestion: that stores raw sensor data, this maintains a current, queryable STATE MODEL derived from it.
by @ops
Rust + Postgres + Redis: On-chain Transaction Indexer
Indexes blockchain transaction data into a queryable Postgres store, a worker processing new blocks as they arrive, Redis tracking indexing progress. Infrastructure for querying chain data quickly — not a wallet, not trading logic.
by @ops
Rust + Postgres: Internal Certificate Authority (PKI) Backend
Issues and tracks internal certificates for service-to-service authentication — distinct from Certificate & Domain Expiry Monitoring (that watches external certs): this is an internal CA actually issuing them.
by @ops
Rust + Redis: Distributed Cache Invalidation & Coherence Service
Keeps caches coherent across multiple app instances — invalidation events propagated so a write on one instance doesn't leave stale reads on another. Low-level infra distinct from anything domain-specific in this catalog.
by @ops
Secrets & Config Management Service
A self-hosted secret store with access-scoped retrieval and rotation tracking — Postgres for encrypted values and audit trail, Redis for fast reads. For teams not ready to stand up a full Vault/KMS but past the point of secrets living in a shared doc.
by @ops
Mobile 17
Expo + Node + Postgres + Redis: Mobile Social Feed App
A real Expo mobile client generated alongside the backend, not just an API serving unspecified mobile traffic — feed posts and likes in Postgres, Redis for feed caching. Point-and-run on a physical device via Expo Go from the first `stacktora sync`.
by @ops
Expo + Node + Postgres + Redis: Mobile Team Chat App
A real Expo client for team messaging, Redis handling live message delivery state — built to run on a device via Expo Go immediately, not just an API a mobile team would eventually wire a client to themselves.
by @ops
Expo + Node + Postgres: Mobile Event Check-in & Ticketing App
A real Expo client for scanning/validating tickets at an event door — pairs with the Event Registration & Ticketing backend, this time with an actual door-staff app instead of assuming one gets built later.
by @ops
Expo + Python + Postgres + pgvector: Mobile AI Assistant App
A real Expo client talking to an LLM-backed Python API with pgvector for context retrieval — a real mobile AI-chat client, not just the backend other recipes in this catalog provide for web clients.
by @ops
Flutter + Go + Postgres + Redis: Mobile Delivery Driver App
A real Flutter client for delivery drivers — order assignment and status updates — Redis for the live location/status state a delivery app needs fast.
by @ops
Flutter + Java + Postgres + Redis: Mobile Patient Portal App
A real Flutter client for patients — appointments and records access — paired with the Spring Boot healthcare-oriented backend pattern used elsewhere in the catalog.
by @ops
Flutter + Python + Postgres: Mobile Personal Finance Tracker App
A real Flutter client backed by Python for expense tracking and budget categorization on the go — the mobile-client counterpart to the Personal Finance Budgeting backend, this time with an actual app to install on a phone.
by @ops
Flutter + Ruby + Postgres + Redis: Mobile Booking & Scheduling App
A real Flutter client for browsing availability and booking appointments — Ruby backend handling the actual slot logic, Redis preventing double-booking under concurrent taps.
by @ops
Geofencing & Location Tracking Backend
Location updates, geofence definitions, and enter/exit event detection in Postgres, with Redis for the last-known-position lookups that need to be fast. The backend shape behind delivery tracking, ride-hailing, or any location-aware mobile feature.
by @ops
Mobile Backend-as-a-Service
Postgres + Redis backend shaped for mobile clients specifically: auth, sync-friendly data access, and Redis ready for push-notification queuing. A real starting point instead of reaching for a generic web API stack and bolting mobile concerns on after.
by @ops
Node + Postgres + Redis: Mobile App Version Gating & Force-Update Backend
Minimum supported app version checks and force-update logic — distinct from Push Device Registry and Mobile BaaS: this is specifically the 'your app version is too old, please update' gate every mobile team eventually needs and usually builds ad hoc.
by @ops
Push Notification Device Registry
Device token registration, platform (APNs/FCM) tracking, and subscription/topic state — the piece that has to exist correctly before the Notification Dispatch recipe's sends actually reach a device. Distinct from both: dispatch sends, this tracks who can receive.
by @ops
Python + Expo + Postgres + Redis: Mobile App Backend
A backend built specifically for a mobile app: Python API paired with a real Expo (React Native) app scaffold, Postgres for user/app data, and Redis for sessions, push-token caching, and rate limiting.
by @ops
React Native + Go + Postgres + Redis: Mobile Fitness Tracker App
A real React Native client plus a Go backend for workout logging and progress tracking — distinct from the Expo recipes: bare React Native for teams who want native module access Expo's managed workflow doesn't offer.
by @ops
React Native + Go + Postgres: Mobile Barcode Inventory Scanner App
A real React Native client for warehouse/retail staff scanning stock — bare RN chosen specifically because barcode-scanning native modules need it, not Expo's managed workflow.
by @ops
React Native + Java + Postgres: Mobile Field Service Technician App
A real React Native client for field technicians — work order details and status updates from the field — paired with the Spring Boot backend pattern used elsewhere in the catalog's field-service recipe.
by @ops
React Native + Node + Postgres + Redis: Mobile Marketplace App
A real React Native client for browsing and listing items — the mobile-client counterpart to the web-facing Marketplace recipe, for teams whose buyers and sellers are primarily on phones.
by @ops
Notifications 5
Bun + Postgres + Redis: In-app Notification Center / Activity Feed
The bell-icon dropdown showing recent activity, read/unread state, Redis for fast unread counts — distinct from Notification Dispatch and Newsletter Management: those send to external channels (email/SMS/push), this is the in-app feed itself.
by @ops
Email Deliverability & Bounce Management
Bounce, complaint, and suppression-list tracking with a worker processing provider webhooks — distinct from Newsletter/Subscriber Management: that's the list itself, this is keeping your sending reputation intact.
by @ops
Newsletter & Subscriber List Management
Subscriber lists, campaign sends, and unsubscribe/bounce handling — distinct from both other Notifications recipes: Dispatch is transactional sends, Drip is onboarding sequences, this is an actual mailing list with real subscriber lifecycle.
by @ops
Notification Dispatch Service
Outbound email/SMS/push, unified — delivery records in Postgres, a Redis-backed queue, and a worker already wired in for async, retry-safe sending. The opposite direction from the Webhook Receiver recipe (that's inbound events; this is notifications you're sending out).
by @ops
Onboarding & Drip Campaign Service
Scheduled, multi-step email sequences (day 0, day 3, day 7…) with a worker to send them on time. Distinct from the Notification Dispatch recipe: that's immediate/transactional sends; this is sequences that unfold over days or weeks.
by @ops
Observability 5
Centralized Logging & Metrics Pipeline
A self-hosted log/metrics ingestion API on ClickHouse — built for high-volume writes — with Redis for buffering and dedup ahead of it. For teams past the point where grepping log files or a single Postgres table cuts it.
by @ops
Go + MongoDB + Kafka: Logging/Observability Pipeline
A centralized logging and observability backend: Go ingestion API, MongoDB for flexible, schema-less log storage, and Kafka as the durable ingestion buffer so log volume spikes never take down the pipeline.
by @ops
Go + Postgres + Redis: Certificate & Domain Expiry Monitoring
Watches SSL certificate and domain expiration dates, a worker checking on schedule — distinct from Uptime & Status: that checks if an endpoint responds right now, this catches the thing that fails silently weeks in advance until it suddenly doesn't.
by @ops
Incident Management & On-call Backend
Internal incident tracking, on-call rotation state, and postmortem records — distinct from the Uptime & Status Page recipe, which is the external, customer-facing side. This is what your team sees when something breaks, not what your customers see.
by @ops
Uptime & Status Page Backend
Monitor a set of URLs, record pass/fail history, and serve a public status page from the same data — the same shape as Stacktora's own dogfooding project for this exact use case. A worker performs the periodic checks; Postgres holds the history.
by @ops
Payments 8
Digital Wallet / Stored Balance Backend
A stored-value balance (gift cards, in-app currency, prepaid credit) with Postgres as the source of truth and Redis for fast balance checks — distinct from the Ledger recipe (double-entry accounting) and Usage Metering (consumption billing): this is money already collected, sitting in an account, waiting to be spent.
by @ops
Go + Postgres + Redis: Marketplace Escrow & Split Payment Backend
Holds funds in escrow until release conditions are met, then splits payouts via Stripe Connect, a worker processing the release logic — distinct from the general Marketplace recipe and from the Ledger: this is specifically the escrow/hold mechanism sitting between a buyer's payment and a seller's payout.
by @ops
Ledger & Double-Entry Accounting Starter
A Postgres-only backend built around double-entry bookkeeping — tracking balances and money movement correctly, not processing payments. Distinct from a Stripe/subscription starter: this is for internal ledgers, marketplaces splitting payouts, or anything that has to get "where did this dollar go" provably right.
by @ops
Membership & Tiered Access Backend
Membership tiers gating feature/content access, Stripe-connected for the billing side, Redis for fast access checks on every request. Distinct from Usage Metering: that bills for consumption, this is a fixed tier granting or denying access.
by @ops
Multi-currency & FX Conversion Service
Currency conversion with rate caching and a worker keeping exchange rates fresh — distinct from the Ledger recipe: that records transactions correctly, this is what makes cross-currency amounts comparable in the first place.
by @ops
Node + Stripe SaaS Starter
A subscription SaaS backend: Node API, Postgres for customers/subscriptions, Redis for webhook idempotency, and a background worker for async Stripe event processing.
by @ops
Subscription Dunning & Pause/Resume Management
Failed-payment retry logic (dunning), and pause/resume subscription state via Stripe and a worker — the specific, often-mishandled part of subscription billing: what happens when a card fails, not just what happens when it succeeds.
by @ops
Usage Metering & Billing
Track consumption — API calls, tokens, seats, whatever your unit is — in Postgres with Redis for fast real-time counters, and turn it into billable line items via Stripe. Distinct from a subscription-SaaS starter: this is for usage-based pricing, not flat monthly plans.
by @ops
Real-time 17
Bun + Postgres + Redis: Live Trivia / Game Show Host Backend
Host-driven, synchronized live rounds with timed audience responses — distinct from the Turn-Based Multiplayer recipe: that's async turns at each player's own pace, this is a live host controlling pacing for everyone simultaneously, Kahoot-shaped.
by @ops
Bun + Postgres + Redis: Real-time Collaborative Code Editor Backend
Multi-cursor, multi-editor operation sync for a shared code editing surface — distinct from the Whiteboard recipe: same broadcast-and-sync shape, applied to a text/code document instead of a drawing canvas, a genuinely different data model and conflict-resolution need.
by @ops
Chat & Messaging Backend
Message history in Postgres, presence and pub/sub fan-out via Redis — the actual backend shape a real-time chat feature needs, not just a raw WebSocket server with nowhere to put the messages.
by @ops
Deno + Postgres + Redis: Real-time Collaborative Presentation/Slide Deck Backend
Live slide editing and multi-cursor presence for a shared deck — completes the family alongside the Whiteboard, Code Editor, and Spreadsheet recipes: same broadcast-and-sync shape, applied to a slide/deck data model.
by @ops
Elixir + Postgres + Redis: Live Sports Score & Event Ticker
Live-updating scores and event feeds broadcast to many simultaneous viewers — Elixir/OTP's connection-handling model suiting the fan-out-to-thousands-of-viewers shape of this problem specifically.
by @ops
Elixir + Postgres + Redis: Multiplayer Card Game Backend (Hidden Information)
Imperfect-information game state (each player sees only their own hand) — distinct from the Turn-Based Multiplayer recipe: that's full-information turns like chess, this specifically handles hidden state and what each player is and isn't allowed to see.
by @ops
Elixir + Postgres + Redis: Real-time Collaborative Spreadsheet Backend
Live cell edits, formula recalculation events, and multi-cursor presence — distinct from the Whiteboard and Code Editor recipes: same broadcast-and-sync shape, applied to a cell/formula data model instead of canvas operations or text.
by @ops
Elixir + Postgres + Redis: Turn-Based Multiplayer Game Backend
Persisted game state and move history in Postgres, Redis for active-turn/presence state — distinct from the Rust + Redis + NATS multiplayer recipe: that's fast-tick real-time games, this is async turn-based play (chess/word-game shaped), a genuinely different latency and consistency profile.
by @ops
Elixir + Redis: Presence & Broadcast Service
Who's-online presence and pub/sub broadcast built on Elixir/OTP — the runtime this exact pattern (Phoenix Presence) was designed around, not a port of the idea into a language that has to work harder for the same guarantees.
by @ops
Go + Postgres + Redis + NATS: Real-time Chat Starter
A real-time messaging backend: Go API, Postgres for message history and rooms, Redis for presence and rate limiting, and NATS as the pub/sub backbone for live delivery across instances.
by @ops
Leaderboard & Matchmaking Backend
Score tracking, rankings, and matchmaking queue state via Redis sorted sets, Postgres for persisted match history. The backend shape behind any competitive/gaming feature that needs a live leaderboard, not just a stored high-score table.
by @ops
Live Polling & Audience Engagement Backend
Live polls, Q&A, and real-time result tallying via Redis — the backend behind an event/webinar engagement feature, distinct from Leaderboard/Matchmaking and Auction/Bidding.
by @ops
Real-time Auction & Bidding Backend
Timed bidding windows, live bid updates via Redis pub/sub, and winner determination with proper tie-breaking — distinct from the Marketplace recipe's fixed-price listings: bids change the price in real time and the clock matters.
by @ops
Real-time Collaboration & Presence Backend
Live cursors, who's-online presence, and shared editing state via Redis pub/sub, with Postgres for persisted document snapshots. Distinct from the Chat recipe: chat persists messages as the point; this is ephemeral shared state where the live view IS the point.
by @ops
Rust + Postgres + Redis: Real-time Collaborative Whiteboard Backend
Drawing/canvas operations broadcast and persisted, Redis for the live operation stream, Postgres for saved board state — distinct from the general Collaboration & Presence recipe: this is specifically canvas-operation sync, the Figma/Miro-shaped problem.
by @ops
Rust + Redis + NATS: Multiplayer Game Backend
A low-latency multiplayer game backend: Rust for predictable, high-performance tick processing, Redis for fast-changing player/session state, and NATS as the pub/sub backbone for broadcasting game state across server instances.
by @ops
Rust + Redis: Live Stock/Crypto Price Ticker & Watchlist Backend
A worker streaming live price data into Redis, broadcasting updates to watchlist subscribers — built for the update-every-second-to-thousands-of-viewers shape this specific problem has.
by @ops
Scheduling 4
.NET + Postgres + Redis: Resource & Equipment Reservation System
Reserving shared resources — conference rooms, equipment, vehicles — with Redis-backed conflict prevention at the booking moment. Distinct from Booking & Appointment Scheduling: that's a provider's time slots, this is shared physical resources multiple people compete for.
by @ops
Booking & Appointment Scheduling Backend
Availability windows, booking confirmation, and double-booking prevention (Redis-backed locking around the actual reservation moment) — the backend behind any calendar-booking or appointment product.
by @ops
Video Conferencing Room & Recording Metadata Backend
Meeting room scheduling, participant tracking, and recording metadata — not the media/WebRTC layer itself, but the backend record of who met when and where the recording lives. Distinct from Booking & Appointment: this is meeting-specific, with recording lifecycle attached.
by @ops
Volunteer & Staff Shift Scheduling
Shift definitions, sign-ups, and coverage tracking — distinct from Booking & Appointment Scheduling: that's customer-facing reservations against availability; this is internal staff/volunteer shift coverage.
by @ops
Search 5
Java (Spring) + Postgres + Elasticsearch: Enterprise eDiscovery Search
Litigation-hold-aware document search for legal/compliance teams — distinct from the Meilisearch-based Search-as-a-Service recipe: this targets enterprise eDiscovery requirements (audit trail on searches, hold status), not general product search.
by @ops
Java (Spring) + Postgres + Elasticsearch: Product Catalog Search & Faceted Filtering
E-commerce product search with faceted filtering (price, brand, size, attributes) — distinct from both other Search recipes: Meilisearch-as-a-Service is general-purpose, eDiscovery is legal/compliance-focused, this is specifically catalog search with facets.
by @ops
PHP + Postgres + Elasticsearch: Public Job Board & Resume Search
Searchable public job postings for job-seekers — distinct from the Applicant Tracking baseline: that's internal hiring-pipeline management for one company, this is a public-facing job board serving many employers and candidates.
by @ops
Rust + Redis: Autocomplete & Typeahead Suggestion Backend
Fast prefix-matching suggestions served from Redis — distinct from the full Search-as-a-Service recipe: this is specifically the narrow, latency-critical typeahead-suggestions problem, not full-text search with ranking and filters.
by @ops
Search-as-a-Service Starter
Meilisearch in front of Postgres-stored records — real instant search (typo tolerance, ranking, filters) instead of a slow ILIKE query bolted onto the main database as an afterthought.
by @ops
Support 5
Customer Support Ticketing Backend
Tickets, threaded replies, and status/assignment state in Postgres, with Redis for the stuff that needs to be fast (unread counts, live status). The backend behind a support inbox, not a full helpdesk UI.
by @ops
Elixir + Postgres + Redis: Live Chat Widget & Agent Routing Backend
Real-time chat widget backend with agent availability and routing logic — distinct from Support Ticketing: that's asynchronous threaded tickets, this is live chat with a human on the other end right now, and the routing logic to find them.
by @ops
Python + Postgres + Redis: Customer Support SLA & Escalation Tracking
SLA-breach detection and automated escalation rules, a worker monitoring response-time deadlines — distinct from Support Ticketing: that's the tickets themselves, this is the compliance layer watching whether they're being handled fast enough.
by @ops
Python + Postgres: Knowledge Base Deflection & Self-Service Analytics
Tracks which knowledge base articles actually prevent a support ticket from being filed, a worker computing deflection metrics — distinct from the Wiki/Knowledge Base recipe: that hosts the content, this measures whether it's working.
by @ops
Support Impersonation ("Login as Customer") Tool Backend
Secure, time-limited support impersonation with a full audit trail of who impersonated whom and when — distinct from the Support Ticketing recipe: that's the ticket/thread system, this is the specific, sensitive capability of seeing the product as a customer sees it.
by @ops
Webhooks 4
Inbound Email Processing
Receiving and parsing inbound email (a support-desk reply-by-email, a newsletter bounce handler, anything that turns an email into a database record) via your provider's inbound-parse webhook — the inbound-email counterpart to the general Webhook Receiver recipe.
by @ops
Outbound Webhook Delivery Service
The sending side, not the receiving side — YOUR app delivering webhooks to customers/integrations, with signing, retry/backoff on failure, and a delivery log they (and you) can actually inspect. Pairs with the Webhook Receiver recipe as the complete inbound+outbound picture.
by @ops
Webhook Receiver & Event Ingestion
Idempotent webhook ingestion with signature verification and a Redis-backed queue plus worker for async, retry-safe processing — the pattern every Stripe/GitHub/Twilio integration needs and almost always ends up building from scratch, badly, under time pressure.
by @ops
Webhook Testing & Replay Tool Backend
Captures incoming webhook payloads for inspection and replay during development — a debugging tool, not a production integration. The backend behind a self-hosted "webhook.site"-style utility.
by @ops