Amazon DynamoDB

Log into the AWS Console and go to DynamoDB. Click 'Create table'. Choose a table name and, critically, your partition key — the primary attribute DynamoDB uses to distribute and locate items. For example, for a user orders table, the partition key might be `userId` (string). Optionally add a sort key for secondary ordering within a partition — `createdAt` (string in ISO 8601 format) lets you query a user's orders in chronological order. Choose 'On-demand' capacity mode for unpredictable traffic (pay per request), or 'Provisioned' if you know your throughput. On-demand is simpler for Bubble app development. Click 'Create table'. DynamoDB free tier includes 25GB storage and 25 WCU/RCU per month — verify current terms at aws.amazon.com. Next, create an IAM user for proxy credentials: IAM → Users → Create user. Attach an inline policy (or managed policy) granting only the operations your proxy needs: `dynamodb:Query`, `dynamodb:GetItem`, `dynamodb:PutItem`, `dynamodb:UpdateItem`, `dynamodb:DeleteItem` on your specific table ARN. Download the Access Key ID and Secret Access Key — you need these for the proxy environment variables.

1// Minimal IAM policy for DynamoDB proxy (least-privilege)
2{
3  "Version": "2012-10-17",
4  "Statement": [
5    {
6      "Effect": "Allow",
7      "Action": [
8        "dynamodb:Query",
9        "dynamodb:GetItem",
10        "dynamodb:PutItem",
11        "dynamodb:UpdateItem",
12        "dynamodb:DeleteItem"
13      ],
14      "Resource": [
15        "arn:aws:dynamodb:{region}:{account-id}:table/{table-name}",
16        "arn:aws:dynamodb:{region}:{account-id}:table/{table-name}/index/*"
17      ]
18    }
19  ]
20}

Create a new GitHub repository with `package.json` (declaring dependencies on `express` and `@aws-sdk/client-dynamodb` + `@aws-sdk/lib-dynamodb`) and `server.js`. The proxy validates an incoming `X-API-Key` header, then uses the AWS SDK's `DynamoDBDocumentClient` (which handles SigV4 signing and type conversion automatically) to execute DynamoDB operations. Expose three endpoints: `POST /query` (Query by partition key with optional sort key range), `POST /putItem` (insert or replace), `POST /updateItem` (update specific attributes). The Document Client auto-converts DynamoDB's `{"N":"42"}` number type format to plain JavaScript numbers — this is critical for Bubble. Create a Render Web Service, connect your GitHub repo, and set these environment variables: `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_REGION`, `TABLE_NAME`, `API_KEY` (a 32-character random secret you generate). Deploy and copy the Render HTTPS URL.

1// server.js — DynamoDB REST proxy for Bubble
2const express = require('express');
3const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
4const { DynamoDBDocumentClient, QueryCommand, PutCommand, UpdateCommand } = require('@aws-sdk/lib-dynamodb');
5
6const app = express();
7app.use(express.json());
8
9const ddb = DynamoDBDocumentClient.from(new DynamoDBClient({
10  region: process.env.AWS_REGION,
11  credentials: {
12    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
13    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
14  }
15}));
16
17const TABLE = process.env.TABLE_NAME;
18
19function auth(req, res, next) {
20  if (req.headers['x-api-key'] !== process.env.API_KEY) {
21    return res.status(401).json({ error: 'Unauthorized' });
22  }
23  next();
24}
25
26// Query items by partition key
27app.post('/query', auth, async (req, res) => {
28  const { partitionKey, partitionValue, limit = 25, lastKey } = req.body;
29  const params = {
30    TableName: TABLE,
31    KeyConditionExpression: '#pk = :pkval',
32    ExpressionAttributeNames: { '#pk': partitionKey },
33    ExpressionAttributeValues: { ':pkval': partitionValue },
34    Limit: limit,
35    ...(lastKey && { ExclusiveStartKey: JSON.parse(lastKey) })
36  };
37  const result = await ddb.send(new QueryCommand(params));
38  res.json({
39    items: result.Items || [],
40    lastKey: result.LastEvaluatedKey ? JSON.stringify(result.LastEvaluatedKey) : null
41  });
42});
43
44// Put (insert or replace) an item
45app.post('/putItem', auth, async (req, res) => {
46  const { item } = req.body;
47  await ddb.send(new PutCommand({ TableName: TABLE, Item: item }));
48  res.json({ success: true });
49});
50
51// Update specific attributes
52app.post('/updateItem', auth, async (req, res) => {
53  const { key, updates } = req.body;
54  const expressions = Object.keys(updates).map((k, i) => `#attr${i} = :val${i}`);
55  const names = {};
56  const vals = {};
57  Object.keys(updates).forEach((k, i) => {
58    names[`#attr${i}`] = k;
59    vals[`:val${i}`] = updates[k];
60  });
61  await ddb.send(new UpdateCommand({
62    TableName: TABLE,
63    Key: key,
64    UpdateExpression: `SET ${expressions.join(', ')}`,
65    ExpressionAttributeNames: names,
66    ExpressionAttributeValues: vals
67  }));
68  res.json({ success: true });
69});
70
71app.listen(process.env.PORT || 3000);

