AWS Builder Center
Building ReclaimX: Privacy-Preserving Ownership Verification with AWS Serverless Services

Building ReclaimX: Privacy-Preserving Ownership Verification with AWS Serverless Services

ReclaimX is a serverless lost-and-found platform built around a simple principle: a potential match is not proof of ownership. This article explains how AWS Lambda, API Gateway, DynamoDB, S3, Cognito, Amplify, and CDK work together to implement private ownership verification through the Proof Locker.

πŸ” Building ReclaimX: Privacy-Preserving Ownership Verification with AWS

Lost-and-found systems usually focus on one problem: finding an item that matches a lost-item description.
But there is another problem that is just as important:
How do we verify that the person claiming the item is actually the owner?
This was the problem I wanted to address while building ReclaimX, a privacy-preserving lost-and-found platform built with AWS.
The core idea behind ReclaimX is simple:
A match is not proof of ownership.
Instead of exposing every identifying detail of a found item, ReclaimX separates matching from ownership verification.
The recovery journey is:
LOST β†’ MATCHED β†’ VERIFIED β†’ RECLAIMED
The key part of this architecture is the πŸ”’ Proof Locker, where private ownership clues are stored and checked server-side.

🚨 The Problem with Traditional Matching

Imagine someone finds a black backpack on a university campus.
A normal lost-and-found system might publish:
Category: Backpack
Color: Black
Location: University Library
Description: Black canvas backpack
Someone could then claim that item simply because their description appears to match.
The problem is that publicly available information can also be used by someone who is not the actual owner.
This creates two separate questions:
  1. Does this lost item potentially match this found item?
  1. Can the claimant prove ownership?
ReclaimX treats these as separate steps.
The matching system identifies potential matches. The verification system determines whether the claimant can provide the correct private information.

πŸ” Introducing the Proof Locker

The Proof Locker is the central privacy feature of ReclaimX.
When a finder reports an item, they can provide additional ownership clues that should not be publicly visible.
For example:
Public Information
------------------
Black Backpack
Found near Library
Backpack category
Private Ownership Proof
-----------------------
Unique marking
Specific characteristic
Private identifying detail
The public information can be used for matching. The private information is stored separately and is only accessed by the backend verification logic.
The claimant does not receive the private proof. Instead, ReclaimX presents verification questions. The claimant submits their answers, and the backend compares those answers against the stored proof.
Only the verification result is returned.

☁️ AWS Architecture

I used AWS serverless services to build and deploy the backend infrastructure.
The architecture is:
ReclaimX uses a serverless AWS architecture. The React and TypeScript frontend is hosted and deployed through AWS Amplify. Amazon API Gateway provides the backend API entry point, while AWS Lambda handles the serverless application logic. Amazon DynamoDB stores application data, claims, and private Proof Locker information, while Amazon S3 stores item media and images. Amazon Cognito provides user authentication, and AWS CDK is used to define and deploy the infrastructure as code. Amazon CloudWatch is used for application logs and monitoring.
I also used AWS CDK with TypeScript to define and deploy the infrastructure as code.

πŸš€ AWS Amplify

I use AWS Amplify to host the ReclaimX frontend.
The frontend is built with:
  • βš›οΈ React
  • πŸ”· TypeScript
  • ⚑ Vite
Amplify provides the public deployment for the application and connects the deployed frontend to the AWS backend.
This allows the application to be accessed through a public URL instead of running only on a local development server.

πŸ” Amazon Cognito

ReclaimX uses Amazon Cognito for authentication.
Users need an authenticated account to interact with the application's protected functionality.
The authentication flow is separated from the application API so that the backend can identify authenticated users before processing protected requests.
This gives ReclaimX an identity layer without requiring me to build an authentication system from scratch.

🌐 Amazon API Gateway

Amazon API Gateway acts as the entry point for the backend API.
The frontend communicates with the backend through API endpoints rather than directly accessing the database.
The basic flow is:
React Frontend
β”‚
β–Ό
API Gateway
β”‚
β–Ό
AWS Lambda
This keeps the application architecture separated into frontend and backend responsibilities.

Ξ» AWS Lambda

AWS Lambda handles the serverless backend logic.
Lambda is particularly important for the Proof Locker because private ownership verification should happen on the server.
The verification flow looks like this:
Claimant
β”‚
β”‚ Submit answers
β–Ό
API Gateway
β”‚
β–Ό
AWS Lambda
β”‚
β”‚ Retrieve private proof
β–Ό
DynamoDB
β”‚
β”‚ Return private proof
β–Ό
AWS Lambda
β”‚
β”‚ Compare answers
β–Ό
Verification Result
β”‚
β–Ό
Claimant
The claimant receives the result of the verification rather than the private proof itself.
This is an important architectural distinction. The frontend should not need access to the private ownership clues just to perform verification.

