Amazon DynamoDB

Open the AWS Management Console and navigate to DynamoDB. Click Create Table. Choose a table name that reflects your data (e.g., Orders, Inventory, CartItems). The most critical decision is the Partition Key: this is the primary dimension for all queries. Choose a partition key that aligns with your app's most common lookup — for a cart, use userId; for orders, use orderId; for inventory, use productCategory. Optionally add a Sort Key for range queries within a partition (e.g., createdAt for orders under the same userId). Select On Demand capacity mode if traffic is unpredictable; Provisioned mode if you have stable, predictable load and want to stay within the free tier's 25 WCU/25 RCU allocation. Click Create Table. Next, go to IAM in the AWS Console. Click Policies → Create Policy. In the JSON editor, write a policy that grants only the DynamoDB actions your app actually needs on your specific table — use the code block below as a template. Avoid granting dynamodb:Scan (it is expensive and slow on large tables), dynamodb:DeleteTable, or any iam: permissions. Create the policy, then create an IAM User named dynamodb-proxy-user, attach the policy, and generate an Access Key. Store the Access Key ID and Secret Access Key in your Firebase environment config — never in code.

1{
2  "Version": "2012-10-17",
3  "Statement": [
4    {
5      "Sid": "FlutterFlowDynamoDBAccess",
6      "Effect": "Allow",
7      "Action": [
8        "dynamodb:Query",
9        "dynamodb:GetItem",
10        "dynamodb:PutItem",
11        "dynamodb:UpdateItem"
12      ],
13      "Resource": [
14        "arn:aws:dynamodb:us-east-1:YOUR-ACCOUNT-ID:table/YOUR-TABLE-NAME",
15        "arn:aws:dynamodb:us-east-1:YOUR-ACCOUNT-ID:table/YOUR-TABLE-NAME/index/*"
16      ]
17    }
18  ]
19}

The Cloud Function is the core of this integration — it is the only component that holds AWS credentials and talks directly to DynamoDB. Create a new Firebase Cloud Function named dynamodbProxy. The function uses the AWS SDK for Node.js (aws-sdk package, available in the Cloud Functions runtime) to create a DynamoDB Document Client, which simplifies working with JavaScript objects instead of DynamoDB's typed attribute format. Implement at minimum two exported functions: queryItems (for fetching a list of items by partition key, using DynamoDB.Query) and getItem (for fetching a single item by primary key, using DynamoDB.GetItem). Add a third putItem function for writes. Each function first validates Firebase Auth to ensure only authenticated app users can query your data. It then reads the request parameters from the callable data object, constructs the DynamoDB parameters (TableName, KeyConditionExpression, ExpressionAttributeValues), calls the AWS SDK, and returns the Items array to FlutterFlow. For pagination, pass through the LastEvaluatedKey if present so FlutterFlow can request the next page. Set AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION, and DYNAMODB_TABLE_NAME as Firebase environment variables before deploying.

