New Ask DynoStudio, Agent mode & an MCP Gateway

Built for the queries you never planned.

DynamoDB is unbeatable for the access patterns you planned, and unforgiving for the ones you didn't — however you model it. DynoStudio is a desktop DynamoDB system studio for that gap: write SQL across live tables, native vector indexes, OpenSearch, and S3 Tables; preview every request and cost; and build reports without a hand-built query pipeline or remodel.

 Read the docs →

Free for non-commercial use · See pricing →

console.partiqlSpin up a table without leaving the query console.
CREATE TABLE "prod.Ledger" (
  PARTITION KEY pk STRING,
  SORT KEY sk STRING
) WITH BILLING = ON_DEMAND
SQL by emulationclient-side
  1. No CREATE TABLE in the PartiQL API
  2. Switch to CDK / CloudFormation / the console
  3. Define it there, then come back to query it
1context switch to define it
DynoStudionative
  1. One statement, in the same console
  2. Lowers to CreateTable — shown before it runs
  3. CREATING → ACTIVE, then query it right here
0context switches
Executes asCreateTable "prod.Ledger" (pk, sk · ON_DEMAND)
See every statement we support →Read the full dialect reference →
Light + dark — every surface. Try the theme toggle.
Built on an open standard

PartiQL underneath. DynamoDB-native at the wire.

DynoStudio implements PartiQL — the open query language DynamoDB itself speaks — and follows the spec's reduction model: richer syntax lowers back to the operations the service runs. The result feels like SQL in the editor, but still resolves to DynamoDB requests you can inspect.

Read the PartiQL specification
Inside the studio

Model, query, report, and operate in one window.

Connect to AWS accounts with SSO or profiles, model a table offline, browse live data in tabs, run PartiQL with the native request and cost profile in view, and create S3 Tables analytics replicas when a report belongs off the live table. New to the dialect? The built-in Query Library is a searchable catalogue of supported statements — pick one and it drops into the editor against the table in view, ready to run. This is the actual studio surface — a desktop app for Mac, Windows, and Linux — light and dark, flipping with the page.

Available in
macOS Windows Linux
DynoStudio
Kanject WorkspaceStaging
Search or run a command⌘K
stage.KanjectConfiguration
▦ Data⛁ Modelling
⌕ Builderƒx Functions>_ PartiQLStrong read
SELECT * FROM "stage.KanjectConfiguration"Scan — full table readNo key condition, so every item is read and billed before any filter applies. Add a WHERE with an equality on pk to run it as a Query. LIMIT 25;SELECT * FROM "stage.KanjectConfiguration" WHERE pk = '$$Unique#BrandName#kanject'Key conditionAn equality on the partition key — DynamoDB serves this as a Query, straight to the item, not a Scan.;SELECT COUNT(*) FROM "stage.KanjectConfiguration" WHERE pk = 'ItemCategories#p1'Key conditionAn equality on the partition key — reads just this one partition as a Query.;
Live analyzerScanfull read — every item billedkey conditionnarrows to a Query
Executes asScan — full table read
Scan("stage.KanjectConfiguration") — full read
Scan reads and bills every item in the table; WHERE filters apply after the read.
LIMIT 25 executes as the request's Limit parameter — DynamoDB PartiQL has no LIMIT keyword.
#PK · PKSK · SKIDGSI2PK_GSI2SK_GSI · GSI2PKGSI1PK_GSI1SK_GSI · GSI1PK
1ItemCategorySizes#d46a2d5fSizeInfo#d46a2d5fd46a2d5f-85d7-4431ItemCategories#904b930e-4866-45bf-8679-b8615a893009ItemCategorySizes
2$$Unique#BrandName#kanjectReservedData857cbf5f-de4a-49ee
3ItemColours#4c0a858bInfo4c0a858b-e2b5-4b21ItemColours
4$$Unique#CategorySize#xsReservedData014fb90d-7c09-4a14
5$$Unique#CategorySize#smReservedDataf3daf236-e426-46d8
6$$Unique#CountryCategory#ukReservedDataca72e18a-5d43-43a2
7$$Unique#ItemColour#redReservedData
8$$Unique#ItemColour#blueReservedData
9$$Unique#CountryCategory#auReservedData3077f574-0cf3-485f
10RegionSizes#bbab2ef8Region#EU#Categorybbab2ef8-b81e-4edaItemRegionSizeRegion#EU#Category#cd6dd22c-6f93-47e4-8385
11RegionSizes#1b06012cRegion#AU#Category1b06012c-ee0d-4676ItemRegionSizeRegion#AU#Category#cea6815d-e635-4cc3-82a2
12RegionSizes#cb416a44Region#UK#Categorycb416a44-e091-4aecItemRegionSizeRegion#UK#Category#70652855-006f-4d6a-ad76
13ItemCategorySizes#f9413877SizeInfo#f9413877f9413877-58cc-4ea4ItemCategories#ca7cac7e-27cf-4553-ae9b-b3f8ad952d1bItemCategorySizes
14$$Unique#CategorySize#mdReservedData99a4ce33-37f0-49f0
Fetched 25 items in 740ms · 100% efficient · 1.5 RCU · 25 partitionsTableJSON25 ⌄⤓ Export
Loaded 18 table(s).18 tables · 3 indexes · 65 entities eu-west-2· Layout · Split Workspace
Light + dark — every surface. Try the theme toggle.
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 240,000 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; writes and DDL are refused
  • 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 · 240,000 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
