New Ask DynoStudio, Agent mode & an MCP Gateway

Built for the queries you never planned.

A desktop DynamoDB system studio. Write SQL across live tables, vector indexes, OpenSearch and S3 Tables, run the queries you planned as ready‑made functions, and see every native request and its cost before it runs.

 Read the docs →

Free for non-commercial use · See pricing →

Live preview on the Bean & Bark sampleSwitch tabs, run a query, try a function

DynoStudioProfessional
PartiQL

Run SQL-style DynamoDB statements against the selected workspace stage.

Query Library
SELECT OrderId, Placed, Status, Total
FROM "BeanAndBark"
WHERE pk = 'CUSTOMER#c-014' AND begins_with(sk, 'ORDER#')
Executes asQueryQuery — begins_with prefixPK ✓
Query BeanAndBark · pk = "CUSTOMER#c-014" · begins_with(sk, "ORDER#")
A partition-key equality: only this customer’s partition is read.
ChartReportExport
#OrderIdPlacedStatusTotal
1Order#88422026-06-19delivered$540
2Order#90132026-06-27shipped$360
3Order#91882026-07-01lost?$420
Returned 3 items · 0.5 kB · 8 ms100% efficient · 0.5 RCU · 1 key value
Loaded 1 table(s).1 table4 indexes4 entitieseu-west-1
  • Bean & Bark, the tutorial table
  • Credentials stay on your machine
  • A native desktop app
  • No .NET required
PartiQL

One dialect for every data plane.

Live tables, native vector indexes, OpenSearch and S3 Tables, in one PartiQL dialect. What DynamoDB can’t run natively, from joins to GROUP BY, is lowered to the requests it can, with the plan shown before it runs.

Failed orders in one org, joined to each customer.
SELECT o.orderId, o.total, c.email
FROM "prod.Orders" AS o
JOIN "prod.Customers" AS c
  ON c.pk = 'Customer#{CustomerId}'
WHERE o.pk = 'Org#kanject' AND o.status = 'FAILED'
SQL by emulationclient-side
  1. No JOIN in the API — Scan "prod.Orders"
  2. Scan "prod.Customers" too
  3. Merge on CustomerId in JS
2.4Mitems scanned
DynoStudionative
  1. Query "prod.Orders" WHERE pk = 'Org#kanject'
  2. Match 12 FAILED orders
  3. BatchGetItem "prod.Customers" ×12
39items read
Executes asQuery "prod.Orders" → BatchGetItem "prod.Customers" — two native request groups
Save as function
See every statement we support →Read the full dialect reference → Built on PartiQL, the open query language DynamoDB itself speaks.
Functions

Most of them write themselves.

A function is a named question with typed inputs: a Get, a Query or a Scan you can run again tomorrow. Two sources generate them for you. The third is you.

From your modelEvery edition

Point it at a table. It infers the model.

One bounded read of live items, sized and priced before it runs. A deterministic engine, no language model, groups them by key shape into entities, key templates, types and indexes. You review, you save, and every key pattern becomes a ready-to-run Get or Query.

Infer the model from BeanAndBarkThree steps. Only the second reads the table; the canvas changes only after the third.
EntityKeysItemsCarries
CustomerEntityPKCUSTOMER#{CustomerId}SKPROFILE4,268UNQEmailUNQReferralCode
OrderEntityPKCUSTOMER#{CustomerId}SKORDER#{OrderNumber}732byStatusStatus · Placed
SubscriptionEntityPKCUSTOMER#{CustomerId}SKSUB#{SubNumber}399—
ProductEntityPKPRODUCT#{Sku}SKPROFILE10UNQSku
Saving generates 11 functions
Trusts any kind of 1 in 1,000 items or more; rarer kinds come out thin or unseen.
What the Functions tab fills withGenerated · one per key pattern
QueryGetCustomerById
QueryGetOrderByCustomerId
QueryGetSubscriptionByCustomerId
GetGetProductBySku
QueryQueryOrderByStatus
+ 6 more from the 514 Kanject index rows it foundProfessional
From Kanject indexesProfessional

The finders your repository already has.

On tables written with Kanject Core, unique, collection, range and search indexes live as reserved rows in the base table. DynoStudio reads them and lists finders named after your generated repository’s methods.

UniqueEmail· CustomerEntity
Key shape$$Unique#Email#{Email} · ReservedData Generates
QueryFindCustomerByEmailAsyncone item
QueryIsCustomerEmailUniqueAsynctrue / false
Stored as one reserved row per distinct value in the base table that points back at the owning item — no GSI, no index storage bill, one extra write per item.
Saved by youEvery edition

Any query you would run twice.

Save a Builder or PartiQL query under a name. Mark each key Parameter or Fixed: a parameter binds as a native value at run time, never pasted into the statement.