1// Firebase Cloud Function: index.js
2const functions = require('firebase-functions');
3const AWS = require('aws-sdk');
4
5const dynamodb = new AWS.DynamoDB.DocumentClient({
6  region: process.env.AWS_REGION,
7  accessKeyId: process.env.AWS_ACCESS_KEY_ID,
8  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
9});
10
11const TABLE = process.env.DYNAMODB_TABLE_NAME;
12
13// Query items by partition key
14exports.queryItems = functions.https.onCall(async (data, context) => {
15  if (!context.auth) {
16    throw new functions.https.HttpsError('unauthenticated', 'Login required');
17  }
18
19  const { partitionKey, partitionValue, limit = 20, lastEvaluatedKey } = data;
20
21  const params = {
22    TableName: TABLE,
23    KeyConditionExpression: '#pk = :pkVal',
24    ExpressionAttributeNames: { '#pk': partitionKey },
25    ExpressionAttributeValues: { ':pkVal': partitionValue },
26    Limit: limit,
27    ExclusiveStartKey: lastEvaluatedKey || undefined,
28  };
29
30  const result = await dynamodb.query(params).promise();
31  return {
32    items: result.Items,
33    lastEvaluatedKey: result.LastEvaluatedKey || null,
34    count: result.Count,
35  };
36});
37
38// Get a single item by primary key
39exports.getItem = functions.https.onCall(async (data, context) => {
40  if (!context.auth) {
41    throw new functions.https.HttpsError('unauthenticated', 'Login required');
42  }
43
44  const { key } = data; // e.g. { userId: 'abc123', orderId: '456' }
45  const result = await dynamodb.get({ TableName: TABLE, Key: key }).promise();
46  return result.Item || null;
47});
48
49// Write a new item or overwrite existing
50exports.putItem = functions.https.onCall(async (data, context) => {
51  if (!context.auth) {
52    throw new functions.https.HttpsError('unauthenticated', 'Login required');
53  }
54
55  const { item } = data;
56  await dynamodb.put({ TableName: TABLE, Item: item }).promise();
57  return { success: true };
58});

In FlutterFlow, click API Calls in the left navigation panel. Click + Add → Create API Group. Name the group DynamoDBProxy. Set the Base URL to your Firebase Cloud Function's HTTPS trigger base URL — this is the URL up to and including the region and project path, but not the specific function name (or use the full callable URL pattern). For Firebase callable functions, the URL format is https://us-central1-YOUR-PROJECT-ID.cloudfunctions.net/functionName. Add a header Authorization and set its value to Bearer {{idToken}} — reference an App State variable ebayIdToken (or use FlutterFlow's built-in Firebase Auth current user's ID token). Now create three API Calls inside this group: one for QueryItems (POST to the queryItems function URL, body contains partitionKey, partitionValue, limit, and lastEvaluatedKey), one for GetItem (POST to the getItem function URL, body contains the key object), and one for PutItem (POST to the putItem function URL, body contains the item object). In the Response & Test tab for QueryItems, add a sample response and click Generate JSON Paths to map $.items[*] fields to FlutterFlow data model fields. Your exact JSON paths depend on your DynamoDB table's attribute names — for an orders table you might map $.items[*].orderId, $.items[*].status, $.items[*].total, $.items[*].createdAt.

1// API Group: DynamoDBProxy
2// Configuration reference
3{
4  "group_name": "DynamoDBProxy",
5  "base_url": "https://us-central1-YOUR-PROJECT-ID.cloudfunctions.net",
6  "headers": [
7    {
8      "key": "Content-Type",
9      "value": "application/json"
10    }
11  ],
12  "api_calls": [
13    {
14      "name": "QueryItems",
15      "method": "POST",
16      "path": "/queryItems",
17      "body": {
18        "data": {
19          "partitionKey": "{{partitionKeyName}}",
20          "partitionValue": "{{partitionKeyValue}}",
21          "limit": "{{limit}}",
22          "lastEvaluatedKey": "{{lastEvaluatedKey}}"
23        }
24      }
25    },
26    {
27      "name": "GetItem",
28      "method": "POST",
29      "path": "/getItem",
30      "body": {
31        "data": {
32          "key": "{{primaryKey}}"
33        }
34      }
35    },
36    {
37      "name": "PutItem",
38      "method": "POST",
39      "path": "/putItem",
40      "body": {
41        "data": {
42          "item": "{{itemData}}"
43        }
44      }
45    }
46  ]
47}

