Building AI Prototypes Fast: My Hackathon Tech Stack

I'm a few months out from starting at Northeastern, and one thing I'm genuinely excited about is the hackathon scene in Boston. HackMIT, HackHarvard, HackUMass, the list goes on. I've done a couple of hackathons back in India, but the density of events in the Boston area is on another level.

So I've been refining my stack. The tools I reach for when I need to go from "what if we built..." to a working demo with an AI backend in under 24 hours. Here's what I've settled on.

Frontend: Streamlit

Look, I know React exists. I know it's the "right" way to build a frontend. But at 3 AM in a hackathon with 8 hours left, I do not want to debug CSS flexbox. I want to write Python and have a UI appear.

Streamlit does exactly that. st.title(), st.file_uploader(), st.image(), done. You can go from zero to a functional, decent-looking app in under an hour. It handles state management, caching, and even has built-in support for displaying ML model outputs like charts and dataframes.

For hackathons, developer speed beats everything else.

Backend: FastAPI

When Streamlit isn't enough and I need a proper API, FastAPI is the answer. Automatic docs with Swagger, async support, Pydantic validation, and it's genuinely fast. I can spin up an endpoint that accepts an image, runs inference, and returns results in about 30 lines of Python.

My typical pattern: FastAPI serves the model, Streamlit calls it. Clean separation, easy to demo, and judges can see the API docs as a bonus.

Models: HuggingFace Transformers and Hub

The HuggingFace ecosystem is ridiculously powerful for prototyping. Need a text classifier? Three lines. Image captioning? Five lines. Sentiment analysis, summarization, object detection? It's all there with pretrained weights.

Copyfrom transformers import pipeline
 
classifier = pipeline("zero-shot-classification")
result = classifier("This movie was amazing", candidate_labels=["positive", "negative"])

For vision tasks, I lean on timm (PyTorch Image Models) by Ross Wightman. Pretrained ViTs, EfficientNets, ResNets, all loadable in one line. Fine-tuning on a small dataset takes minutes with the right learning rate.

Deployment: Google Cloud Run

This is my secret weapon. Cloud Run takes a Docker container and deploys it as a serverless endpoint. No infrastructure management. Scales to zero when nobody's using it (so it costs nothing after the hackathon). Scales up when judges hit your demo.

My Dockerfile is practically a template at this point:

CopyFROM python:3.9-slim
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["streamlit", "run", "app.py", "--server.port=8080"]

Push to Cloud Run, get a URL, put it in your slides. Done.

The Glue: Things People Forget

python-dotenv for API keys. Never hardcode secrets, even in a hackathon.

Pillow and opencv-python for image preprocessing. Every CV project needs them.

loguru for logging. Way better than print statements when you're debugging at 4 AM.

A good requirements.txt template. I keep one updated with pinned versions. Nothing kills momentum like dependency conflicts at hour 20.

The Philosophy

The goal at a hackathon isn't production-grade code. It's a compelling demo that proves the concept works. Every tool choice should optimize for speed to demo. If something takes more than 15 minutes to set up, it's the wrong tool for a hackathon.

I'm planning to hit every major hackathon in Boston this fall. I'll report back on how this stack holds up when the pressure is real. (Update: it held up. We won Best Google Cloud at HackHarvard and Best AI/ML at HackUMass back to back.)