A dynamodb-admin Alternative for Local and Live DynamoDB

DynoTable is a desktop alternative to dynamodb-admin for when you work on live AWS tables as well as DynamoDB Local. It keeps local and live profiles side by side and adds a SQL Workbench, stage-or-commit editing with a revertible History, full exports, and MCP access for the coding agent you already use.

dynamodb-admin is a free, MIT-licensed web GUI for DynamoDB Local and LocalStack, with more than 7 million pulls on Docker Hub. You run it as a small Node server (npm install -g dynamodb-admin), point it at an endpoint, and browse your local tables.

FeatureDynoTabledynamodb-admin
Browse & edit DynamoDB itemsYesYes
Live AWS tablesYesEndpoint override
YesOne per server process
Visual query/scan builderYesYes
YesNo
YesNo
YesNo
OpenSearch indices beside your tablesYesNo
YesNo
YesNo
YesNo
Query plan preview (Scan/Query + RCU when available)YesNo
YesImmediate writes
Table management (create/delete, GSIs, TTL, capacity)YesCreate (with GSIs/LSIs) and delete; no updates
YesNo
DynamoDB Local supportYesYes
InstallDesktop appNode server + browser
PricingFree read-only tier, from $9/mo billed annuallyFree

Which one fits your workflow

Your workflowChoose
Browse a single local DynamoDB instance in a free MIT web UIdynamodb-admin
Drop a GUI next to amazon/dynamodb-local in docker-composedynamodb-admin
Switch between live AWS profiles (each with its region) without a server restartDynoTable
JOIN, GROUP BY, or aggregates over local or live tablesDynoTable
Revertible edit History, full exports, or MCP access for a coding agentDynoTable

If you only browse a local instance and never touch live tables or run a JOIN, keep dynamodb-admin. The DynamoDB GUI roundup covers the wider field.

What dynamodb-admin is good at

dynamodb-admin's README calls it a "GUI for DynamoDB Local, dynalite, localstack etc." (README). It's the right tool when you're working against a local endpoint:

  • Free and open source (MIT), so there's nothing to buy and nothing to license (license).
  • Zero install friction: npm install -g dynamodb-admin gives you a web UI on localhost:8001 (the default --port; --open launches it in your browser), pointed by default at http://localhost:8000 (README).
  • A Docker image: the official aaronshaf/dynamodb-admin image on Docker Hub drops straight into a docker-compose next to amazon/dynamodb-local. It reads HOST, PORT, BASE_PATH and DYNAMO_ENDPOINT env vars (README).
  • Create and delete tables, then scan, query and edit items: new tables can carry GSIs and LSIs. The table view has a Scan/Query form with a table-or-GSI picker and filter rows (=, ≠, <, <=, >, >=, begins_with), so you never write an expression by hand (source).
  • Maintained: the latest release, 5.3.3 (also tagged v5.3.4 on GitHub), shipped on 10 June 2026 (releases).

By default it fills in dummy credentials (key, secret, and since v5.3.0 a session token of token) and the region us-east-1 (README). Those defaults target the local-development inner loop.

Pointing dynamodb-admin at live AWS

It works. Override the endpoint and pass --skip-default-credentials, so the AWS SDK resolves credentials and region through its standard chain (environment variables, your ~/.aws profile, SSO):

# Point dynamodb-admin at a real region instead of localhost
AWS_PROFILE=prod AWS_REGION=eu-west-1 \
dynamodb-admin --skip-default-credentials --host 127.0.0.1 \
  --dynamo-endpoint=https://dynamodb.eu-west-1.amazonaws.com

Keep --host 127.0.0.1. Without it (or a HOST env var), the server listens on all network interfaces, so anyone who can reach the port can edit or purge your prod tables with your credentials (bin/dynamodb-admin.ts).

Leave --skip-default-credentials off and it injects its dummy values for whatever isn't set. Since v5.3.0 that includes the session token token whenever AWS_SESSION_TOKEN is unset, which AWS rejects alongside long-term AKIA… keys (config.ts).

