AI Engineer World's Fair 2026

AI Apps in a Flash: Ship to GPUs Without Docker — Dean Quiñanola, Runpod

Loading slides…

Read the talk

AI Apps in a Flash: Ship to GPUs Without Docker

Dean Quiñanola develops one Runpod Flash function from a GPU check into text and image generation, then deploys it as a hosted backend. The live demo shows what Flash removes from development—and where cold starts, rollouts and model behavior still matter.

From a talk by Dean Quiñanola

At a glance

Ideas worth remembering

  • Flash removes manual Docker builds and image pushes from the demonstrated iteration workflow; remote worker startup and deployment still take place.

  • flash dev provides a local FastAPI interface for remote GPU execution, including code changes and dependency installation during development.

  • Live iteration still requires attention to rollout state: the image-generation demo initially encountered an older running version.

  • flash deploy packages and uploads the application for hosted serving; callers use the resulting deployment ID rather than the local development server.

  • A completed inference request proves the execution path worked, while the missing string-cheese and bow-tie details show that output quality remains a separate concern.

A code change should not require another image push

A small AI application change can trigger a surprisingly long deployment sequence: edit the code, build a Docker image, push it to Docker Hub, execute it, inspect the result—and repeat if something went wrong. Dean Quiñanola, a staff engineer at Runpod, opens with a personal estimate: depending on the change, one pass through that loop sometimes takes about fifteen minutes.

Runpod Flash aims to remove that repeated packaging work from development. The desired interaction is familiar: write Python, execute it, inspect the result, then edit and execute again. The GPU lives in the cloud, but testing should feel close to working with a local GPU. Deployment remains a separate step; the immediate goal is to shorten the distance between a code change and its observable result.

0:120:42
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:12 · section reference included

Local-looking functions, remote endpoints and shared caches

At the time of the recording, Flash primarily targets serverless endpoints, with support for pods described as work in progress. It offers both queue endpoints and load-balanced endpoints. Quiñanola does not develop their scheduling differences here; the feature tour concentrates on how Python code can use remote compute without requiring the developer to manage every server connection.

Three capabilities support that development experience:

  • Endpoint-to-endpoint calls. A function can call another function even when they are deployed to different endpoints. Flash handles the communication underneath the local-looking call, removing the need to write the server-contact plumbing for each connection.
  • Network volumes with warm caching. Attached network volumes carry cached material across serverless scale-up. The useful distinction is where the cache lives: it can remain available through the volume rather than being confined to one worker.
  • Live serverless. Developers edit and test code through a workflow that feels local while execution uses remote resources. The CLI also provides the route from that development session to a hosted inference service.
2:022:32
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:02 · section reference included

Start with a function that identifies its GPU

The demo follows one function as its job grows. Initially, it asks Torch what GPU is available. Running flash dev launches a local FastAPI server that provides a place to exercise the function. Executing the request provisions a serverless endpoint, which then appears in the Runpod console. Localhost is the development interface; the GPU work happens remotely.

Provisioning still takes work. Quiñanola opens the logs, waits for the worker and identifies a cold start. The container logs expose startup and health checks before the job completes. Flash has removed the developer's manual image-building sequence, but this first request still waits for a usable remote worker.

What confirms that the function actually reached a GPU? Its returned hardware information identifies an NVIDIA GeForce RTX 4090 and includes RAM and GPU-count information. That result gives the next edits a concrete starting point: the function already executes on the remote machine, so the demo can now change what it does.

The completed request returns an NVIDIA GeForce RTX 4090, with one GPU and 23.53 GB of VRAM.Open full source frame
The completed request returns an NVIDIA GeForce RTX 4090, with one GPU and 23.53 GB of VRAM.
3:484:09
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:48 · section reference included

Add text generation and install dependencies during iteration

The next edit adds text-generation code and Python dependencies to the same function. Quiñanola deliberately tries it without a Hugging Face token first. The development interface refreshes, and he submits “Is string cheese real?” The run installs dependencies on the fly and emits a warning about contacting the Hugging Face server without the token. These are the useful things to inspect together: the dependency change, its installation during execution and the authentication warning.