πŸ—„οΈ Amazon DynamoDB

Amazon DynamoDB stores ReclaimX application data.
This includes information such as:
  • Item records
  • Claims
  • Recovery state
  • Verification information
  • Private Proof Locker data
The Proof Locker data is particularly important. The backend retrieves the private proof only when it needs to perform the verification operation.
The architecture therefore separates:
Public Item Information
β”‚
β–Ό
Matching
Private Ownership Proof
β”‚
β–Ό
Verification
This separation is one of the main design principles of ReclaimX.

πŸ“¦ Amazon S3

Item media is stored using Amazon S3.
For example, when a user reports an item, an associated image can be stored in the S3 bucket rather than being embedded directly inside the application database.
This gives the application a dedicated object-storage layer for item media.
The overall relationship is:
Item Metadata
β”‚
β–Ό
DynamoDB
Item Image
β”‚
β–Ό
Amazon S3

πŸ—οΈ AWS CDK

The AWS infrastructure is defined using AWS CDK with TypeScript.
Instead of manually creating every AWS resource through the console, the infrastructure can be represented as code.
The project infrastructure includes resources for:
  • API Gateway
  • Lambda
  • DynamoDB
  • S3
  • Cognito
  • Supporting AWS configuration
The CDK workflow allows the infrastructure to be synthesized and deployed consistently.
For example:
cd infra
npx cdk synth
and:
npx cdk deploy ReclaimXStack --require-approval never
This makes the infrastructure part of the project itself rather than a collection of manually configured resources.

πŸ”„ The Complete Recovery Flow

The different AWS services come together during the complete recovery journey.

1️⃣ Report

A user reports a lost or found item.
User
↓
ReclaimX
↓
API Gateway
↓
Lambda
↓
DynamoDB
Images are stored separately in S3.

2️⃣ Match

ReclaimX identifies potential matches between lost and found reports.
Lost Item
+
Found Item
↓
Matching
↓
Potential Match
At this point, the system has identified a possible relationship between two reports. It has not yet established ownership.

3️⃣ Verify

The claimant answers questions generated from the private ownership proof.
Claimant Answers
↓
API Gateway
↓
Lambda
↓
DynamoDB
↓
Private Proof
↓
Server-Side Comparison
↓
Verification Result
The private proof remains on the backend during this process.

4️⃣ Handover

After successful verification, ReclaimX moves the recovery process to the handover stage.
A temporary handover code is generated so that the physical transfer can be completed.
VERIFIED
↓
Handover Code
↓
Physical Handover
↓
RECLAIMED

πŸ›‘οΈ Why Server-Side Verification Matters

One of the most important decisions in ReclaimX was not simply hiding private proof in the user interface.
If private proof were sent to the browser and only hidden using frontend code, it would not really be private.
Instead, the architecture is:
Browser
β”‚
β”‚ Answers
β–Ό
API Gateway
β”‚
β–Ό
AWS Lambda
β”‚
β–Ό
DynamoDB
β”‚
β”‚ Private Proof
β–Ό
Server-Side Comparison
β”‚
β–Ό
Verification Result
The browser receives the information required for the interaction, but the private ownership proof stays on the backend.
This was the main architectural requirement behind the Proof Locker.

🧠 From Match to Ownership

The central concept of ReclaimX can be summarized as:
MATCHING
β”‚
β–Ό
Potential Match
β”‚
β–Ό
PRIVATE VERIFICATION
β”‚
β–Ό
Ownership Verified
β”‚
β–Ό
HANDOVER
β”‚
β–Ό
RECLAIMED
This distinction changes the role of a lost-and-found platform.
It is no longer only about finding similar descriptions. It becomes a workflow for connecting potential matches and verifying ownership before completing the recovery.

πŸ’‘ What I Learned

Building ReclaimX helped me understand how different AWS services can be combined into a serverless application without putting all application logic into a single backend server.
The most important architectural lesson was that privacy requirements should influence the data flow from the beginning.
For ReclaimX, this meant asking: what information does the claimant actually need?
The answer is not the private proof itself. The claimant only needs the verification questions and the resulting verification status.
That led naturally to a server-side verification architecture using API Gateway, Lambda, and DynamoDB.

βœ… Conclusion

ReclaimX combines a modern frontend with AWS serverless infrastructure to create a privacy-preserving lost-and-found workflow.
The architecture uses:
AWS Amplify
+
Amazon Cognito
+
API Gateway
+
AWS Lambda
+
Amazon DynamoDB
+
Amazon S3
+
AWS CDK
The result is a recovery flow built around a simple principle:
A match is not proof of ownership.
By keeping private ownership clues on the backend and performing verification server-side, ReclaimX separates item discovery from ownership verification.
Find it. Prove it. Reclaim it. πŸ”ŽπŸ”πŸ“¦

πŸ”— Project

ReclaimX
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article