templatesopen-sourcemicroapps

Starter Repo: Micro‑App Templates (Dining, Polls, Expense Split) with Serverless Backends

UUnknown

2026-02-18

10 min read

Ready-to-deploy microapp templates (Dining, Polls, Expense Split) with serverless functions, IaC, LLM prompts, and docs to ship in days.

Ship micro‑apps in days: starter repo bundle with templates (Dining, Polls, Expense Split) and serverless backends

Stuck between prototyping in a weekend and shipping a reliable micro‑app to users? Product teams and platform engineers face the same recurring blockers: slow function cold starts, vendor lock‑in, brittle infra scripts, and missing observability. This starter repo bundle—ready‑to‑deploy templates for a Dining app, a Polls microapp, and an Expense Splitter—combines production‑grade function code, infrastructure as code, LLM prompts, and docs so you can move from idea to deployed microapp in days, not weeks.

Why this matters in 2026

By early 2026 the micro‑app trend—driven by improved LLM assistance and fast, portable FaaS runtimes—means non‑specialists can prototype powerful apps quickly. But productionizing those prototypes still requires engineering discipline: observability, cost controls, CI/CD, and portability. Recent moves (Anthropic’s Cowork and Claude Code, wider adoption of snapshot-based fast start mechanisms in cloud runtimes, and mature WebAssembly/edge runtimes in late 2025) make short‑lived functions more capable — but they also increase integration surface area.

“Micro‑apps are fun to build, painful to scale without repeatable templates.”

What you get in the starter repo

Three ready templates: Dining (restaurant recommender), Polls (quick voting), Expense Split (group expense sharing).
Function code in Node.js + Deno + a WASM example for CPU‑light tasks.
Infrastructure as code: Terraform modules (multi‑cloud), a Cloudflare Workers config, and a GitHub Actions CI/CD pipeline.
LLM prompt pack for UX copy, server logic, data validation and test generation.
Docs & runbook: deployment checklist, observability playbook, cost guardrails, and portability notes.

Inverted‑pyramid: deploy one app now — inspect the repo structure

Clone the repo and deploy an app in under an hour. Start with the Dining template if you want to demo personalized recommendations; Polls if you need a simple frontend + serverless API; Expense Split if you want background reconciliation and scheduled jobs.

Starter repo layout (high level)

starter-microapps/
├─ dining/
│  ├─ functions/       # serverless functions (Node.js, Deno)
│  ├─ infra/            # Terraform + Cloudflare workers configs
│  ├─ prompts/          # LLM prompts for recommendations, UX text
│  └─ docs.md
├─ polls/
│  └─ ...
├─ expense-split/
│  └─ ...
├─ terraform-modules/
└─ ci/                 # GitHub Actions workflows

Quick start: deploy the Dining template (15–60 minutes)

git clone https://github.com/org/starter-microapps.git
cd dining && cp .env.example .env && fill API keys (OpenAI/Anthropic, DB)
terraform init && terraform apply -var-file=env.tfvars
Run local dev server: npm run dev (function emulator included)
Open deployed URL from Terraform output

Detailed commands are in docs.md for each template. The repo uses a multi‑cloud Terraform module that can target AWS Lambda + API Gateway, Cloud Run, or Cloudflare Workers with one flag—so you can test portability quickly.

Core technical decisions and why we chose them

Keep functions small and single‑purpose. Each action (vote, recommend, split) lives in a single function to optimize cold start and simplify tracing.
Use a lightweight runtime by default. Node 18 handler for async I/O, and alternative Deno functions for local dev parity. WASM tasks (e.g., currency conversion in Expense Split) run in edge workers for deterministic performance.
Portable IaC. Terraform modules provide provider‑specific targets; Cloudflare and Vercel configs are included for edge/near‑user routing.
Observability-first. OpenTelemetry traces, logs shipped to Grafana Loki, and example Honeycomb dashboards included for each template.

Function examples

Dining: recommendation function (Node.js, 60–80 lines)

