AWS DynamoDB Console Alternative
For daily querying and editing, a desktop client such as DynoTable is the main alternative to the AWS DynamoDB console; the console stays where you restore tables, configure streams and run one-off lookups. The console gives you a table list, an item browser and a PartiQL editor.
DynoTable adds a SQL Workbench that runs JOIN, GROUP BY and aggregates
within DynamoDB's access-pattern rules, an AI agent on your own AWS Bedrock
keys, and MCP access for coding agents like Claude Code and Cursor.
It also brings the workflow the console never grew: tabs, folders, saved queries, one-keystroke profile switching, and whole-result CSV, JSON and NDJSON exports. DynoTable reads your standard AWS credential chain and talks to the same tables in your account, so there is nothing to migrate.
When to use the AWS console and when to use DynoTable
| Your workflow | Choose |
|---|---|
| Restore a table, or configure streams | AWS console |
Peek at a handful of items or run a one-off GetItem | AWS console |
| Create a table, add a GSI or a replica, tune capacity, or flip TTL | Either |
| Create or delete on-demand backups, or set the PITR recovery period | Either |
JOIN, GROUP BY, or aggregates over live tables daily | DynoTable |
| Export a full filtered result set to CSV, JSON or NDJSON | DynoTable |
| Staged writes, saved queries, or MCP for Claude Code / Cursor | DynoTable |
DynoTable creates and deletes on-demand backups and manages point-in-time recovery, but restores, streams and CloudWatch alarms stay in the console.
What the Free plan covers and what a seat adds
Start with what stays free. DynoTable's Free plan has no time limit and needs
only a free DynoTable account: browse and filter tables, run PartiQL SELECT,
export data, code and schemas from the app, and serve schema and item reads to
your coding agent over MCP. For reading and in-app exports, neither tool costs
anything.
The subscription adds the SQL Workbench (JOIN, GROUP BY,
COUNT/SUM/AVG, none of which PartiQL supports), Smart Tables, an AI agent
that works over your tables, and stage-or-commit editing.
Then there is your time. The console has no saved-query library, so you rebuild yesterday's filter by hand. DynoTable exports whole result sets, pages for you, and keeps queries saved. If DynamoDB is part of your daily work, that busywork costs more than the subscription does. If you only open the console to check a value now and then, keep the console.
Can you query DynamoDB with SQL in the console?
Only the SQL-flavored subset PartiQL exposes. The console has a built-in PartiQL
editor (in the left navigation pane) that runs PartiQL statements
(AWS docs),
and PartiQL's SELECT grammar is deliberately narrow:
SELECT expression [, ...]
FROM table[.index]
[ WHERE condition ]
[ ORDER BY key [DESC|ASC], ... ](AWS docs.)
One table, an optional WHERE, optional ordering, and no JOIN or GROUP BY.
The one function AWS files under aggregates is SIZE, which returns a single
attribute's size in bytes rather than a value across rows, and the list notes
that "any SQL functions that are not included in this list are not currently
supported"
(AWS docs).
That faithfully exposes DynamoDB's single-table access model, but it means
analytical questions are off the table in the console. The
PartiQL vs SQL guide walks through exactly where the
grammar stops, and the PartiQL examples guide has
copy-paste statements for what it can do.
DynoTable's SQL Workbench compiles INNER/LEFT JOIN, GROUP BY, COUNT,
SUM and the other aggregates down to DynamoDB's own Query and Scan
operations on the client. You write relational-shaped SQL, and DynoTable plans
it against your keys and GSIs so it stays within DynamoDB's access-pattern
rules.