There's no connection manager and no profile or SSO picker, so each running process holds one credential set and one region. Switching accounts or regions means stopping the Node process and relaunching it with different env vars.

That's fine for an occasional look at a prod table and slow across several accounts. DynoTable reads every profile in your ~/.aws config, SSO and aws login sessions included. Each profile pins its region, ⌘P (or ⌘1–⌘9) switches profiles, and local endpoints sit next to live ones.

Where dynamodb-admin stops

The boundary shows up as your work moves beyond a single local table:

  • No relational queries: like any visual browser, it lists and edits items in one table. It can't join two tables, GROUP BY, or compute a COUNT / SUM, because DynamoDB has no relational query engine underneath. dynamodb-admin doesn't add one, and neither does PartiQL: its SELECT grammar takes a single FROM table with no JOIN, GROUP BY, or aggregate functions (AWS PartiQL SELECT reference) (see PartiQL vs SQL).
  • Writes are immediate, with no undo: a save goes straight to the table and nothing keeps the previous version. The table list also offers Purge all tables and Delete all tables behind a single browser confirm. On a throwaway local table that's exactly right; on a table other people depend on, it's a risk.
  • It's a browser tab on a server you run: you keep a Node process (or container) running and bookmark localhost. The server refuses to start when NODE_ENV=production ("Do not run this in production!").

What a full DynamoDB client adds on top

DynoTable connects to local and live DynamoDB from one desktop app, using the AWS profiles and access keys you already have. Your data stays in DynamoDB, so there's nothing to migrate.

Its SQL Workbench runs INNER/LEFT JOIN, GROUP BY and COUNT/SUM/AVG, compiled on the client down to DynamoDB's Query/Scan operations and planned against your keys and GSIs, so it stays within DynamoDB's access-pattern rules. The SQL for DynamoDB guide covers what it compiles to.

-- The kind of question a single-table browser can't express:
SELECT u.email, COUNT(o.id) AS orders, SUM(o.total) AS revenue
FROM Users u
JOIN Orders o ON o.userId = u.id
GROUP BY u.email;

The join looks up Orders by userId, so userId must be the partition key of Orders (with no sort key) or the partition key of exactly one GSI on it. With no partition-key equality to narrow it, Users is read by a full Scan, billed for every item.

The pre-run estimate prices that Users scan. The Orders lookups are flagged inline but not priced, and the aggregate columns show (partial) until every page is read.

The DynoTable SQL Workbench compiling a JOIN with GROUP BY into Query and Scan calls.
The DynoTable SQL Workbench compiling a JOIN with GROUP BY into Query and Scan calls.
DynoTable's visual filter builder with the index picker and the derived Query badge.
DynoTable's visual filter builder with the index picker and the derived Query badge.

On top of the browsing and editing dynamodb-admin covers, it adds:

  • Stage or commit, then revert from History: every save offers Stage or Commit. Commit writes at once; Stage queues the edit in a per-table staging area as a per-attribute diff you review and commit later. Every committed write is journaled and revertible from History, except a bulk Direct Run, which has neither a stage nor a history. Writes from the AI agent or over MCP can only stage.
  • MCP for the coding agent you already use: point Claude Code, Cursor or Codex at your tables, local ones included, over MCP, with a scope you pick per connection (read-only, read + stage, or full). An agent that can read your seeded DynamoDB Local tables while you code is the same inner loop dynamodb-admin serves, with your agent in it. The MCP setup guide has the details.
  • An AI agent on your own AWS Bedrock keys: it reads your key schema before it queries and stages every write for approval. Inference runs on Amazon Bedrock in your own AWS account; no DynoTable server sees your prompts or rows. The AI chat docs describe it.
  • Full exports: whole result sets, filtered views included, as CSV, a JSON array or NDJSON, run in the background.
  • Vector search: on an on-demand live table, create a vector index (paid, minutes to build; DynamoDB Local has none) and bind a Bedrock embedding model to it. A pasted-vector search or Find similar needs no AI setup and spends no Bedrock tokens; a typed-sentence search spends Bedrock tokens on your account. An item-editor save that changes the source text re-embeds that item; bulk edits, PartiQL writes and writes from outside DynoTable don't. Vector search covers the setup.

