Open source · runs entirely on your machine

# You can't run Athena
on your laptop.


You can't run AWS Athena on your laptop. There's no `athena` to `docker run`, no local mode, no offline switch. It's serverless — which is wonderful right up until you're the one trying to build against it.

So you pay a quiet tax. Every query you run while developing goes to the real AWS, over the network, billed per terabyte scanned, gone the second your wifi drops.

So I built one the AWS SDK can't tell apart.
  v0.1.4 AGPL-3.0-only [GitHub](https://github.com/twickstrom/athena-local) [npm](https://www.npmjs.com/package/athena-local)
Same code. Different endpoint.
 analytics.ts
```
import { AthenaClient } from "@aws-sdk/client-athena"; const athena = new AthenaClient({region: "us-east-1",endpoint: "https://athena.us-east-1.amazonaws.com",credentials: fromEnv(),});
```

→ Every dev query: a network hop to AWS, billed per TB scanned.

The problem

## The startup tax on your dev loop.

Here's a cost nobody puts on the roadmap. It isn't your AWS bill, exactly — it's the price of a development loop that has to leave your machine to do anything at all. Athena is serverless, so there's nothing to run locally. Every query you fire while building goes to a real data center, billed per terabyte scanned, and disappears the moment your connection does.

It's death by a thousand round trips. Each one is small. Together they're slow feedback, a creeping bill, no offline, and a test suite that either skips your data path entirely or quietly leans on a shared cloud account. And — like most of these things — it gets worse exactly when things start working. More tests, more developers, more iterations. Success shouldn't make your inner loop more expensive.

Run the same query

AWS Athena

us-east-1 · over the network

latency ~420 ms

billed this session

$0.00
0.0s spent waiting

Athena Local

localhost:4567 · on your machine

latency ~4 ms

billed this session

$0.00
instant · works offline

Now imagine this on every save, every test, every branch, every CI run.

None of this is Athena's fault. It's just what *cloud-only* means for the person at the keyboard.

The options

## Until now: a meter, or a subscription.

There's already a way to run Athena locally, and it's good — LocalStack does it. But like most convenience, there's a business model attached: Athena lives in their Ultimate tier, at $89 a seat, every month. For one developer, fine. For a team, that's the same tax wearing a subscription. I wanted a third option I could just *own*.

Develop against real AWS

~$0.01+

per dev query, billed per TB

 - A network round trip, every query
- No offline — gone when wifi drops
- CI leans on a shared cloud account

LocalStack (Ultimate)

$89

per seat, per month

 - A genuinely good emulator
- But Athena sits in the top tier
- Multiply the seat by your whole team

Athena Local

$0

open source · AGPL-3.0

 - Real Trino engine, faithful protocol
- No account, no seat license, no meter
- Yours to run anywhere — including CI

The turn

## The only thing your app needs is the API.

Your code never touches Athena's internals. It makes an SDK call and waits for an Athena-shaped answer. So if something local speaks that exact protocol — and runs the query on an engine you already trust — your app genuinely can't tell the difference.

 1. Your app   the request
@aws-sdk/client-athena

Makes a normal SDK call — StartQueryExecution. Unchanged.
 1.
 1. The facade   the translator
Athena Local

Speaks the exact AWS JSON protocol back. Faithfully — verified against the real SDK.
 1.
 1. The engine   the muscle
Trino

Actually runs your SQL. A real distributed query engine, not a toy emulator.
 1.
 1. Your data   the lake
S3 · MinIO

Queries your own bucket — or attaches to an object store you already run.
     Result-shape parity
Same SDK, same calls, same result shapes — header row first, NULL as an empty datum, bigint as a decimal string. Pinned by a golden test and run against the real `@aws-sdk/client-athena` on every release.

The payoff

## What you actually get is optionality.

Not the cheapest setup possible — the right one. A dev loop that's quick when you're heads-down, honest in CI, and doesn't quietly bill you for the privilege of building.

Free

$0 per query. No per-terabyte meter running while you iterate.

Instant

localhost latency. Your feedback loop stops waiting on a data center.

Offline

Develop on a plane. No account, no network, no internet required.

Testable in CI

Exercise your Athena code path on every PR — no shared account, no flake.

Faithful

The real AWS SDK, the real result shapes. Production DDL runs here unchanged.

 - 12 Athena operations
 - /
- external attach mode
 - /
- Docker or Apple container
 - /
- tested 3.1071 → latest
 - /
- no telemetry

Get started

## Point your SDK at localhost.
      zsh     $ bun add -d athena-local    $ bunx athena-local start  # boots Trino + the facade   $ bunx athena-local query "SELECT 1"  # verify — no SDK code needed
Then point the real AWS SDK at `http://localhost:4567`. Only the endpoint changes.
  [Star on GitHub](https://github.com/twickstrom/athena-local) [View on npm](https://www.npmjs.com/package/athena-local)
I built this the same way I rebuilt my infrastructure: with AI agents and tight review loops, in a lot less time than it has any right to take. The effort gap is shrinking — so own a little more of your stack.