The request completes, but its answer is unhelpful: “I'm sorry, but I cannot provide answers.” Quiñanola's response—“that's spicy”—captures the difference between successfully running inference and obtaining the answer you wanted. The infrastructure has delivered a model response; the response itself needs another look.

He enables the Hugging Face token through a code change, then changes the prompt to “Who is Batman?” The next completed response identifies Batman as a fictional character. Because both authentication and the prompt changed, this does not establish that adding the token corrected the earlier refusal. It does demonstrate another edit-and-execute pass without a manual Docker build or registry push.

5:436:11
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:43 · section reference included

Image generation exposes a rollout still serving old code

The function's next job is image generation. After the code refreshes, the localhost interface exposes generate image, and the prompt combines the previous examples: create an image of string cheese Batman. The workload has changed from reporting hardware, to generating text, to producing an image, while the development entry point remains the same.

This time, the logs show a rollout in progress. Quiñanola finds that the older version is still running and terminates it rather than waiting for the rollout. The replacement then uses the new version. Live development therefore still involves deployment state: refreshing the local interface does not by itself mean every remote worker has already switched to the edited code.

The new run returns a base64-encoded image. Quiñanola prepares that output for display and renders it in the browser. How closely does the result follow the prompt? His verdict is immediate: “That's not string cheese.” The example demonstrates a completed remote image-generation path, while also showing that successful execution does not guarantee the requested visual detail.

3:485:43
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:04 · section reference included

End the development session, then deploy a hosted backend

Canceling the development session deprovisions its endpoint; Quiñanola checks that it disappears from the console. This gives the temporary development environment a clear lifetime. To make the application available beyond that session, he runs flash deploy.

The command packages the application, creates an archive, builds Flash, uploads the result and deploys it on Runpod's servers. “Without Docker” describes the developer-facing workflow: there is no Dockerfile, manual image build or registry push in this sequence. Packaging and remote serving still happen, and the earlier demo exposed container logs underneath the abstraction.

The prepared request needs the new deployment's ID. After finding it, Quiñanola updates the request and asks for a cute baby sea otter with a bow tie. This call uses the hosted backend rather than localhost, making it the path a customer-facing application could use. Worker logs show the remote execution, and the completed request prints its output for display.

The rendered sea otter has no bow tie. As with string cheese Batman, the inference service completes the request while the generated image misses part of the specification. The demonstrated result is an application that can receive a request and return an image independently of the local development server; it is not a demonstration of reliable prompt adherence.

9:5310:18
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

9:53 · section reference included

Fan experiments out across endpoints, then start from an example

The closing example expands from a single inference function to a batch of experiments. A hackathon project wraps Flash with an interface for uploading a data sheet containing experiments, specifications and models. The wrapper fans the work out, creates endpoints, runs training and reports results back. The data sheet becomes the input for distributing multiple experiments instead of manually setting up each endpoint.

Quiñanola reports that the participant built the project in three to four hours despite starting without knowledge of Flash, asking along the way whether the idea was possible. It won the previous day's hackathon. This is an anecdote about how quickly someone assembled an orchestration layer on top of Flash; the talk does not provide training-throughput or cost measurements for it.

The suggested starting sequence is straightforward: create a Runpod account, install Flash, write code and log in so the API key is available. Initialization can supply a skeleton application. Then choose flash dev for the local development interface or flash deploy for a hosted application.

The strongest practical recommendation is to study the Flash examples repository for existing cases before building your own. Quiñanola also suggests opening that repository with Claude Code so the coding assistant can use its examples as context, and mentions available skills. The ending returns to the same working unit as the demo: start with code you can exercise, change its job, inspect the remote result, and deploy when it is ready to serve.

12:1412:44
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

12:14 · section reference included

Transcript download
Full transcript

Loading transcript…