Save as functionReusable key access pattern — fill the values at run time
Function nameordersByStatus
KeysStatusParameterFixedsample · processing
executes asQuery BeanAndBark · index byStatus · Status = {Status}
Parameterized · 2 of 3 left on CommunityCancelSave function
Three sources. One list. One runner.Whatever wrote it, a function opens the same way.
01Typed inputsEach key variable becomes a field, required or optional, typed from the model.
CustomerIdc-014
OrderNumberoptional
02Executes asThe native request resolves as you type, before anything is sent.
executes asQuery BeanAndBark · pk = "CUSTOMER#c-014" · begins_with(sk, "ORDER#")
03Result and receiptRows as a grid or JSON, with the capacity the read consumed.
Returned 3 items · 0.5 kB · 8 ms100% efficient · 0.5 RCU · 1 key value
Generated and saved functions run in every edition. Community keeps 3 parameterized functions per workspace; Professional removes the limit and adds Kanject-index functions. Run one in the window above ↑
Executes as

Know what it reads before it runs.

Every surface names the native DynamoDB request it is about to send, and every result carries a receipt for what was billed. A Scan cannot hide.

One question · two plansWhich orders are still processing?
SELECT OrderId, CustomerName, Placed, Status FROM "BeanAndBark" WHERE Status = 'processing'
Executes asScanScan — full table readReads every item, then filters
Scan BeanAndBark · Status = "processing"
Read5,923 items billed Returned4 items
<0.1% efficient109.5 RCU372 ms
SELECT OrderId, CustomerName, Placed, Status FROM "BeanAndBark"."byStatus" WHERE Status = 'processing'
Executes asQueryQuery · byStatusPK ✓
Query BeanAndBark · index byStatus · Status = "processing"
Read4 items billed Returned4 items
100% efficient0.5 RCU9 ms
ScanWhat the Scan reads 5,923 of 5,923 items
QueryWhat the Query reads 4 of 5,923 items

One dot per item in the table.

219×

less capacity for the same 4 rows.

One CREATE GLOBAL INDEX apart, and the studio shows you which side you are on before you press Run.

  1. The request, named first

    “Executes as” spells out the exact native request on the Builder, on every function and in the PartiQL console. One click copies it.

  2. The read funnel

    Items read and billed, against items returned, so a filter that scans and discards never hides its waste.

  3. A receipt for every run

    Each result reports the capacity it consumed, its latency and payload size. The habit that keeps DynamoDB bills boring.

  4. Read-only stages

    Mark production read-only and writes are refused outright, across the editor, the item browser, saved functions and transactions.

Operate

Production work, in the same window.

Real questions cross accounts, stages and partition keys. Stages, read-only production, table health, reports and analytics replicas sit beside the table you query. One desktop workspace for the whole working set.

Every account. Every stage.

Sign in with AWS IAM Identity Center or named profiles and keep dev, staging and prod apart as stages. Mark production read-only and writes are refused across the editor, the item browser, saved functions and transactions, not just hidden.

WorkspaceBean & Bark
Deveu-west-1 SSO
Stagingeu-west-1 SSO
Prodeu-west-1 Read-only
UPDATE "BeanAndBark" …refused · Prod is read-only

Reports, without a handoff.

Turn query results into tables, charts and notes in a titled report that keeps the query and the read cost that produced it. Export to CSV or JSON when the answer has to travel.

ReportWest revenue by monthTable · Chart
from revenueByMonth5,923 items read · 109.5 RCU · folded in the studio

Table health, answered.

A per-table CloudWatch view opens on a verdict, backed by throttles, capacity and latency over the window you choose. See what that window cost, rank the busiest tables in the region, and read the hottest partition keys, with the billed call shown first.

HealthyBeanAndBark · last 24 hours1h · 24h · 7d
What this window costRegion top tablesRead hot keys

Heavy questions, off the live table.

When a report would become an expensive production Scan, provision a zero-ETL DynamoDB → S3 Tables analytics replica from the same workspace, then monitor its status, staleness and errors.

CREATE ANALYTICS REPLICA IF NOT EXISTS FOR TABLE "BeanAndBarkSales"
  1. PITR check
  2. S3 Tables bucket + catalog
  3. Lake Formation / Glue wiring
  4. IAM role
  5. Glue zero-ETL integration
Native calls, permission gaps and recurring costs previewed before you consent.
AI & agents · Beta

AI that has to show its plan.

Turn everyday questions into DynamoDB queries. Investigate slow exports and get index proposals you can review. Or connect Claude Code and Cursor through DynoStudio’s MCP Gateway—with query plans, bounded reads, and explicit data-access controls.

From a slow export to an index proposal.

Why does the morning export take so long? In this example, a scan reads 5,923 items to return four. Agent mode inspects the table’s schema and access patterns, compares query plans, and drafts an index that would let the export use a targeted Query. You review the evidence and decide whether to apply the proposal.

  • Investigate query performance, plan a new access pattern, or get a model proposal
  • Choose Low, Medium, or High investigation depth to cap time, model calls, and token usage
  • Review proposed reads, indexes, and models before running or applying them

Ask in plain English. See how the query will run.

