How to Integrate Lovable with Amazon DynamoDB

Never use root AWS credentials or overly broad IAM roles for your Lovable Edge Function. Create a dedicated IAM user with precisely the permissions your app needs. Log in to the AWS Console and navigate to IAM → Users → Create user. Name it something descriptive like lovable-dynamodb-user. On the permissions step, choose 'Attach policies directly' and click 'Create policy'. In the JSON editor, paste a policy that grants access only to your specific table. Use the table's ARN (Amazon Resource Name) which looks like: arn:aws:dynamodb:us-east-1:123456789012:table/MyTableName. The minimum permissions for a read-write integration are: dynamodb:GetItem, dynamodb:PutItem, dynamodb:UpdateItem, dynamodb:DeleteItem, dynamodb:Query, dynamodb:Scan on the table ARN, plus dynamodb:Query on any Global Secondary Index ARNs (format: arn:aws:dynamodb:region:account:table/MyTable/index/*) if your app uses GSIs. After creating the policy and attaching it to the user, go to the user's Security credentials tab and click 'Create access key'. Select 'Application running outside AWS' as the use case. Copy the Access Key ID and Secret Access Key — the secret is shown only once. Keep them ready for the next step.

In Lovable, click the '+' button next to the Preview panel to open the Cloud tab, then navigate to Secrets. Add these three secrets: - AWS_ACCESS_KEY_ID: the Access Key ID from the IAM user you just created - AWS_SECRET_ACCESS_KEY: the Secret Access Key for that IAM user - AWS_REGION: the AWS region where your DynamoDB table is located (e.g., us-east-1, eu-west-1, ap-southeast-1) The region must exactly match the region shown in your DynamoDB table's ARN. An incorrect region is a common cause of 'ResourceNotFoundException' errors when the Edge Function tries to access the table. Optionally, also add AWS_DYNAMODB_TABLE as a secret containing your primary table name. This makes it easy to switch between development and production tables by changing a single secret rather than redeploying Edge Function code. Never paste these credentials in the Lovable chat panel — Lovable's platform blocks approximately 1,200 hardcoded API keys daily, but free tier chat history is publicly visible.

