Winning the NVIDIA DGX AITX Hackathon

One weekend. One Jetson. 2.3 million Austin construction permits. Nemotron Nano 8B running locally. We won first place at NVIDIA's DGX AITX hackathon. The build looked nothing like a normal hackathon sprint, and that's the part I want to talk about.

The brief

DGX AITX ran Friday through Sunday and gave teams a DGX Spark, a Jetson AGX Orin, and a question. Build something that demonstrates what NVIDIA hardware enables today. Most teams went straight at the DGX — image gen, video pipelines, fine-tuning runs that would burn most of the day. We took the Jetson and asked a different question: what's a production problem that can run on a thing the size of a hardback book, locally, with no token bill?

Austin has 2.3 million construction permits. Solar, battery, generator, EV charger — every one of those is in a database somewhere, behind a search box that answers in seconds when it works at all. City planners spend weeks pulling numbers manually. There's no AI search layer. No semantic understanding of what's been built where. No way to ask "what's the solar-to-battery ratio in 78704?" and get an answer.

That was our problem. We named the project Undervolt. The "under" because the city is under-built on storage. The "volt" because that's the unit that keeps a freezer running when the grid fails.

What we shipped

A working web app. Not a demo. Not a deck.

• GPU-accelerated ingest of all 2.3M permits using RAPIDS cuDF on the DGX Spark, then exported to a Parquet file the Jetson could serve.
• A Nemotron Nano 8B model running locally on the Jetson via Ollama. No NIM container, no API. The whole inference loop fits in 24GB of unified memory.
• An interactive map of every solar installation, battery, EV charger, and generator across Travis County.
• A natural-language query layer that turned "show me where battery storage lags solar" into structured queries against the permit data.
• A discovery: a 22-to-1 solar-to-battery ratio across the city. Austin produces clean energy but can't store it. When the grid fails — and it has — solar panels stop being useful.

The discovery wasn't planned. We weren't hunting for it. The model surfaced the ratio when we asked it to find anomalies, and we backed into the implication. That's the part that won.

The agentic engineering part

Here's the work breakdown. A 12-hour hackathon, two engineers, normal tooling: you'd spend 4 hours just wiring up the data pipeline. We had it parsing, cleaning, and indexed in 75 minutes. Not because we typed faster. Because Claude Code wrote the pipeline while we were still reading the permit schema.

The pattern went like this. One stream on the data layer — load, clean, test, fix. A second on the map UI — Mapbox, layer toggles, click-to-detail. A third on the model layer — pull Nemotron, write the system prompt, build the structured-query tool, eval against ten gold-standard questions. Three streams running in parallel. We worked at the orchestration layer: which work stream gets which brief, which eval defines done, which output ships and which gets sent back.

Each stream had a tight brief: "Here's the permit schema. Here's three example rows. Here's the output format I need. Here's the eval. Don't return until the eval passes." That brief takes thirty seconds to write. The work that follows is fifteen to forty minutes. While it runs, you write the next brief.

The trick isn't prompting. It's which agent does which part, in what order, with which context, under what review. Three parallel sub-agents on three parallel tracks beats one giant agent attempting the whole thing. We learned this the hard way on earlier projects, lost an evening to context bloat, and never went back.

By Saturday afternoon, we had a working app. The rest of the weekend went into making the discovery presentable: tightening the query, improving the chart, writing the demo script, and rehearsing for Sunday's pitch.

What the judges noticed

Three things, ranked by what got the most questions:

1. Local inference. Nemotron Nano 8B running on the Jetson, no cloud round-trip. The judges asked twice if we were sure it wasn't hitting an API. We were sure. They appreciated that.
2. A real discovery. The 22-to-1 ratio is a finding, not a feature. Most hackathon entries are features without findings. Production AI shows the second.
3. Production posture. It looked like an app. It loaded fast. It didn't error in the demo. We had spent the last two hours making it not break under stage pressure, not adding capability. That decision compounds.

What the experience taught me about the bar

A few things that I want to keep applying:

Real data over fake data. Most hackathon entries use synthetic data because real data is hard. Real data is also where the value is. Spend the hour to wire up a real dataset.

A discovery beats a feature. A feature is "we built X." A discovery is "we found Y." Y is what gets remembered.

Local is now a first-class deployment target. The Jetson is fast enough. Nemotron is good enough. There's a real architectural decision to make every time you reach for an API: does this need to be cloud, or am I defaulting to it?

Small teams beat big armies. Two people with three orchestrated agents beat eight people with three engineers and five idle teammates. When agents are doing the implementation, headcount stops being the lever. Orchestration discipline becomes the lever.

That last one is the part I keep coming back to. We didn't win because we're better engineers than the other teams. We won because we'd been practicing agentic orchestration since October 2025 — eight weeks of deliberate reps — and they hadn't.

What's next

Undervolt isn't a hackathon project anymore. It's running at undervolt-atx.vercel.app. The intelligence layer is real, the data refresh is automated, and the API is open. We're talking with the City of Austin's office about formalizing it.

The deeper move is the one underneath: every project we've shipped since this one — the AI referee that uses Cosmos to make calls in real time, the local-only photographer copilot, the home-network monitor — has used the same agentic pattern. Brief small. Run parallel. Eval before code. Production from day one.

If you're a founder or platform lead trying to figure out what "agentic engineering" actually changes about how teams ship, the answer is: a lot, but not the part you'd expect. It changes the company shape, not the engineer's day.

I'll write more on that.