Your data, your controls

Know what it can access. See what it will do.

Off until you turn it on

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

Choose your model

Ask and Agent mode use Amazon Bedrock in your AWS account, or a model on your machine through Ollama, LM Studio, or vLLM. Kanject does not host the inference.

Control row access

Ask uses schema and access patterns without table rows. Agent mode needs a per-stage grant and your approval to sample rows. Gateway row access is granted per session.

Review before you commit

Ask drafts go to your editor. Agent mode’s proposed reads and changes wait for approval. Connected MCP clients can run SELECT queries after obtaining a plan, within session limits.

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.

Inspect the AI request

“View exact AI payload” shows the request Ask DynoStudio sends to the model, so you can inspect the context behind a draft.

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 →
Team evaluation

Real questions cross accounts, stages, and partition keys.

DynoStudio is built for the working set around DynamoDB: many AWS accounts, many stages, model changes, incident tabs, reports, analytics replicas, and production safety rails in one desktop workspace.

Download DynoStudio
01

Work across accounts

Use AWS SSO or profiles, keep dev/staging/prod separated as stages, and hold multiple table investigations open in tabs.

02

Protect production data

Read-only stages refuse writes across the editor, item browser, saved functions and transactions, instead of relying on UI hiding.

03

Report without handoff

Turn query results into saved reports and visuals. When a report should move off the live table, provision and monitor an S3 Tables analytics replica from the same native-call plan.

SSO
accounts
Tabs
context
S3
replicas
One studio, the whole loop

From access pattern to answer.

Design the model, inspect the live table, run the query, build the report, and know what AWS will do before the request leaves your machine.

For modelling DynamoDB

Start blank, import code, or learn from live data.

Build a model from scratch, inspect an existing table, or import annotated application code when your team has it. DynoStudio keeps entities, keys, indexes, access patterns and generated functions together instead of making the model a second artifact.

  • Visual model builder for entities, keys, GSIs and access patterns
  • Schema-only mode for offline design, plus live-table inspection
  • Annotated POCO import as a shortcut for .NET teams
For production investigations

Query, report, and keep AWS honest.

Every surface shows the native DynamoDB request it's about to send and what it will read. The editor flags a full-table Scan with live item counts, reports stay tied to the query that produced them, read-only stages refuse writes outright, and transactions require the same plan twice before they commit.

  • Multi-account stages with AWS SSO, profiles and read-only production
  • "Executes as" on every query surface, with one-click copy
  • Custom reports and S3 Tables analytics replicas for heavier questions
Code import shortcut

Import code. Or model from scratch.

Start with a blank model, inspect a live table, or import the schema your app already carries. For .NET teams, annotated entity records can double as the model source: [KeyTemplate], [ShardedKeyTemplate], [DynamoDbGsi], [DynamoDbGsiAlias<T>], and DynamoDB key attributes become entities, keys, indexes and access patterns in the studio. Edit the model visually or edit the code and re-import; either way the query surface stays tied to the schema instead of a separate diagram.

ProductEntity.cs OrderEntity.cs 14 annotations recognized 
using Amazon.DynamoDBv2.DataModel;
using Kanject.Core.NoSqlDatabase.Provider.DynamoDb.Abstractions.Interfaces;
using Kanject.Core.NoSqlDatabase.Provider.DynamoDb.Annotations.Attributes;

