Hackathon Build Challenges¶
Last reviewed: October 2026
End-to-end, time-boxed builds — the format where you ship something working under pressure, then demo and defend it. Great for learning-by-doing and for the "take-home / build day" rounds. Each challenge gives you a scope, timed milestones, a what-good-looks-like bar, and stretch goals.
How to run a build challenge
- Time-box it (2–3 hours). Set milestone alarms.
- Cut scope hard — a working thin slice beats a broken ambitious one. Ship the smallest thing that demos, then layer.
- Keep a running README of decisions/trade-offs — you'll present it.
- Leave 15 min to demo + write "what I'd do next." Judges reward clarity and honest trade-offs over feature count.
The build-day method¶
flowchart LR
S[Scope<br/>cut to a thin slice] --> P[Plan<br/>milestones + risks]
P --> B[Build<br/>working slice first]
B --> H[Harden<br/>errors, edge cases]
H --> D[Demo<br/>story + trade-offs + next]
The #1 mistake is over-scoping and having nothing that runs at the end. The #1 win is a working, honestly-scoped demo with a clear "here's what I'd do with more time." Decompose a vague ask into a concrete plan first, that decomposition is what's being judged.
Challenge 1 — RAG Q&A over a CSV (2 hours)¶
Prompt: Given a CSV of documents/records, build something that answers natural- language questions with citations.
- Load the CSV → chunk the text column.
- Embed + store (FAISS/Chroma locally, or Cortex Search if in Snowflake).
- Retrieve top-k for a question → prompt an LLM to answer only from context with citations.
- A tiny CLI or Streamlit input box.
- 0:20 — CSV loaded, chunks created, sanity-printed.
- 0:50 — embeddings + retrieval returning relevant chunks for a test query.
- 1:20 — grounded answer with citations end-to-end.
- 1:45 — a minimal UI (or clean CLI) + README.
- 2:00 — demo + "what's next."
- Answers are grounded (only from retrieved rows) and cite sources.
- Says "not found" when the CSV doesn't cover it (no hallucination).
- You can explain chunking + retrieval choices and one failure mode.
- Hybrid (vector + keyword) retrieval; a reranker.
- A tiny eval set (5 Q/A) with recall@k.
- Metadata filters (e.g. by category/date).
See: RAG · AI Engineer
Challenge 2 — Ingest → transform → serve mini-pipeline (3 hours)¶
Prompt: Land raw files, transform to a clean current-state table, expose a simple query/endpoint.
- Ingest CSV/JSON into a staging table (DuckDB/SQLite/Snowflake).
- Idempotent
MERGE/upsert into a current-state table keyed on a natural key. - One or two data-quality checks (unique key, not-null).
- Expose results via a small FastAPI endpoint or a SQL view.
- 0:30 — raw loaded into staging, schema confirmed.
- 1:15 — idempotent upsert working; re-running doesn't duplicate.
- 2:00 — quality checks + a history/snapshot table.
- 2:40 — endpoint/view returning clean data + README.
- 3:00 — demo (show a re-run producing no dupes).
- Re-runnable without duplicates (prove idempotency live).
- Clear staging → current (+ history) separation.
- Quality checks that actually fail on bad input.
- CDC-style change capture; incremental instead of full load.
- dbt models + tests instead of hand-rolled SQL.
- A tiny dashboard over the served data.
See: Data Engineering · SQL · dbt
Challenge 3 — Tool-using agent / MCP server (2–3 hours)¶
Prompt: Build an agent (or MCP server) that can answer questions AND take one safe action against a small dataset/API.
- Define 2–3 typed tools (e.g.
search,get_record, and one gatedupdate). - A plan → act → observe loop (LangGraph, or LangChain 1.x
create_agentwith human-in-the-loop middleware) with a step cap. - Read tools open; the write tool validated + approval-gated.
- CLI or chat UI showing intermediate steps.
- 0:30 — tools defined with schemas + docstrings; callable standalone.
- 1:15 — agent loop routes to the right tool for a question.
- 2:00 — gated write action with validation + a confirm step.
- 2:40 — tracing of steps + README.
- 3:00 — demo (show it refusing an unsafe/invalid action).
- Narrow, well-described tools; destructive action is gated, not direct.
- Handles a bad/injection-y input safely (treats tool text as data).
- Step cap prevents runaway loops; steps are traceable.
- Multi-agent supervisor routing; expose tools over MCP (Python SDK
FastMCP; stdio locally, Streamable HTTP + OAuth if remote). - An agent eval: 5 tasks × 3 trials each, scored on outcome and steps used.
- Outcome verification (confirm the action's effect against real state).
- An eval of routing accuracy.
See: Agents · MCP · LangChain / LangGraph
Challenge 4 — Snowflake-native GenAI (2 hours)¶
Prompt: Do something useful with data already in Snowflake, no data leaving the account.
- Pick a table with text; use Cortex AI functions (
AI_SUMMARIZE,AI_CLASSIFY,AI_FILTER, orAI_COMPLETEwith a JSON schema) in SQL. - Or stand up a Cortex Search service and query it.
- Or a minimal semantic view + a Cortex Analyst / Cortex Agent NL question.
- 0:30 — table chosen; first Cortex function call returning results.
- 1:15 — a small end-to-end flow (e.g. classify + summarize a batch).
- 1:45 — wrap in a view or Streamlit-in-Snowflake page + README.
- 2:00 — demo + governance talking point (RBAC/no egress).
- Runs inside Snowflake's perimeter under your RBAC (the governance story is the whole point).
- You can explain when to use Cortex vs an external LLM.
- Full Snowflake-native RAG (Cortex Search →
AI_COMPLETE), or a Cortex Agent with a Search tool. - Cost awareness (per-token AI credits on top of warehouse compute;
AI_COUNT_TOKENS).
See: Snowflake · Technologies → Snowflake
Demo & defense checklist¶
Judges/interviewers reward these more than raw features:
- It runs and demos a working slice end-to-end.
- I can state what I cut and why (scope discipline).
- I can name the top failure mode and how I'd handle it.
- I have a crisp "what I'd do with more time."
- I explained one trade-off (cost/latency/complexity).
More labs
See also: Scenario Drills · Live-Coding Drills.