Work across accounts
Use AWS SSO or profiles, keep dev/staging/prod separated as stages, and hold multiple table investigations open in tabs.
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.
Free for non-commercial use · See pricing →
CREATE TABLE "prod.Ledger" (
PARTITION KEY pk STRING,
SORT KEY sk STRING
) WITH BILLING = ON_DEMAND
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 specificationConnect 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.
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.;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 DynoStudioUse AWS SSO or profiles, keep dev/staging/prod separated as stages, and hold multiple table investigations open in tabs.
Read-only stages refuse writes across the editor, item browser, saved functions and transactions, instead of relying on UI hiding.
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.
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.
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.
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.
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.
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; } = "";
} (Products#{Id})(Info#{SellerId})(Orders#{Id})(Info#{CustomerId})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 →
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 →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.
PITR, table policies, S3 Tables bucket/catalog setup, Glue integration, Lake Formation grants and IAM role creation are listed before anything runs.
Replica status, staleness, errors and source/target wiring stay attached to the table and stage that created them.
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.
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.
Authenticate with AWS IAM Identity Center (SSO) or named profiles — many accounts and stages at once.
Keep several table investigations open in tabs and switch context without losing your place.
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.
Provision a zero-ETL DynamoDB → S3 Tables analytics replica and monitor its status, staleness and errors — heavy reporting moves off the live table.
A visual builder for entities, keys, GSIs and access patterns — design offline or learn a live table’s shape.
Import annotated C# POCOs and DynoStudio derives the model, keys and access-pattern functions. Optional, never required.
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.
Query live DynamoDB tables in SQL — key-aware JOINs, IN-subqueries, aggregates with GROUP BY, ON CONFLICT upserts, and atomic transactions.
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.
“Executes as” names the exact native request and what it will read before every run. Read-only stages refuse writes outright.
As you type, the editor marks a full-table Scan against a keyed Query and shows the item count it will read.
A searchable catalogue of every supported statement — pick one and it drops into the editor against the table in view.
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.
Read any result as a sortable grid or raw JSON — switch between them without re-running the query.
Turn results into funnel, heatmap and trend charts inline — no trip through a spreadsheet.
Assemble multi-statement results into a titled report — tables, charts and notes, with cost provenance.
Send any result set straight to CSV or JSON for the spreadsheet, the ticket, or the next tool.
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.
Operate on whole result sets at once — previewed first, then guarded per-item so nothing changes blind.
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.
A per-table CloudWatch dashboard opens on a verdict — healthy, watch, or problem — backed by throttles, capacity and latency over the window you choose.
Billed reads and writes for the range in view, priced into an estimate — so "is this table expensive?" gets a number, not a feeling.
One click reads the most-throttled partition keys via CloudWatch Contributor Insights — the billed call disclosed before it runs.
Rank every table in the region by requests or capacity to see who is actually busy — then jump straight into that table’s metrics.
Every page shows items read (billed) against items returned, so a filter that scans and discards never hides its waste.
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.
A native desktop app for macOS, Windows and Linux — not a browser tab.
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.
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.
Light, dark and custom editor themes — the studio flips with the rest of your desk.
A ⌘K command palette plus shortcuts for tables, stages, queries and actions — hands stay on the keys.
Next-page prefetch, instant cold-open, and queries lowered to read only what they must — no waiting on the tool.
One consolidated workspace, not a maze of panels — icon-first chrome that stays out of the way.
Shipping improvements on a steady cadence, with release notes every time — the studio you use keeps getting better.
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 for individuals, open source, education, and companies under $250K — no .NET required.
Download freeSelf-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.
The full DynamoDB system studio for commercial work: model, query, report, operate across accounts, and provision analytics replicas. Buy one developer seat at a time.
Buy nowAlready 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.)
Includes 5 developers at the Professional annual rate, plus one flat team platform fee for team defaults, priority support, and procurement.
Buy team planFrom $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.
Seat parity plus the governed layer: controls around rollout, security review, support commitments, procurement and scale.
Talk to salesEnterprise 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.
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.
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 | 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 | 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 | 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 | 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 | 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 | ||||
| “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 | 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 |
| 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 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 | — | — | — | |
DynoStudio is a true desktop app — the same studio, running native on macOS, Windows and Linux.
14 Sonoma or later
10 & 11 · 22H2 or later
Ubuntu 22.04+ · Debian 12+ · Fedora 40+
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.