Ask for “every order still processing, oldest first.” DynoStudio drafts the PartiQL and checks it against your table. See whether it uses a Query or Scan, which index it targets, and what it reads. Insert the draft into your editor, review it, and run it when you are ready.

  • Start from the PartiQL console, table Browse, the Board, or ⌘K
  • Query plans come from DynoStudio’s analyzer, which also checks queries you write yourself
  • Drafts use schema and access patterns; inspect the exact request with “View exact AI payload”

Work with DynamoDB from your coding agent.

Give Claude Code, Cursor, or another MCP client access to your table’s schema, access patterns, and query tools through DynoStudio. Connected clients can explain and execute SELECT queries within the gateway’s session limits. The Gateway console checks the connection and gives you the configuration snippet for your client.

  • Each query needs an analyzer-issued plan before execution; single-item writes need a session you arm, and DDL stays in the studio
  • Reads have row, byte, capacity, and time limits; row access requires an explicit session grant
  • The connection stays on the selected stage and is accessible only from your machine, with a session token
Agent modeDepth · Medium
Why is the morning fulfillment export slow, and what would fix it?
  1. Inspect schemaBeanAndBark · pk, sk · 1 GSI
  2. Inspect access patterns“orders by status” has no keyed path
  3. Explain queryScan · 5,923 items read · 4 returned
  4. Compare plansScan vs Query on a Status-keyed index
  5. Propose indexDDL drafted for your review
Rounds4 / 10
Model calls6 / 20
Actions5 / 24
Time48s / 300s
Tokens in31K / 128K
Tokens out4.2K / 24K
Proposed · awaiting your approval
CREATE GLOBAL INDEX "byStatus" ON "BeanAndBark"
PARTITION KEY (Status)
SORT KEY (Placed)
PROJECT INCLUDE (OrderId, CustomerName)
With this index, the morning export could query processing orders directly.
Rows · OffDepth · Medium
Ask DynoStudio⌘K
Every order still processing, oldest firstDraft
SELECT OrderId, CustomerName, Placed, Status
FROM "BeanAndBark"."byStatus"
WHERE Status = 'processing'
ORDER BY Placed ASC
AnalyzerChecked · no diagnostics
Executes asQuery · BeanAndBark.byStatus
Context sentSchema · access patterns
No row dataStage · StagingBedrock · your account
Insert into editorView exact AI payload
Gateway console127.0.0.1 · loopback only
Claude CodeconnectedSession token · issued once
  1. get_schemaBeanAndBark · 1 GSI
  2. get_access_patterns6 patterns · 1 unkeyed
  3. explain_queryplan issued · Query byStatus
  4. run_query4 rows · plan-bound · 3 RCU
  5. run_queryrefused · SELECT only
Explain before runSELECT onlyStage pinnedRows off by defaultEvery call journaled
What the model sees

Built to work from your schema, not your rows.

Off until you turn it on

One switch controls AI & agents for your user on this machine. It starts off in every edition, and nothing turns it on without asking you. While it is off, DynoStudio sends nothing to a model.

Ask never sees a row

Ask DynoStudio drafts from your schema and access patterns. Row values are absent from its prompt by construction, not by a setting, and “View exact AI payload” shows the request verbatim.

Rows only on your say-so

Agent mode’s Rows switch starts off for every stage, every time the app opens. With it on, the agent can see up to 25 records per index lookup, and samples still wait for your approval. Gateway clients get rows only through a per-session grant.

Model live data without a model

Import from live table reads a sample and infers entities, keys and indexes on your machine. No LLM is involved, so it works in every edition with AI switched off.

Your model, your account

Ask and Agent mode run on Amazon Bedrock under your own AWS account, or on a local model through Ollama, LM Studio, or vLLM. Kanject hosts no inference, and no Kanject server sits in the path.

Review gateway activity

A local journal records every gateway call’s tool, stage, outcome, and cost. Credentials and row data are excluded from the record.

AI can make mistakes — check queries and answers before you rely on them. Included in Professional, Business, and Enterprise. For Ask and Agent mode, bring your own Bedrock access or local model. AWS bills Bedrock usage separately; local inference has no per-request provider fee.

Get Professional Read the AI docs →
Everything else

The rest is one ⌘K away.

Connect, model, query, report and operate from one window. Search the list the way you would in the app: 44 capabilities, no wall of cards.

Connect & model

  • AWS SSO & profiles

    Authenticate with AWS IAM Identity Center (SSO) or named profiles — many accounts and stages at once.

  • Multi-table tabs

    Keep several table investigations open in tabs and switch context without losing your place.

  • Backups in SQL

    BACKUP TABLE and RESTORE TABLE lower to native CreateBackup / RestoreTableFromBackup — snapshot a table before risky work, restore to a new table, both disclosed before they run.

  • S3 Tables analytics replicas

    Provision a zero-ETL DynamoDB → S3 Tables analytics replica and monitor its status, staleness and errors — heavy reporting moves off the live table.

  • Data modelling

    A visual builder for entities, keys, GSIs and access patterns — design offline or learn a live table’s shape.

  • Bring your POCO

    Import annotated C# POCOs and DynoStudio derives the model, keys and access-pattern functions. Optional, never required.

  • Multi-key GSIs

    Create native multi-key GSIs — up to four partition and four sort keys — without hand-encoding a KeySchema.