Planning doesn't make a read cheaper. A WHERE or GROUP BY without a partition-key
equality runs as a full Scan, billed for every item it reads. Each JOIN adds
key lookups (BatchGetItem, de-duplicated) on the joined table, which must be
keyed by the join attribute: the partition key of a table with no sort key, or
the partition key of exactly one GSI. A self-join follows the same rule. Subqueries,
CTEs, UNION and window functions are out.
Before you run, the Workbench preview names Scan or Query and the index. Its
RCU estimate covers the base read, when table metadata supports one; reads on
the joined table are flagged inline, not priced. An ordinary partition Query
shows no RCU.
If you've hit the wall where the console's PartiQL editor stops, the
SQL for DynamoDB guide explains what works and what
doesn't, the DynamoDB JOIN guide shows how the Workbench
joins two tables, and the GROUP BY guide covers
aggregating without a GROUP BY clause.
An AI agent on your keys, and MCP for the agent you already use
The console ships Amazon Q, a hosted assistant that answers AWS questions from
the console chrome (aws.amazon.com/q/developer). DynoTable's agent is a different
kind of tool. Inference runs on Amazon Bedrock in your own AWS account; no
DynoTable server sees your prompts or rows, and you pay AWS at cost with no
markup. The agent reads your key schema and GSIs before it queries, prefers a
Query over a Scan when your keys allow it, and can only stage writes, as a
diff you review; nothing is committed without your say-so. The
AI chat docs cover setup, models and permissions.
If you already work with Claude Code, Cursor or Codex, point that agent at your tables instead: DynoTable exposes them over MCP, with a scope you pick per connection (read-only, read + stage, or full). External agents never write directly. Their changes land in the same staging area as a reviewable diff, and you commit. The MCP setup guide has the details.
Built for daily DynamoDB work
Day-to-day speed is mostly small things repeated hundreds of times, and this is where a desktop client separates from a browser tab:
- Tabs and folders: keep tables, queries and item editors open in tabs, group them into folders, and get the whole workspace back when you restart.
- Saved queries: one query library across PartiQL and SQL, so the statement you tuned last sprint is a keystroke away instead of rebuilt from memory.
- Profile switching: every profile from your
~/.awsconfig, each pinned to its region, switchable with ⌘P (or ⌘1–⌘9; Ctrl on Windows and Linux). No re-sign-in, no role-switch dance. - Autocomplete: filters suggest attribute names from your items, and the query editors complete table names and SQL as you type.
- Keyboard-first: ⌘K opens a table, a Smart Table, a workbench or a chat, or starts a create action.
- Staged writes: every item save offers Stage or Commit. A staged change, like everything an AI agent drafts, waits in a per-table staging area as a per-attribute diff you review and commit, and committed edits can be reverted from History. Console edits save the moment you click.
- DynamoDB Local: point a profile at localhost and browse local tables like any region. The downloadable DynamoDB runs "without accessing the DynamoDB web service" (AWS docs), and the web console shows only the web service, so local tables are invisible to it.
Where the console's vector search stops
The console handles part of vector search. It creates a vector index from a table's Indexes tab, and Explore items has a Search mode that runs one, with an index picker and a Top K. It does not produce the vector. AWS's own launch walkthrough generates the query embedding outside the console and then "paste[s] the query vector into the Search vector field", and the guide is blunt about the stored side: "DynamoDB does not recompute embeddings for you. If you change the source content that produced an embedding … the stored vector does not update automatically" (working with vector search). PartiQL doesn't get around it, because "Vector indexes are not accessible through PartiQL" (requirements).
With the console alone, a script has to call an embedding model, write each vector back and run again whenever the text changes. DynoTable does that for the edits you make in it. Bind an embedding model and its source attributes to the index once, then type a sentence instead of a float array, right-click a row for Find similar, and let each item-editor save that changes the source text rewrite that item's embedding. Bulk edits, PartiQL writes and writes from your own application are not re-embedded, so your app still needs its own embedding step.
A vector index needs an on-demand table, doesn't work on DynamoDB Local and takes minutes to build; creating one needs a paid seat. Typed-sentence search and embed-on-save need AI set up and spend Bedrock tokens on your own account, while searching by a pasted vector and Find similar need no AI setup and spend no Bedrock tokens. Vector search covers the setup.
The busywork the console hands you
The console's item browser is a thin wrapper over the DynamoDB API, and it hands two of the API's rules straight to you.
- Filters don't reduce what you pay for. A filter expression "is applied
after a
Scanfinishes but before the results are returned," so aScan"consumes the same amount of read capacity, regardless of whether a filter expression is present" (AWS docs). That is true in any client, DynoTable included, and the console shows no read estimate before you run. The query vs scan guide covers why this matters. - Pagination is manual. "A single
Scanrequest can retrieve a maximum of 1 MB of data," and "the absence ofLastEvaluatedKeyis the only way to know that you have reached the end of the result set" (AWS docs). The console shows results page by page, so walking a table means clicking through page after page. DynoTable's grid follows the cursor for you and can run a query to the end of the result set; the pagination guide explains how the cursor works under the hood.
How to export a DynamoDB table to CSV
The console's own bulk export is Export to S3. It writes a full or filtered export from the table's point-in-time recovery window into a bucket, as DynamoDB JSON or Amazon Ion. It needs PITR switched on and consumes no read capacity. A full export is billed on the table's size, and filtering doesn't lower that unless it selects a single partition key value (AWS docs). That suits Athena or Glue. A CSV for a spreadsheet still needs a conversion step.
DynoTable exports the whole result set of a query or scan, filtered views included, as CSV, a JSON array or NDJSON, in plain values or raw DynamoDB JSON, to a file (the clipboard takes the loaded rows or a selection). Exports run in the background with progress in the Activity panel, and since v1.16.2 a table tab's visual query can also start a filtered export to S3 (the same AWS export: PITR, DynamoDB JSON or Ion). The longer-form options (AWS CLI, S3 export, scripts) are covered in the export DynamoDB to CSV guide.
DynamoDB's low-level API uses type descriptors (S, N, B, BOOL, …) as
tokens telling DynamoDB how to interpret each attribute
(AWS docs),
so a naive CSV dump of DynamoDB JSON leaks {"S": "..."} wrappers unless the
tool flattens them (the data types guide explains the type
tags).
Try DynoTable against the same tables
Download DynoTable for macOS (Apple Silicon or Intel), Windows or Linux,
point it at the same profile and region you use in the console, and run a JOIN
or GROUP BY you couldn't express before. The trial is free for 30 days, no
credit card required. Paid Individual seats start at $9/mo billed annually
($108/yr); see pricing for monthly and Team rates. After the trial,
the Free plan keeps browsing, PartiQL SELECT, in-app exports and MCP
schema/item reads with no time limit.
FAQ
Is there a better alternative to the AWS DynamoDB console?
Yes. DynoTable is a desktop DynamoDB client that adds what the console never had: a SQL Workbench for JOINs, GROUP BY and aggregates, an AI agent on your own Bedrock keys, MCP access for coding agents, staged writes, whole-result CSV/JSON/NDJSON exports, and tabs, folders and saved queries.
Why would I pay for a DynamoDB app when the AWS console is free?
DynoTable's Free plan is also free, with no time limit. 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.
Why can the DynamoDB console not run JOIN or GROUP BY?
The console queries with PartiQL, whose SELECT grammar is single-table with an
optional WHERE and ORDER BY, and it has no row aggregates. The one function AWS
lists under aggregates, SIZE, returns a single attribute's size in bytes
(AWS docs).
DynoTable's SQL Workbench plans those queries on the client, compiling them down
to DynamoDB's Query/Scan operations.
Do I need to migrate my data to use a console alternative?
No. DynoTable reads your standard AWS credential chain and points at the same regions and tables; your data stays in DynamoDB, so there's nothing to migrate.
Related
- Browse the full comparison hub for every DynoTable alternative.
- See also DynoTable as a DynamoDB GUI and the NoSQL Workbench comparison.
- Build queries fast with the free DynamoDB Expression Builder.
Last verified 2026-10-09. AWS, DynamoDB, Amazon Q and the AWS console are trademarks of Amazon Web Services; referenced here for identification only.