[DynamoDbGsi(Name = "Gsi1Index")]
[DynamoDbGsiAlias<ProductEntity>(name: "Gsi1Index", alias: "SellerProduct")]
[DynamoDbGsiAlias<OrderEntity>(name: "Gsi1Index", alias: "CustomerOrder")]
public abstract record CommerceEntity : IDynamoDbEntity
{
    [DynamoDBHashKey("pk")] public virtual string PartitionKey { get; set; } = "";
    [DynamoDBRangeKey("sk")] public virtual string SortKey { get; set; } = "";
    [DynamoDBGlobalSecondaryIndexHashKey] public virtual string Gsi1Pk { get; set; } = "";
    [DynamoDBGlobalSecondaryIndexRangeKey] public virtual string Gsi1Sk { get; set; } = "";
}

public record ProductEntity : CommerceEntity
{
    [KeyTemplate("Products#{Id}")]
    [DynamoDBHashKey("pk")]
    public override string PartitionKey { get; set; } = "";

    [KeyTemplate("Info#{SellerId}")]
    [DynamoDBRangeKey("sk")]
    public override string SortKey { get; set; } = "";

    [KeyTemplate("Seller#{SellerId}#Products")]
    [DynamoDBGlobalSecondaryIndexHashKey]
    public override string Gsi1Pk { get; set; } = "";

    [KeyTemplate("ProductInfo#{Id}")]
    [DynamoDBGlobalSecondaryIndexRangeKey]
    public override string Gsi1Sk { get; set; } = "";

    [DynamoDBProperty] public string ProductName { get; set; } = "";
    [DynamoDBProperty] public decimal Price { get; set; }
}

public record OrderEntity : CommerceEntity
{
    [KeyTemplate("Orders#{Id}")]
    [DynamoDBHashKey("pk")]
    public override string PartitionKey { get; set; } = "";

    [KeyTemplate("Info#{CustomerId}")]
    [DynamoDBRangeKey("sk")]
    public override string SortKey { get; set; } = "";

    [KeyTemplate("Customer#{CustomerId}#Orders")]
    [DynamoDBGlobalSecondaryIndexHashKey]
    public override string Gsi1Pk { get; set; } = "";