Create the Edge Function that handles DynamoDB operations. The AWS SDK v3 for DynamoDB is importable in Deno using the npm: prefix, and the @aws-sdk/lib-dynamodb package's DynamoDBDocumentClient automatically handles DynamoDB's attribute value marshaling (converting between JavaScript types and DynamoDB's { S: 'string' }, { N: '123' } format). The Edge Function should initialize the DynamoDB client using credentials from environment variables, accept an operation type and table-specific parameters from the frontend, and return clean JSON responses. Supporting the four core operations covers most use cases: get (single item by key), put (create or replace item), query (items by partition key with optional sort key conditions), and scan (filter across all items — use sparingly). The most important DynamoDB concept in the code is the KeyConditionExpression for Query operations. A query always requires a partition key equality condition (pkField = :pkValue) and can optionally include a sort key range condition (skField BETWEEN :start AND :end). Use ExpressionAttributeNames for field names that are DynamoDB reserved words (like 'status', 'name', 'type') and ExpressionAttributeValues for the actual values.

1// supabase/functions/dynamodb-proxy/index.ts
2import { serve } from "https://deno.land/std@0.168.0/http/server.ts";
3import { DynamoDBClient } from "npm:@aws-sdk/client-dynamodb";
4import {
5  DynamoDBDocumentClient,
6  GetCommand,
7  PutCommand,
8  QueryCommand,
9  ScanCommand,
10  UpdateCommand,
11} from "npm:@aws-sdk/lib-dynamodb";
12
13const corsHeaders = {
14  "Access-Control-Allow-Origin": "*",
15  "Access-Control-Allow-Headers": "authorization, x-client-info, apikey, content-type",
16  "Access-Control-Allow-Methods": "POST, OPTIONS",
17};
18
19serve(async (req: Request) => {
20  if (req.method === "OPTIONS") {
21    return new Response("ok", { headers: corsHeaders });
22  }
23
24  try {
25    const client = new DynamoDBClient({
26      region: Deno.env.get("AWS_REGION"),
27      credentials: {
28        accessKeyId: Deno.env.get("AWS_ACCESS_KEY_ID") || "",
29        secretAccessKey: Deno.env.get("AWS_SECRET_ACCESS_KEY") || "",
30      },
31    });
32    const docClient = DynamoDBDocumentClient.from(client);
33
34    const { operation, tableName, key, item, partitionKey, sortKeyCondition, limit = 50 } = await req.json();
35
36    let result;
37
38    if (operation === "get") {
39      const response = await docClient.send(new GetCommand({ TableName: tableName, Key: key }));
40      result = { item: response.Item };
41    } else if (operation === "put") {
42      await docClient.send(new PutCommand({ TableName: tableName, Item: item }));
43      result = { success: true };
44    } else if (operation === "query" && partitionKey) {
45      const response = await docClient.send(new QueryCommand({
46        TableName: tableName,
47        KeyConditionExpression: "#pk = :pkVal",
48        ExpressionAttributeNames: { "#pk": partitionKey.keyName },
49        ExpressionAttributeValues: { ":pkVal": partitionKey.keyValue },
50        Limit: limit,
51      }));
52      result = { items: response.Items, count: response.Count };
53    } else if (operation === "scan") {
54      const response = await docClient.send(new ScanCommand({ TableName: tableName, Limit: limit }));
55      result = { items: response.Items, count: response.Count };
56    } else {
57      return new Response(
58        JSON.stringify({ error: `Unsupported operation: ${operation}` }),
59        { status: 400, headers: { ...corsHeaders, "Content-Type": "application/json" } }
60      );
61    }
62
63    return new Response(JSON.stringify(result), {
64      status: 200,
65      headers: { ...corsHeaders, "Content-Type": "application/json" },
66    });
67  } catch (error) {
68    return new Response(
69      JSON.stringify({ error: error.message }),
70      { status: 500, headers: { ...corsHeaders, "Content-Type": "application/json" } }
71    );
72  }
73});

With the Edge Function running, open the Lovable chat and describe the UI components you need. Tell Lovable your DynamoDB table structure — table name, partition key name and type, sort key name and type (if any), and the attribute names you want to display. Providing the access patterns upfront is important for DynamoDB: tell Lovable how users will filter the data. 'List all items by userId' is a Query operation (efficient). 'List all items where status is active' is a Scan with filter (slow on large tables, but acceptable for small tables or infrequent admin queries). If you need to filter on a non-key attribute frequently, mention that you may want a Global Secondary Index — Lovable can describe what GSI to create, though you'll need to create it in the AWS DynamoDB Console. When Lovable generates the React components, they call the dynamodb-proxy Edge Function with the operation and parameters. The loading state, error handling, and data display are generated automatically. For list views, tell Lovable to implement the lastEvaluatedKey-based DynamoDB pagination — DynamoDB does not support offset-based pagination, and Lovable needs to know this to generate correct 'Load more' functionality.

Test all CRUD operations in your Lovable app. Create a new item, verify it appears in the DynamoDB Console, update a field, and delete it. Check Cloud → Logs to see the Edge Function output for each operation. Verify the key design works for your access patterns. If queries are returning unexpected results, the most common cause is a mismatch between the partition key value in your query and the actual value stored in DynamoDB. DynamoDB key comparisons are case-sensitive and type-sensitive — the string '123' and the number 123 are different partition key values. Also test pagination. If your table has more than 50 items (the default limit in the Edge Function), the response includes a LastEvaluatedKey field. Your frontend needs to pass this back as the ExclusiveStartKey in the next request to get the next page. Ask Lovable to add 'Load more' pagination that uses this DynamoDB cursor pattern. For production deployments, review your IAM policy one more time. If any test revealed that the Edge Function needs additional permissions (like dynamodb:DescribeTable for table introspection), add only those specific permissions to the IAM policy rather than broadening to a managed policy like AmazonDynamoDBFullAccess.