Query

  • First-class PartiQL

    Query live DynamoDB tables in SQL — key-aware JOINs, IN-subqueries, aggregates with GROUP BY, ON CONFLICT upserts, and atomic transactions.

  • Native vector indexes

    Create and drop DynamoDB vector indexes in SQL, then run descriptor-validated top-k VECTOR_DISTANCE queries as native, byte-metered SearchVectors requests.

  • OpenSearch & hybrid queries

    Search OpenSearch projections with MATCH, highlights and facets, or combine bounded DynamoDB, S3 Tables and OpenSearch legs with explicit freshness and cost receipts.

  • Named parameters

    Save a query once with {parameters} and run it as a form — values bind as native query parameters, never spliced into the statement, so reuse stays injection-safe.

  • Cost & safety, disclosed

    “Executes as” names the exact native request and what it will read before every run. Read-only stages refuse writes outright.

  • Live query analyzer

    As you type, the editor marks a full-table Scan against a keyed Query and shows the item count it will read.

  • Query Library

    A searchable catalogue of every supported statement — pick one and it drops into the editor against the table in view.

  • Create & manage tables

    Create tables and native GSIs in SQL — CREATE TABLE and CREATE GLOBAL INDEX run as disclosed control-plane calls, no console trip.

AI & agents

  • Ask DynoStudio

    Turn a question into a PartiQL draft. See its Query or Scan plan, insert it into your editor, and run it when you are ready.

  • Agent mode

    Investigate a slow export or a new access pattern. Compare query plans and review proposed reads, indexes, or models alongside the evidence.

  • Investigation budgets

    Choose Low, Medium, or High depth to limit each investigation. Track time, model calls, actions, rounds, and token usage as it works.

  • MCP Gateway

    Connect Claude Code, Cursor, or another MCP client to inspect your tables and run SELECT queries with required plans and session limits.

  • Gateway console

    Check that the local gateway is ready, then copy the connection configuration for your coding agent.

  • DynamoDB expert on call

    The agent can consult the AWS Labs DynamoDB modelling expert for reference guidance — pinned to a version, and sent no table data, schema or query text.

  • Your model, your account

    Use Ask and Agent mode with Bedrock in your AWS account or a model on your machine. Bedrock pricing is shown when you choose a model.

  • Off until you turn it on

    AI starts off in every edition. One switch controls access for your user on this machine; while off, DynoStudio sends nothing to a model.

Results

  • Table & JSON views

    Read any result as a sortable grid or raw JSON — switch between them without re-running the query.

  • Charts

    Turn results into funnel, heatmap and trend charts inline — no trip through a spreadsheet.

  • Reports

    Assemble multi-statement results into a titled report — tables, charts and notes, with cost provenance.

  • Export to CSV & JSON

    Send any result set straight to CSV or JSON for the spreadsheet, the ticket, or the next tool.

  • Import from CSV & JSON

    Load CSV or JSON into a table — from your machine or straight from S3 — with a key-aware preview and a conflict policy before anything writes.

  • Bulk delete & update

    Operate on whole result sets at once — previewed first, then guarded per-item so nothing changes blind.

  • Split view

    Open two tables, queries or stages side by side to compare data and plans at a glance.

Operate

  • Table health, answered

    A per-table CloudWatch dashboard opens on a verdict — healthy, watch, or problem — backed by throttles, capacity and latency over the window you choose.

  • What this window cost

    Billed reads and writes for the range in view, priced into an estimate — so "is this table expensive?" gets a number, not a feeling.

  • Hot keys, named

    One click reads the most-throttled partition keys via CloudWatch Contributor Insights — the billed call disclosed before it runs.

  • Region top tables

    Rank every table in the region by requests or capacity to see who is actually busy — then jump straight into that table’s metrics.

  • The read funnel

    Every page shows items read (billed) against items returned, so a filter that scans and discards never hides its waste.

  • A receipt for every run

    Each query’s footer reports the capacity it consumed, its latency and payload size — the habit that keeps DynamoDB bills boring.