exports.handler = async (event) => {
  const body = JSON.parse(event.body || '{}');
  const { userId, context } = body;

  // lightweight recommendation using cached embeddings
  const embedding = await getUserEmbedding(userId);
  const candidates = await fetchNearbyRestaurants(context.location);
  const ranked = rankByEmbeddingSimilarity(embedding, candidates);

  return {
    statusCode: 200,
    body: JSON.stringify({ results: ranked.slice(0, 6) })
  };
};

This function assumes helpers for embeddings and candidate fetches. The repo includes a simple Redis cache for embeddings and a seeded SQLite for local demos (switchable to Postgres in prod Terraform variables).

Polls: vote endpoint (Deno deploy)

import { serve } from 'http/server'
serve(async req => {
  const { pollId, choice } = await req.json();
  await incVote(pollId, choice);
  return new Response(JSON.stringify({ ok: true }), { status: 200 });
});

Simple, fast, and designed for 100–10k votes per minute depending on your backing store. The repo wires up a Redis Stream pattern for higher throughput.

Infrastructure-as-code: examples and portability

We provide a single Terraform module that targets multiple providers via variables. Use provider = "aws" to get Lambda + API Gateway, provider = "cloudflare" for Workers, provider = "gcp" for Cloud Run. Each provider target maps the same logical resources: function, http route, secrets, and a metrics exporter.

Terraform snippet (module usage)

module "dining_function" {
  source = "../terraform-modules/function"
  name   = "dining-recommender"
  provider = var.provider
  runtime  = var.runtime   # nodejs18, deno, wasm
  env = {
    DB_URL = var.db_url
    LLM_KEY = var.llm_key
  }
}

The module wraps provider specifics and outputs a standard url and invoke_role so CI/CD can integrate across clouds with minimal changes.

LLM prompt pack: ship UX & logic quickly

Microapps benefit from LLMs for natural language UX, input validation, and generating test cases. The starter repo includes curated prompts that are tuned to avoid hallucinations and enforce guardrails (temperature, max tokens, system instructions). See our recommendations on versioning prompts and models to manage prompt changes across environments.

Example prompt: Dining recommender (system + user)

System: You are a strict recommender. Return a JSON array of restaurants with (name, score, reason). Do not hallucinate addresses.

User: Given user profile { "likes": ["sushi","outdoors"], "budget":"mid" }, and candidates: [ ... ], score each candidate 0-100 and explain concisely.

We include a safe wrapper that cross-checks LLM outputs against a canonical database to prevent hallucinated results from reaching the client.

Prompt for generating unit tests

System: You produce deterministic Jest tests for the following function signature.
User: Generate tests for function rankByEmbeddingSimilarity(embedding, candidates) covering tie scores and empty inputs.

Use these prompts in CI to auto‑generate candidate test cases when function logic changes. The repo includes a GitHub Action that runs an LLM-based testgen job on PRs (opt-in) and an internal guide on how to integrate prompt-driven workflows into your developer processes.

Observability & debugging playbook

Every template includes a preconfigured OpenTelemetry collector and sample dashboards. Key takeaways:

Trace every request end‑to‑end: from frontend to function to DB and LLM calls. Use semantic attributes for microapp_id and user_id.
Instrument LLM calls for latency and token usage—this prevents surprise costs.
Set SLOs for 95th percentile latency and costs per user action; alert on drift.

The repo includes example Honeycomb queries and Grafana dashboards to visualize function cold starts, LLM token cost, and request traces with span links to DB queries. For incident response and postmortems, follow our templates and examples in the postmortem and incident comms playbook.

Cost controls and billing guardrails

Enable per‑function budget caps in CI/CD and fail PR merges if potential token cost increases beyond threshold.
Use scheduled data retention rules for logs and raw LLM responses (delete after 30 days by default).
Prefer short‑running functions (<500ms) and cache LLM outputs for repeat requests.

Cold‑start and performance strategies (2026 best practices)

In 2026 the landscape includes snapshot-based fast starts (e.g., Lambda SnapStart evolution), edge isolates, and WASM accelerators. Use these strategies:

Preload heavy dependencies asynchronously in global scope to leverage snapshots.
Use lightweight language runtimes for user‑facing endpoints (Deno, Bun, or runtimeless edge workers).
Keep cold path minimal—delay loading metrics exporters and non‑critical clients until after the response for super-low latency responses.
Provisioned concurrency selectively for predictable traffic spikes (e.g., polls closing) to avoid cost bleeding.

CI/CD: safe deploys for microapps

Templates include a GitHub Actions workflow that runs static analysis, auto‑generates tests via LLMs (opt‑in), runs integration tests against an ephemeral stack (Terraform -target), and deploys on merge to main. Rollbacks are automatic using provider native versions (Lambda Aliases or Workers KV release tags). See our implementation notes on integrating prompt-driven test generation and team upskilling in guided LLM workflows.

Portability checklist: move from cloud to edge

Abstract external services behind an adapter layer (DBAdapter, CacheAdapter, LLMAdapter).
Use environment variables and feature flags for provider specifics.
Benchmark the function on both provider runtimes. Keep performance tests in CI.
Validate security posture (CORS, secret rotation, content filtering) before cutting over.

Case study: ship Dining in 3 days (engineering highlights)

One internal product team used the starter repo to ship Where2Eat-like functionality in 72 hours. Highlights:

Day 1: Clone dining template, wire LLM key, and seed local DB.
Day 2: Customize recommendation prompt and UI copy using provided LLM prompt pack; run generated tests.
Day 3: Use Terraform module to deploy to Cloudflare Workers for edge routing; enable observability and set a daily token cap.

Results: a working MVP demo to stakeholders, no infra handoffs, and predictable cost under the configured caps. They iterated UI and prompt tuning without changing server code thanks to the LLM‑backed prompt management files.

Advanced strategies and future predictions (2026+)

Expect these trends through 2026 and beyond:

LLM-centric logic components: more microapps will push LLM prompts & schemas to runtime configuration for rapid UX iteration without deploys.
Snapshot and WASM ubiquity: more cloud vendors will standardize fast snapshot starts and WASM modules, making sub‑10ms edge functions common.
Policy-driven cost governance: cloud consoles will add cost‑per‑function SLOs and automated throttles tuned to budget boundaries.
Hybrid dev experiences: local LLM emulation and function emulators will mature, letting non‑dev PMs iterate safely.

Security & compliance notes

Default to encrypted secrets with KMS/Cloud KMS and rotate keys monthly.
Sanitize and log LLM inputs and outputs. Treat LLM responses as untrusted until validated against a canonical data source.
Follow least privilege IAM for function roles. Terraform modules include minimal role templates.

Actionable checklist before shipping any microapp

Run the provided security scan and fix high severity items.
Configure observability: traces and log retention.
Set cost and token caps in CI/CD secrets.
Run load test at expected peak and provision concurrency if needed.
Document rollback and incident response runbook (repo includes a template runbook).

Where to customize: quick edit guide

Most teams will adjust three files to make the template theirs:

prompts/recommendation.json — tune tone and constraints for LLM.
functions/config.js — set caching windows, DB timeouts, and opt into provisioned concurrency.
infra/vars.tf — pick provider and scale targets.

Concluding advice

Microapps are becoming core to product teams’ workflows in 2026. The marginal cost of building is low; the marginal cost of operating is where teams commonly get stuck. This starter repo is built to close that gap: production‑grade serverless code, portable IaC, observability, and LLM prompt operations so your team can ship secure, low‑latency microapps fast and iterate on product value instead of plumbing.

Get started now

Clone the repo, deploy the Dining template, and run the included end‑to‑end demo. If you want a tailored workshop for your product team—CI/CD, cost guardrails, or custom LLM prompt tuning—we offer a professional add‑on that integrates with your cloud accounts and SSO in a day.

Call to action: Clone the starter repo, open the dining demo, and create a first PR with a modified prompt. Share your PR with the community to get feedback on prompts and infra best practices.

Unknown

Contributor

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.