DynoStudio by Kanject · Now available

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 against live tables, preview request and cost, build reports, and set up S3 Tables replicas when the answer should move off production. No hand-built pipeline. No 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)
Light + dark — every surface. Try the theme toggle.

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

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.

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

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

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 →

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.

One studio. Every DynamoDB question.

First-class PartiQL over live tables — with the native request and its cost shown before it runs. Plus modelling, monitoring, reporting, analytics replicas, import and export, all 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.

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 GSI run as disclosed control-plane calls, no console trip.

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, credentials never sync. One click on Business; Enterprise adds RBAC, SSO-scoped access and 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.

On the roadmap
  • Query the analytics replica from the console
  • Partial point-in-time restore

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 annual team packaging at the same per-seat rate; 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 — no .NET required.

Download free
  • Browse tables, item editor and ⌘K command bar — any DynamoDB account, no .NET
  • Typed PartiQL — reads, writes, upserts, 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
  • Starter modelling — sketch access patterns offline or inspect a live table
  • 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.

For growing teams

Business

Annual only From$3,000 / year · 5 developers
Teams · annual billing · priority support

Includes 5 developers at the Professional annual rate, plus one flat team platform fee for team defaults, priority support, and procurement.

Buy team plan
  • Everything in Professional, packaged for team use
  • Seats at the Professional rate — $200 per developer / year, no per-seat team premium
  • Flat $2,000 / year team platform fee — the team layer, one line on the invoice
  • One annual contract — add seats as the team grows
  • 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, no Kanject data plane
  • Good fit when you need seats and support, not custom governance

From $3,000/year — a $2,000 team platform fee plus $200 per developer (from 5), the same per-seat rate as Professional. 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

Seat parity 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 $7,000/year governance platform plus 25 seats at $200/developer/year
  • Additional seats stay $200/developer/year unless your annual agreement sets a volume commitment or discount
  • Governed shared workspaces — choose the store, upgraded with customer-managed encryption keys, a scoped IAM boundary, DynamoDB-backed RBAC, SSO-scoped access and an in-account audit trail
  • Per-command elevation — destructive writes re-prompt for auth, per environment
  • Governed analytics and managed-ops workflows as they ship
  • Dedicated support contact with response-time SLA terms
  • MSA, DPA, security review support and invoice billing
  • Volume licensing and rollout planning on a signed annual agreement
  • Governance roadmap alignment: RBAC, audit trail, SSO/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

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 packages the same seat economics for teams, and Enterprise adds governed rollout, procurement and SLA terms.

Community
Free
Professional
$20/mo · $200/yr
Business
From $3,000/yr · 5 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 Team commercial Governed agreement
Eligible users Individuals · OSS · education · under $250K 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 5+ active developers 25+ active developers · governed agreement
Advanced power
Advanced PartiQL Outer/cross joins, GROUP BY & aggregates, correlated/filter subqueries, set ops
Interactive transactions & dry-runs Preview the write set and native requests before a transaction runs
Saved queries & functions Community can keep simple saved work; Professional adds reusable parameters, generated functions and richer run paths Basic / literal Parameterized + generated Parameterized + generated
Custom reporting builder Fold one or more query results into reusable report templates, KPI blocks, tables and charts
S3 Tables analytics replicas Create, alter and monitor DynamoDB to Amazon S3 Tables zero-ETL integrations, with native AWS calls and recurring costs previewed before consent
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
Shared team workspaces Models, saved queries and reports sync across the team through a store in your own AWS account — versioned, encrypted, no Kanject data plane, and credentials never sync. Business sets it up in one click; Enterprise adds customer-managed keys, a scoped IAM boundary, RBAC 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
Query history retained Last 25 Unlimited Unlimited
Data export per run Up to 1,000 rows 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 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
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
“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
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 path for high-risk operations: require a fresh approval before destructive workspace writes Governed
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
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
Support & terms
Billing Business and Enterprise are annual because the value is team packaging, support and governance, not just the desktop binary Annual self-serve Annual agreement
Software updates Free updates While subscribed While subscribed
Support Docs + changelog Priority team support Dedicated contact + SLA
Procurement package Business gives finance a clean purchase record; Enterprise adds the legal/security packet procurement expects Receipt + license record MSA · DPA · 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

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

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.

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 — plus a health view for replica status, staleness and errors. Querying the replica from the query console is next on the roadmap, and the studio will never silently reroute a live-table query to it.

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, starter modelling, typed PartiQL (reads, writes, upserts via ON CONFLICT, 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 interactive transactions 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 ($20/dev/mo or $200/dev/yr): the full workspace with priority email support. Business is the same product capability for teams, priced so you never pay more per seat than Professional — seats stay at $200/developer/year (the Professional rate) plus a flat $2,000/year team platform fee for priority support and team collaboration, from $3,000/year for a team of 5. Enterprise keeps the same seat rate and makes the governance premium explicit: $7,000/year for the governed layer plus 25 seats at $200/developer/year, from $12,000/year. It adds procurement, security review support, a dedicated contact, SLA terms, per-command elevation 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 for a discount). Business starts at $3,000/year for 5 developers — a $2,000/year team platform fee plus $200 per developer — and scales per developer through checkout. Enterprise starts at $12,000/year on a signed annual agreement: a $7,000/year governance platform plus 25 seats at $200 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.