Workspace

  • Cross-platform desktop

    A native desktop app for macOS, Windows and Linux — not a browser tab.

  • Local-first & private

    Credentials never leave your machine — connect straight from the desktop to your AWS account, with an optional passphrase or Touch ID app-lock. Everything else stays local unless you opt in — to a team workspace in your own AWS account, or to AI & agents on your own model.

  • Shared team workspaces

    Models, saved queries and reports sync across the team through a store in your own AWS account — versioned, encrypted under a customer-managed key, credentials never sync. One click on Business; Enterprise adds enforced Reader / Editor / Admin roles managed in your own DynamoDB table plus an in-account audit trail.

  • Dark mode & themes

    Light, dark and custom editor themes — the studio flips with the rest of your desk.

  • Keyboard-first

    A ⌘K command palette plus shortcuts for tables, stages, queries and actions — hands stay on the keys.

  • High performance

    Next-page prefetch, instant cold-open, and queries lowered to read only what they must — no waiting on the tool.

  • Clean & focused

    One consolidated workspace, not a maze of panels — icon-first chrome that stays out of the way.

  • Always improving

    Shipping improvements on a steady cadence, with release notes every time — the studio you use keeps getting better.

44 capabilitiesShipped capability only
Pricing

Free to explore. Licensed to ship.

Free for individuals, open source, education and companies under $250K. A commercial license is per developer, and a year of Professional ships with every annual Core and All Access license.

Free

Community

$0 free, forever
Individuals · OSS · education · companies under $250K
Download free
  • Browse tables, item editor and ⌘K command bar — any DynamoDB account, no .NET
  • Functions — save queries as functions (3 with reusable parameters) and run the access patterns generated from your model
  • Typed PartiQL — reads, writes, upserts, atomic transactions, INNER joins and IN-subqueries, lowered to native requests
  • Query Library — a catalogue of ready-made example queries
+ 5 more in the comparison

Self-certified — tick a box, no sales call. Cross $250K in trailing-twelve-month revenue or funding and you have 90 days to move to a commercial license.

Most popular
For commercial use

Professional

$15 / developer / month Billed monthly $12.50 / developer / month Billed $150 per developer per year
Developers · per-seat commercial use
Buy now
  • Everything in Community, licensed for commercial use
  • Unlimited reusable parameterized queries and functions, plus saved reports
  • Full modelling — import annotated C# or JSON models, author Kanject indexes, and check access patterns against the model
  • Advanced PartiQL — outer & cross joins, GROUP BY & aggregates, correlated subqueries, set operations
+ 8 more in the comparison

Already hold an annual Kanject Core or All Access license? It ships with a free one-year Professional subscription — you do not buy it separately. (BaaS modules are licensed separately and do not include it.)

For growing teams

Business

Annual only $20 / developer / month Billed $240 per developer per year · from 3 developers
Teams · annual billing · priority support
Buy team plan
  • Everything in Professional, packaged for team use
  • $20 per developer / month, billed annually ($240 per developer / year) — one line on the invoice, no platform fee
  • From 3 developers — add seats as the team grows, on one annual contract
  • Priority support for team rollouts and DynamoDB modelling questions
+ 3 more in the comparison

From $720/year — $240 per developer per year from 3 developers, no platform fee. Need a signed agreement, an SLA or a security review? Move to Enterprise.

For governed teams

Enterprise

Annual only From$12,000 / year · 25 developers
Signed agreement · SLA · security review
Talk to sales
  • Everything in Business, licensed for governed teams
  • Starts at $12,000/year — a flat $6,000/year governance platform plus 25 seats at $240/developer/year
  • Additional seats stay $240/developer/year unless your annual agreement sets a volume commitment or discount
  • Governed shared workspaces — choose the store, with a scoped IAM boundary, enforced Reader / Editor / Admin roles managed in your own DynamoDB table, and an in-account audit trail
+ 6 more in the comparison

Enterprise is a contract, not a hidden per-seat premium. We scope developer count, environments, SLA terms and security review before quoting the final agreement.

Prices are software licences. DynamoDB/S3 usage for your workspaces is billed by AWS because the team data stays in your account, under your IAM and retention controls.

Compare Community, Professional, Business, and Enterprise, side by side. Compare every feature Hide the comparison

Use this as the buying map: Community is the free solo workspace, Professional unlocks the advanced commercial workspace, Business adds the team layer per developer, and Enterprise adds governed rollout, procurement and SLA terms.