    [KeyTemplate("OrderInfo#{PlacedOn}#{Id}")]
    [DynamoDBGlobalSecondaryIndexRangeKey]
    public override string Gsi1Sk { get; set; } = "";
}
Detected
2 entities · 14 attributes · 1 GSI · 2 aliases
ProductEntity
PK PartitionKey (Products#{Id})
SK SortKey (Info#{SellerId})
SellerProduct
OrderEntity
PK PartitionKey (Orders#{Id})
SK SortKey (Info#{CustomerId})
CustomerOrder
→ 7 functions generated

Kanject Core annotations are the code-first shortcut. DynoStudio can also model from a blank canvas or a live table; teams using Core simply get to import the model their app already defines. See Kanject Core →

S3 Tables analytics

Move heavy questions off the live table.

For reports that would become expensive production scans, DynoStudio can provision and monitor DynamoDB to Amazon S3 Tables zero-ETL integrations from the same workspace. The preview names the DynamoDB, Glue, Lake Formation, IAM and S3 Tables calls, plus recurring costs, before consent.

Read the replica DDL docs →
01

One statement to start

Run CREATE ANALYTICS REPLICA FOR TABLE "orders-prod" and DynoStudio expands it into the ordered AWS setup plan instead of sending you through five consoles.

02

Costed native-call plan

PITR, table policies, S3 Tables bucket/catalog setup, Glue integration, Lake Formation grants and IAM role creation are listed before anything runs.

03

Health beside the table

Replica status, staleness, errors and source/target wiring stay attached to the table and stage that created them.

04

Still cost-honest

Exports avoid RCUs on the live table, but PITR, export GB, S3 Tables storage, compaction and read-side compute are still disclosed before you commit.

Feature highlights

One studio. Every DynamoDB question.

First-class PartiQL across live tables, native vector indexes, OpenSearch and S3 Tables — with every native request, merge and meter shown before it runs. Plus modelling, monitoring, reporting, import and export in one desktop app.

Reach every AWS account and stage — SSO or named profiles — then model the schema.

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.

Read, write and reshape live tables in SQL — with the native request and cost shown first.

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.

Draft queries in plain English, investigate slow exports, and connect your coding agent to DynamoDB with clear plans and data-access controls.

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.

See results your way, move data in and out, edit in bulk, and lay them out side by side.

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.

Watch cost, capacity and health beside the data — the table you query is the table you monitor.

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.

A fast, private, cross-platform desktop home that stays out of your way.

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 into a team workspace in your own account.

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 roles and membership managed in your own DynamoDB table plus an in-account audit trail, with enforced RBAC and SSO-scoped access on the governance roadmap.

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.
Pricing

Free to explore. Licensed to ship.

Free for non-commercial use — individuals, open source, education, and companies under $250K. Professional unlocks the full workspace for commercial use, and a one-year subscription ships free with every annual Core and All Access license; Business adds the team layer — shared workspaces and priority support — per developer, billed annually; Enterprise adds a flat governance layer for security review, procurement, a dedicated support contact and SLA terms.

Free

Community

$0 free, forever
Individuals · OSS · education · companies under $250K

Free for individuals, open source, education, and companies under $250K.

Download free
  • Browse tables, item editor and ⌘K command bar — any DynamoDB account, no .NET
  • 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
  • “Executes as” disclosure with cost and execution-plan preview
  • Read-only stages — writes refuse everywhere, not just in the UI
  • Saved credentials encrypted at rest — never stored in plaintext
  • Modelling — design from scratch, or infer a model from a live table’s items
  • Functions — save queries as functions (3 with reusable parameters) and run the access patterns generated from your model
  • Code generation — export queries to your stack

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

The full DynamoDB system studio for commercial work: model, query live and derived data planes, run native vector search, report, and operate across accounts. Buy one developer seat at a time.

Buy now
  • Everything in Community, licensed for commercial use
  • 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
  • Native vector indexes — create, drop and query top-k similarity with live metadata, readiness checks and byte-metered receipts
  • AI & agents — Ask DynoStudio, Agent mode and the MCP Gateway, on your own Bedrock access or a local model
  • OpenSearch & hybrid queries — full-text search plus bounded composition across DynamoDB, S3 Tables and OpenSearch
  • App lock — seal the studio behind biometric or passphrase unlock
  • Unlimited reusable parameterized queries and functions, plus saved reports
  • Custom reporting builder — fold query results into reusable reports, funnels, heatmaps and trends
  • S3 Tables analytics replicas — create, alter, monitor and query zero-ETL integrations with native-call, freshness and recurring-cost previews
  • Configurable query caps — tune the join, aggregate, subquery & set-op limits
  • A one-year subscription ships free with every annual Core and All Access license

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

Everything in Professional plus the team layer — shared workspaces, priority support and procurement — for $20 per developer a month, billed annually. No platform fee.

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
  • Procurement-friendly receipt and license record for finance
  • Shared team workspaces — models, saved queries and reports sync across the team through a one-click store in your own AWS account: versioned, encrypted under a customer-managed key, no Kanject data plane
  • Good fit when you need seats and support, not custom governance

From $720/year — $240 per developer per year from 3 developers, no platform fee. Need SSO, custom terms, an SLA or private deployment? Move to Enterprise.

For governed teams

Enterprise

Annual only From$12,000 / year · 25 developers
Governance · security review · SLA

Seats at the Business rate plus the governed layer: controls around rollout, security review, support commitments, procurement and scale.

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, roles and membership managed in your own DynamoDB table, and an in-account audit trail
  • Dedicated support contact with response-time SLA terms
  • Volume licensing
  • Signed annual agreement with custom terms and invoice billing
  • Security review support — no vendor data plane and nothing leaves your AWS account, so the questionnaire is short
  • Governance roadmap alignment: enforced RBAC, SSO-scoped workspace access, SAML and private deployment

Enterprise is for control, not a hidden per-seat premium. We scope developer count, environments, SLA, SSO/governance needs and deployment model 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.

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
Compare

Community, Professional, Business, and Enterprise, side by side.

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, roles and membership 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
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 — with 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 destructive verbs require re-authentication per environment. The prompt is live for Identity Center administration; enforcement for table writes ships with the elevation prompt — — — Configurable · roadmap
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 — — —
Compatibility

Every desktop. Natively.

DynoStudio is a true desktop app — the same studio, running native on macOS, Windows and Linux.

macOS

14 Sonoma or later

Architectures
Apple siliconIntel

Windows

10 & 11 · 22H2 or later

Architectures
x64ARM64

Linux

Ubuntu 22.04+ · Debian 12+ · Fedora 40+

Architectures
x64ARM64
FAQ

Questions, before you sign up.

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?

Ask DynoStudio sends schema and access patterns without table rows, and lets you inspect the exact request. Agent mode also uses design notes and runtime statistics; sampling rows needs a per-stage grant and your approval. The gateway keeps row access off until you grant it for a session. For Ask and Agent mode, a local model keeps prompts on your machine; Bedrock uses your AWS account and region. Connected MCP clients use their own model configuration. 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. Writes and DDL are refused. 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 governance/private-deployment scoping.

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.