In your FlutterFlow canvas, navigate to the page where you want to display DynamoDB data. Add a ListView widget. In the Backend Query settings for the ListView, select API Call, choose the DynamoDBProxy group, and select QueryItems. Set the partitionKeyName to match your table's partition key attribute name (e.g., 'userId') and set partitionKeyValue to the current user's Firebase Auth UID using FFAppState().currentUser.uid or the authenticated user's ID from FlutterFlow's Firebase Auth integration. Set limit to 20. Add the data model fields inside the ListView template widget and bind each Text or Image widget to the corresponding JSON path field. DynamoDB paginates via LastEvaluatedKey rather than page numbers. To implement Load More pagination: create a page variable lastKey (type JSON) initialized to null. After a successful QueryItems call, check if the response contains a non-null lastEvaluatedKey field. If it does, store it in the lastKey page variable and show a Load More button. When the user taps Load More, call QueryItems again, passing the lastKey as the lastEvaluatedKey parameter. Append the new items to your list rather than replacing it. When lastEvaluatedKey comes back null from DynamoDB, hide the Load More button.

1// DynamoDB pagination pseudocode for Action Flow Editor
2
3// Initial load (On Page Load action)
4// 1. Call QueryItems
5//    partitionKeyName: 'userId'
6//    partitionKeyValue: FFAppState().currentUserId
7//    limit: 20
8//    lastEvaluatedKey: null
9// 2. Store response.items → pageVariable.itemList
10// 3. Store response.lastEvaluatedKey → pageVariable.lastKey
11// 4. IF pageVariable.lastKey != null THEN show Load More button
12
13// Load More button action
14// 1. Call QueryItems
15//    lastEvaluatedKey: pageVariable.lastKey (JSON object from previous response)
16// 2. APPEND response.items to pageVariable.itemList
17// 3. UPDATE pageVariable.lastKey = response.lastEvaluatedKey
18// 4. IF pageVariable.lastKey == null THEN hide Load More button
19
20// Example JSON paths for orders table
21// $.result.items[*].orderId      → orderId
22// $.result.items[*].status       → orderStatus
23// $.result.items[*].total        → total
24// $.result.items[*].createdAt    → createdAt
25// $.result.lastEvaluatedKey      → lastEvaluatedKey (pass back for next page)

Writing items to DynamoDB from FlutterFlow follows the same pattern as reads. In the Action Flow Editor on your data-entry screen, wire the Save button to call the PutItem API Call, constructing the item JSON object from the screen's form fields. PutItem overwrites an existing item if the primary key matches, or creates a new one if the key is new — there is no separate 'create' vs 'update' for DynamoDB PutItem. If you need conditional writes (e.g., only create if the item does not already exist), implement a ConditionExpression in your Cloud Function (attribute_not_exists(partitionKey)) and handle the ConditionalCheckFailedException in the function by returning a meaningful error response that FlutterFlow can check. For throttling: if your table uses Provisioned capacity and traffic exceeds your WCU/RCU allocation, DynamoDB returns a ProvisionedThroughputExceededException, which surfaces as a 400 error from your proxy. Handle this in FlutterFlow by checking the response status code and showing a 'Server busy, please try again' message, then retrying after a short wait. On-demand capacity mode never throttles but costs more per request.

1// Conditional PutItem in Cloud Function (prevent duplicate keys)
2exports.putItemSafe = functions.https.onCall(async (data, context) => {
3  if (!context.auth) {
4    throw new functions.https.HttpsError('unauthenticated', 'Login required');
5  }
6
7  const { item, allowOverwrite = true } = data;
8  const params = {
9    TableName: TABLE,
10    Item: item,
11  };
12
13  // Prevent overwriting existing items if allowOverwrite is false
14  if (!allowOverwrite) {
15    params.ConditionExpression = 'attribute_not_exists(#pk)';
16    params.ExpressionAttributeNames = { '#pk': Object.keys(item)[0] };
17  }
18
19  try {
20    await dynamodb.put(params).promise();
21    return { success: true };
22  } catch (error) {
23    if (error.code === 'ConditionalCheckFailedException') {
24      throw new functions.https.HttpsError('already-exists', 'Item already exists');
25    }
26    if (error.code === 'ProvisionedThroughputExceededException') {
27      throw new functions.https.HttpsError('resource-exhausted', 'Database busy, retry');
28    }
29    throw new functions.https.HttpsError('internal', error.message);
30  }
31});