Community
Free
Professional
$15/mo · $150/yr
Business
$20/dev/mo · annual · from 3 devs
Enterprise
From $12,000/yr · 25 devs
Use rights
Commercial use license Community is intentionally generous, but it is not a commercial license once the company crosses the free-use threshold Non-commercial Commercial Team commercial Governed agreement
Eligible users Individuals · OSS · education · under $250K Solo developers and small teams Teams buying one annual plan Governed organizations
Seat model Seats mean active developers who open the studio, not every employee in the company Single user 1+ active developers 3+ active developers 25+ active developers · governed agreement
Advanced power
Advanced PartiQL Outer/cross joins, GROUP BY & aggregates, correlated/filter subqueries, set ops —
Native vector indexes & search CREATE / DROP VECTOR INDEX plus descriptor-validated VECTOR_DISTANCE top-k reads lowered to native SearchVectors —
OpenSearch & hybrid query planes OpenSearch MATCH / highlight / facets plus bounded DynamoDB, S3 Tables and OpenSearch composition with explicit freshness —
Saved queries & functions Every edition saves functions and runs the access patterns generated from your model. Community keeps 3 reusable parameterized functions per workspace; Professional removes the limit and adds Kanject-index functions Saved + generated · 3 parameterized Unlimited parameters + Kanject indexes Unlimited parameters + Kanject indexes Unlimited parameters + Kanject indexes
Model import from code Derive the model from annotated C# entities or a portable JSON model definition —
Custom reporting builder Fold one or more query results into reusable report templates, KPI blocks, tables and charts —
S3 Tables analytics replicas Create, alter, monitor and query DynamoDB to Amazon S3 Tables zero-ETL integrations, with native calls, freshness and recurring costs disclosed —
Limits
Local workspaces A workspace is a saved local modelling/querying context. Team sync is a separate Business/Enterprise capability when Shared Workspaces is enabled. 1 Unlimited Unlimited Unlimited
Shared team workspaces Models, saved queries and reports sync across the team through a store in your own AWS account — versioned, encrypted under a customer-managed key, no Kanject data plane, and credentials never sync. Business sets it up in one click; Enterprise adds a scoped IAM boundary, enforced Reader / Editor / Admin roles managed in your own DynamoDB table, and an in-account audit trail. — — In your AWS account Governed
Stages per workspace Use stages for dev/prod profiles, regions or accounts inside one workspace 2 Unlimited Unlimited Unlimited
Open tabs Counted across every pane and every kind of tab. At the limit you replace an open tab to keep working; nothing you have open is closed for you 3 at a time Unlimited Unlimited Unlimited
Query history retained Last 25 Unlimited Unlimited Unlimited
Data export per run Up to 1,000 rows Unlimited Unlimited Unlimited
Configurable query caps Multi-request lowerings refuse past a safe default; paid editions can raise or lower those limits intentionally Fixed safe defaults User configurable Team defaults + user tuning Governed defaults + user tuning
Workspace
Browse tables + item editor Inspect and edit items against any DynamoDB account you can connect to
Typed queries + command bar PartiQL authoring, command palette and guided actions stay available in every edition
Query Library Browse supported statements and drop one into the editor against the table in view — paid editions insert the reusable parameterized form Literal examples Reusable parameters Reusable parameters Reusable parameters
PartiQL: reads · writes · upserts · INNER joins · IN-subqueries Upserts via INSERT … ON CONFLICT (DO UPDATE / DO REPLACE / DO NOTHING), each lowered to one native write
Atomic transactions with a write preview The first Run previews the write set and native requests; an unchanged second Run commits it all-or-nothing
“Executes as” disclosure Native request + cost + plan shown before anything runs
Read-only stages Writes refuse at the execution path, not just in the visible controls
Schema-only / offline mode Model and review access patterns without connecting to a live table
Infer a model from a live table Sample a connected table and turn its key prefixes into entities, keys and indexes on your machine, with no LLM involved — and a pre-flight read bound for large tables
Code generation & export Export queries and generated code for the capabilities your edition includes
Connect to any DynamoDB account DynoStudio works as a DynamoDB client even when the app is not built with .NET or Kanject
AWS SSO, profiles and multi-account stages
Security
Saved credentials encrypted at rest Sealed with a passphrase-derived key — never written to disk in plaintext
App lock — biometric or passphrase unlock A responsible local security baseline: lock-on-launch, auto-lock and credential release after authentication
Per-command elevation for destructive writes Enterprise governance: choose which verbs re-authenticate per environment class. Item writes, DDL, transactions, PartiQL writes, scans, backups and restores are enforced at the dispatch layer, on every tab — a declined challenge means the call never reaches DynamoDB. Switching to a production stage, exporting 1,000 rows or more and saving results to disk ask the same way — — — Configurable
Modelling
Visual model builder Community covers basic single-table modelling and read-only maps; paid editions add the advanced builder, linting and code sync Starter Advanced Advanced Advanced
Schema import & code sync Paid editions can import Kanject.Dyno-annotated code or JSON models and keep the model aligned with source Manual / starter C# + JSON import C# + JSON import C# + JSON import
AI & agents
Ask DynoStudio Plain English to a checked PartiQL draft, with a Query or Scan plan to review before you run it —
Agent mode Investigate query performance and access patterns; review proposed reads, indexes, and models, with Low / Medium / High investigation budgets —
MCP Gateway for local agents Connect a coding agent to table context and SELECT execution, with required query plans, session limits, and a local connection token —
Model providers Ask and Agent mode use your own Bedrock access, with pricing shown beside the model picker, or a local model through Ollama, LM Studio, or vLLM — Bedrock or local Bedrock or local Bedrock or local
AI & agents off switch Off by default, for your user on this machine; while off, DynoStudio sends nothing to a model
Support & terms
Billing Business and Enterprise are annual because the value is team packaging, support and governance, not just the desktop binary — Monthly or annual Annual self-serve Annual agreement
Software updates Free updates While subscribed While subscribed While subscribed
Support Docs + changelog Priority email Priority team support Dedicated contact + SLA
Procurement package Business gives finance a clean purchase record; Enterprise adds a signed agreement with custom terms, invoice billing and security review support — — Receipt + license record Custom terms · security review
Volume terms — — — Signed agreement
Included with annual Core / All Access licenses Every annual Core and All Access license ships with a free one-year Professional subscription; BaaS modules are licensed separately — — —
Already a Kanject customer?