What's free and what's paid

DynoTable's Free plan has no time limit and needs a free DynoTable account sign-in. It covers browsing and filtering local and live tables, PartiQL SELECT, data, code and schema exports, and read-only MCP for your coding agent. For the browsing dynamodb-admin is built for, both tools are free.

dynamodb-admin edits items and creates tables for free. In DynoTable, writes and table changes are part of the paid plans after the 30-day trial, along with the SQL Workbench, Smart Tables and the AI agent, none of which dynamodb-admin has.

A paid Individual seat is $9/mo billed annually ($108/yr) or $12 month-to-month, on up to two machines; see pricing for Team rates. On DynamoDB Local you can work offline, but a paid seat refreshes its license online every ~3 days and falls back to read-only without it.

How to switch from dynamodb-admin

DynoTable runs against local endpoints as well as live ones, so it can take over the local inner loop too:

  1. Download DynoTable for macOS (Apple Silicon or Intel), Windows or Linux, and sign in with a free account.
  2. Add a DynamoDB Local profile on its localhost port (http://localhost:8000 by default). A local profile takes a localhost address, so publish the container's port to the host rather than using a compose service name.
  3. Open your tables.
  4. For live AWS, add a profile from your ~/.aws config and choose its region.

Connecting to DynamoDB Local and LocalStack covers the endpoint and dummy-credential setup. The trial is free for 30 days, no credit card required.

FAQ

Is DynoTable a dynamodb-admin alternative?

For local-only development, dynamodb-admin is free and sufficient. DynoTable is the alternative when you also need live AWS tables, saved connections through your AWS credential chain, stage-or-commit editing with a revertible History, full exports, MCP access for coding agents, and a SQL Workbench that runs JOINs, GROUP BY and aggregates. dynamodb-admin covers live tables only one process at a time and has none of the rest.

Can dynamodb-admin connect to live AWS DynamoDB?

Yes. Override --dynamo-endpoint with the regional endpoint, pass --skip-default-credentials so the AWS SDK resolves your profile and region, and pass --host 127.0.0.1 so the server doesn't listen on every network interface. Without the credentials flag it injects dummy values, including a session token that breaks long-term access keys. It has no connection manager or profile switching, so each running process holds one credential set and one region.

Why use a paid app when dynamodb-admin is free?

DynoTable's Free plan is also free, with no time limit and a free account sign-in, and it covers local and live tables alike. Free includes browsing, PartiQL SELECT, OpenSearch index search, data, code, and schema exports, and MCP schema/item reads; paid seats add the SQL Workbench, Smart Tables, writes, and AI.

Is there a dynamodb-admin Docker image?

Yes. aaronshaf/dynamodb-admin is published on Docker Hub and configured via the HOST, PORT, BASE_PATH and DYNAMO_ENDPOINT env vars, so it sits next to amazon/dynamodb-local in a docker-compose (README). DynoTable is a desktop app, not a container, so there's no image to run. It connects to a DynamoDB Local container through the port published on localhost, or to your live account.

Can dynamodb-admin run SQL or join tables?

No. dynamodb-admin browses and edits one table at a time; it has no documented SQL surface, and DynamoDB itself has no relational engine. Even PartiQL's SELECT is single-FROM with no JOIN, GROUP BY, or aggregates (AWS PartiQL SELECT reference), so JOIN, GROUP BY and aggregates aren't possible without a client that plans them. DynoTable's SQL Workbench compiles those down to DynamoDB's Query/Scan operations.

Last verified 2026-10-09. dynamodb-admin is MIT-licensed open-source software by its respective authors; referenced here for identification only.

Work with DynamoDB without the Console

A fast DynamoDB desktop client that runs the real SQL DynamoDB can’t — JOINs, GROUP BY, aggregates — with visual editing and an AI agent on your own Bedrock keys.

Free 30-day trial, no credit card — then the Free plan with no time limit.