From Camera to Cloud: Building OmniEntry with AWS Rekognition, Lambda and Serverless Architecture
Building a hackathon project usually starts with an idea. For me, the challenge was turning that idea into something that actually worked end to end.
I wanted to build an employee entry system where authentication was based on a face rather than a physical card, while also recording where the verification happened. That idea became OmniEntry, a face-authentication and location-aware employee entry system.

I am an Information Technology student at MITS Gwalior, India, and while I had already worked with web development, this project pushed me to think beyond the frontend and understand how multiple cloud services could work together.
💡 Starting With a Simple Requirement
My initial requirement was simple:
Capture an employee's face → verify the identity → record the entry.
But I wanted the system to also capture the employee's location.
That turned the workflow into:

The interesting part was figuring out how to implement each step without building and maintaining a traditional backend infrastructure.
🏗️ Architecture
The final architecture looked like this:

Each AWS service had a specific responsibility.
Amazon Rekognition handled face verification.
AWS Lambda handled the backend logic.
Amazon API Gateway connected the frontend to Lambda.
Amazon S3 stored employee images used during registration.
Amazon DynamoDB stored employee information and entry logs.
Amazon Location Service converted latitude and longitude into human-readable location information.
AWS Amplify hosted the React frontend.
This was an important change in how I approached cloud development: instead of asking “How do I build the backend?”, I started asking “Which managed service should handle this requirement?”

👁️ Building Face Authentication
For authentication, I created an Amazon Rekognition Face Collection.
During employee registration, the employee image is indexed and associated with a Rekognition Face ID. I then store that Face ID along with the employee information in DynamoDB.
During verification:

This allowed me to use Rekognition's managed face-matching capabilities instead of building and training a computer-vision model myself.
One of the practical things I learned was that Rekognition and my employee database serve different purposes: Rekognition identifies the face, while DynamoDB connects that Face ID to my application's employee identity.
📍 Adding Location Verification
The next challenge was making the entry record location-aware.
The browser provides:
- Latitude
- Longitude
- Accuracy
I send these values along with the face-verification request.
Lambda then uses Amazon Location Service for reverse geocoding.
Instead of storing only:
26.xxxxxx, 78.xxxxxx
the system can store information such as:
City
Region
Country
Postal Code
Address
The entry record also contains the location accuracy and a Google Maps link.
This made the verification record much more useful than simply storing a timestamp.
⚠️ What Broke Along the Way
The hardest part wasn't getting one AWS service working.
It was getting multiple services to communicate correctly.
I ran into configuration issues around IAM permissions, API Gateway CORS, Lambda deployment, and Amazon Location Service permissions.
For example, the frontend could work correctly while the API request still failed because the API Gateway/Lambda configuration wasn't allowing the expected browser request.
That taught me an important lesson:
In a multi-service cloud application, integration is part of the implementation—not something to think about after the individual services work.
I also learned to test one connection at a time instead of trying to debug the entire architecture simultaneously.
🚀 From Localhost to a Live Application
Once the workflow worked locally, I deployed the frontend using AWS Amplify and connected it to the API Gateway endpoint.
That gave me a complete path:

Seeing the same application work outside my local machine was an important milestone for me.
📊 What I Built
The final application can:
- Capture an employee face
- Verify the employee using Amazon Rekognition
- Capture browser location
- Reverse-geocode the coordinates
- Record face similarity
- Store verification information in DynamoDB
- Display location accuracy
- Provide a map link for the recorded location
- Run through a serverless AWS backend
- Serve the frontend through AWS Amplify
The project currently uses on-demand DynamoDB capacity, which was appropriate for a hackathon-scale workload rather than provisioning fixed database capacity.
💰 Cost Was Also Part of the Learning
One thing I learned while working with AWS is that building with managed services also means understanding their pricing.
For a project like OmniEntry, usage depends heavily on the number of face-search requests, Lambda invocations, API requests, database operations, storage, and location requests.
Instead of assuming that “serverless means free,” I started paying attention to which operations generate usage and how AWS pricing maps to the architecture.
That is something I would consider much earlier in my next AWS project.
🧠 What I Took Away
OmniEntry started as a face-authentication idea, but it became a practical lesson in cloud architecture.
I learned how to connect:
React → API Gateway → Lambda → Rekognition → DynamoDB → Location Service
while also using S3 and Amplify as part of the overall system.
The biggest lesson wasn't learning seven AWS service names.
It was learning to break a real-world requirement into smaller problems and choose the appropriate managed service for each one.
🔭 What's Next?
The next version of OmniEntry could include authentication and role-based access, an admin dashboard, automated attendance reports, stronger anti-spoofing/liveness detection, and infrastructure-as-code deployment.
For another student starting with AWS, my biggest practical advice would be:
Don't try to learn every AWS service first. Start with one real problem, break it into components, and learn the services you need to solve each component.
That is how OmniEntry took me from a React application running locally to a complete cloud-based system.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article