A free year of Professional DynoStudio ships with every annual Core and All Access license.

Every annual Core and All Access Enterprise license includes a one-year Professional DynoStudio subscription at no extra cost; BaaS modules are licensed separately and do not include it. If your app uses Kanject.Dyno annotations, DynoStudio can import that model directly; you can also model from scratch or inspect a live table.

See Kanject licenses
Download

Every desktop. Natively.

The same studio, compiled to a native binary for macOS, Windows and Linux. Drop your email and the download link arrives in your inbox. No call, no calendar, no qualification questions.

Email me the download link See pricing

Free for non-commercial use · Professional from $12.50 per developer a month, billed annually

  • macOS 14 Sonoma or later
    Apple siliconIntel
  • Windows 10 & 11 · 22H2 or later
    x64ARM64
  • Linux Ubuntu 22.04+ · Debian 12+ · Fedora 40+
    x64ARM64

Compiled with .NET Native AOT: a self-contained binary, no runtime to install.

Questions

Asked before every download.

The short answers. The long ones are in the docs, including a chapter-by-chapter tutorial on the same Bean & Bark table the window above runs on.

Start the Bean & Bark tutorial →
Can you use SQL with DynamoDB?

Yes. DynamoDB natively speaks PartiQL — a SQL-compatible query language — for reads and writes against a single table. DynoStudio extends that with the parts the service leaves out: key-aware JOINs, IN-subqueries, aggregates with GROUP BY, set operations and atomic transactions. Anything DynamoDB can't run server-side is lowered to the native requests it can, and the exact translation and cost are shown before the statement runs.

How do you query DynamoDB?

You read items with a SELECT … WHERE statement. The trick is the WHERE clause: a partition-key equality (or IN list) stays a cheap Query that touches only matching items, while any other predicate degrades to a Scan that reads — and bills — the whole table. DynoStudio classifies every query as Query or Scan before it runs, points at the predicate responsible, and lets you target a GSI to keep a filter on the cheap side.

Does DynamoDB support joins?

Not natively — DynamoDB has no JOIN and can't run a subquery. DynoStudio adds key-aware joins, semi-/anti-joins via IN / NOT IN (SELECT …), and set operations, composing each from key-driven reads (BatchGetItem) after the first query. Every read in the chain is disclosed and billed honestly, so a join never hides a full-table Scan.

Can you run aggregate queries like COUNT or SUM on DynamoDB?

DynamoDB has no aggregate functions, so DynoStudio folds them client-side: COUNT, SUM, AVG, MIN, MAX and GROUP BY, plus table profiling. Because the fold happens after a read, every item the aggregate touches is read and billed — the studio shows that item count up front, so a COUNT(*) over a table is never a silent surprise on the bill.

Does DynoStudio have AI?

Yes. Ask DynoStudio turns plain English into PartiQL drafts you review and run. Agent mode investigates questions such as “why is this export slow?” and proposes reads, indexes, or models for your approval. The MCP Gateway connects coding agents such as Claude Code and Cursor to table context and controlled SELECT execution. All three are included in Professional, Business, and Enterprise. Ask and Agent mode use your own Bedrock access or a local model.

What does the AI see? Does DynoStudio send my data to a model?

Your schema, and your rows only when you say so. Ask DynoStudio sends schema and access patterns, never row values, and lets you inspect the exact request. Agent mode adds design notes and row-free runtime statistics; row values reach it only while its Rows switch is on for that stage — up to 25 records per index lookup, and a sample only after your approval. The gateway returns rows to a connected client only if you grant them for that session, and that client uses its own model. A re-embed job you arm sends the fields its recipe names to your embedding model. Inferring a model from a live table involves no model at all. Table, entity and attribute names do reach the model as schema. For Ask and Agent mode, a local model keeps prompts on your machine; Bedrock runs under your AWS account. Turning AI & agents off stops DynoStudio from sending anything to a model.

Can I connect Claude Code or Cursor to DynoStudio?

Yes. Enable the MCP Gateway, check the connection in the Gateway console, and copy the configuration for your client. Connected agents can inspect table context and execute SELECT queries after obtaining an analyzer-issued plan, within row, byte, capacity, and time limits. Single-item writes are refused unless you arm the session, and each one runs once from a previewed plan; DDL and bulk operations stay in the studio. Each connection uses a session token, stays on its selected stage, and starts with row access off. Every call is recorded locally. Available in Professional, Business, and Enterprise.

Can DynoStudio create and query DynamoDB vector indexes?