In your Bubble editor, go to the Plugins tab. If 'API Connector' by Bubble is not installed, click 'Add plugins', search 'API Connector', and install it. Click 'API Connector', then 'Add another API'. Name it 'DynamoDB Proxy'. In 'Root URL', paste your Render HTTPS URL (e.g., `https://your-dynamodb-proxy.onrender.com`). In 'Shared headers', click 'Add a shared header'. Key: `X-API-Key`. Value: the API key you set in the Render `API_KEY` environment variable. Check the 'Private' checkbox — this is mandatory. The Private checkbox ensures Bubble processes this header on its servers and never sends the API key value to any user's browser. Add a second shared header: Key `Content-Type`, Value `application/json` (leave not private). This is the only correct way to store the proxy API key in Bubble — do not place it in a query parameter or request body where it might appear in browser network logs.

1{
2  "root_url": "https://your-dynamodb-proxy.onrender.com",
3  "shared_headers": [
4    {
5      "key": "X-API-Key",
6      "value": "<your-proxy-api-key>",
7      "private": true
8    },
9    {
10      "key": "Content-Type",
11      "value": "application/json",
12      "private": false
13    }
14  ]
15}

Inside the 'DynamoDB Proxy' API group, click 'Add another call'. Name it 'QueryItems'. Set method to POST, endpoint to `/query`. In the body section, add four parameters: `partitionKey` (text — the name of your partition key attribute, e.g., `userId`), `partitionValue` (text — the value to query, e.g., a dynamic user ID), `limit` (number, default `25`), `lastKey` (text, default `null` for the first page). Click 'Initialize the call'. For initialization, Bubble needs a real successful response — provide a real partition key name and a real value that has items in your DynamoDB table. If your table is empty, insert a test item via the AWS Console first. The response comes back as `{"items":[...], "lastKey":null}`. In the 'Use as Data' dialog, configure Bubble to detect the `items` array as the data type list. Name the detected type something like 'DynamoOrder' or based on your table content. Each DynamoDB attribute becomes a field on this type. The `lastKey` field (a text string) is used for pagination — store it in a custom state for the 'Load More' button.

1// QueryItems — POST body
2{
3  "partitionKey": "userId",
4  "partitionValue": "{{userId}}",
5  "limit": 25,
6  "lastKey": "{{lastKey}}"
7}
8
9// Sample proxy response
10{
11  "items": [
12    {
13      "userId": "user_abc123",
14      "createdAt": "2026-03-15T10:30:00Z",
15      "orderId": "ord_xyz789",
16      "total": 149.99,
17      "status": "shipped"
18    }
19  ],
20  "lastKey": null
21}

Add a new call named 'PutItem'. Set method to POST, endpoint to `/putItem`. In the body, add one parameter: `item` (object — a representative JSON object matching the structure of a DynamoDB item, including the partition key and all attributes). Set 'Use as' to 'Action'. Initialize with a real test item — confirm it appears in your DynamoDB table via the AWS Console after initialization. Delete test items created during initialization if you do not want them in your production data. Add a second call named 'UpdateItem'. Set method to POST, endpoint to `/updateItem`. Body parameters: `key` (object — contains the partition key and sort key if applicable: `{"userId":"{{userId}}","createdAt":"{{createdAt}}"}`), and `updates` (object — the attributes to update: `{"status":"{{newStatus}}","updatedAt":"{{timestamp}}"}` ). Set 'Use as' to 'Action'. Initialize with a real test item's key and test update values. Note: every DynamoDB update requires the full primary key — partition key plus sort key if your table has one. Store both key attributes in Bubble custom states when a user selects an item to edit.

1// PutItem body — full item
2{
3  "item": {
4    "userId": "{{userId}}",
5    "createdAt": "{{createdAt}}",
6    "orderId": "{{orderId}}",
7    "total": "{{total}}",
8    "status": "pending"
9  }
10}
11
12// UpdateItem body — key + updates
13{
14  "key": {
15    "userId": "{{userId}}",
16    "createdAt": "{{createdAt}}"
17  },
18  "updates": {
19    "status": "{{newStatus}}",
20    "updatedAt": "{{now}}"
21  }
22}

Add a Repeating Group to your page. Set data source to 'Get data from external API' → QueryItems. Pass the user's ID (or relevant partition key value) as `partitionValue`, `25` as `limit`, and `null` as `lastKey` for the initial load. Access the 'DynamoOrder' fields on each Repeating Group cell. For pagination, add a 'Load More' button below the Repeating Group. Create a custom state `lastKey` (type: text, default: `null`). When the page loads, store the QueryItems response's `lastKey` field in the `lastKey` custom state (using a 'Set state' workflow action after the initial QueryItems call). The 'Load More' button triggers a new QueryItems call passing the stored `lastKey` as the body parameter. The proxy passes it to DynamoDB as `ExclusiveStartKey`. Append the new items to a Bubble 'custom data list' custom state (type: list of DynamoOrder) that your Repeating Group binds to. Disable the 'Load More' button when `lastKey` custom state is empty (no more pages). For the insert form: PutItem call with each form input mapped to the `item` body object fields. For updates: store the selected item's partition key (and sort key) in custom states when a user clicks edit, then pass them in UpdateItem's `key` parameter. Set up Privacy rules under Data tab → Privacy for any Bubble data types you create from DynamoDB responses.