Yes. Professional can create and drop native DynamoDB vector indexes in SQL, completes the DDL from live table metadata, and tracks asynchronous backfill until the index is ready. A VECTOR_DISTANCE SELECT validates dimensions, filters, projection and readiness against the live descriptor, then lowers to one eventually consistent, byte-metered SearchVectors request.

When can I try it?

Now — DynoStudio is generally available and self-serve. Drop your email at the bottom of this page and the download link arrives in your inbox. No call, no calendar, no qualification questions.

Is the PartiQL console just a passthrough?

No — and it isn't a JavaScript emulation layer either. The editor speaks a richer PartiQL than DynamoDB accepts natively — IN (SELECT …) subqueries, key-aware JOINs, aggregates with GROUP BY, table profiling, multi-statement scripts, ON CONFLICT upserts, and atomic transactions — and compiles every statement to the operations the service actually runs. The editor diagnostics and "Executes as" strip show each translation before it leaves the machine.

Do I need an AWS connection?

No. Schema-only mode lets you design and validate access patterns offline. Connecting to AWS (IAM SSO or access keys) unlocks live browse, query and write.

Do I need .NET to use DynoStudio?

No. You can connect, browse tables, run queries, build reports, and model DynamoDB from scratch without .NET. Annotated C# POCOs are an import shortcut for teams that already describe their DynamoDB model in code; they are not the only way to model a table.

Can DynoStudio create S3 Tables analytics replicas?

Yes. Professional includes a control-plane flow for DynamoDB to Amazon S3 Tables analytics replicas: `CREATE ANALYTICS REPLICA` expands into the ordered DynamoDB, Glue, Lake Formation, IAM and S3 Tables setup plan, with permissions, native calls and recurring costs previewed before consent. Query the replica explicitly through `s3tables."T"`, or configure `hybrid."T"` to merge append-only history with recent DynamoDB writes at the replica watermark. DynoStudio never silently reroutes an unqualified live-table query.

Self-hosted or SaaS?

Desktop app — a native download for macOS, Windows and Linux. Your AWS credentials and schema files never leave your machine; connections are direct from the desktop client to your AWS account.

Is DynoStudio free?

Yes, for non-commercial use — individuals, hobby projects, open source, education, and companies under $250K in revenue or funding raised over the trailing twelve months. The free tier covers the everyday workspace: connect, browse, the item editor, modelling (including inferring a model from a live table), functions, typed PartiQL (reads, writes, upserts via ON CONFLICT, atomic transactions with a write preview, INNER joins and IN-subqueries), code export and the ⌘K command bar — every action still shown as the native request before it runs. Full modelling, custom reports, S3 Tables analytics replicas, the advanced dialect (outer joins, aggregates, correlated subqueries, set operations) and AI & agents (Ask DynoStudio, Agent mode, the MCP Gateway) are part of Professional. Commercial use needs a Professional, Business or Enterprise license.

What counts as commercial use?

Using DynoStudio for a company's revenue-generating work once that company is over $250K in trailing-twelve-month revenue or funding. Below that threshold — and for individuals, open source, and education — the non-commercial license covers you. Eligibility is self-certified; there is no audit.

What is the difference between Professional, Business and Enterprise?

Professional is the self-serve per-developer license ($15/dev/mo, or $150/dev/yr with two months free): the full workspace with priority email support. Business is the same product capability plus the team layer — shared workspaces, priority team support and a procurement record — at $20/developer/month billed annually ($240/developer/year), from 3 developers and with no platform fee. Enterprise keeps the Business seat rate and makes the governance premium explicit: $6,000/year for the governed layer plus 25 seats at $240/developer/year, from $12,000/year. It adds a signed agreement with custom terms and invoice billing, security review support, a dedicated contact, SLA terms and governed shared workspaces.

I already pay for Kanject — do I pay for DynoStudio too?

No. Every annual Core and All Access license ships with a free one-year Professional DynoStudio subscription, so DynoStudio is never a second invoice while your license is active. (BaaS modules are licensed separately and don't include it.) Business seat bundles and Enterprise governance are separate upgrades on top.

How is the commercial license counted, and how is it billed?

Per active developer — the people who actually open the studio, not your whole headcount. Professional bills monthly or annually (commit annually and get two months free). Business bills $240 per developer per year — $20 a month, billed annually, no platform fee — from 3 developers ($720/year), and scales per developer through checkout. Enterprise starts at $12,000/year on a signed annual agreement: a $6,000/year governance platform plus 25 seats at $240 per developer. Either way your DynamoDB tables stay in your own AWS account, so there is no usage meter and no per-query charge.

Why do I pay for Business if the shared workspace data lives in my AWS account?

Business is not a hosted-storage fee. It is the licensed team workflow: the software that provisions and coordinates the customer-owned data plane, the shared workspace layer, roster/invite flows, team defaults, priority support, updates and one annual procurement record. AWS bills the DynamoDB/S3 resources directly because the team data stays under your account, IAM, audit and retention controls; Kanject does not meter your workspace usage or charge per query.