LifeOS: Connecting Your Information to the Real World with AWS
LifeOS is a Personal Action Intelligence platform that connects private documents with relevant real-world information. Built with AWS, it transforms scattered information into understandable insights, evidence-backed changes, and actionable next steps.
LifeOS: Connecting Your Information to the Real World with AWS
The Problem
Important information is everywhere.
A student might have a scholarship PDF in one folder, a college notice in WhatsApp, a resume on their laptop, a job description in their email, and a receipt somewhere in their downloads folder.
The problem isn't simply storing these files.
The problem is understanding what matters, finding connections between different pieces of information, checking whether something has changed, and knowing what to do next.
We built LifeOS to solve this problem.
LifeOS is a Personal Action Intelligence platform that connects a user's private information with relevant real-world information and turns that context into actionable intelligence.
Our core idea is:
Your World ↔ LifeOS Intelligence ↔ The Real World → Action
What LifeOS Does
LifeOS allows users to bring their personal information into one intelligent workspace.
Users can upload documents such as:
- Scholarship notices
- College documents
- Resumes
- Job descriptions
- Receipts
- Invoices
- Other personal PDFs and documents
LifeOS processes these documents, extracts useful information, and turns unstructured content into structured insights.
Instead of showing users raw OCR output, LifeOS aims to present:
- A clear summary
- Important facts
- Important dates
- Requirements
- Action items
- Warnings
- Evidence from the original document
The goal is simple:
Don't just store information. Understand it and act on it.
The Two Knowledge Worlds
One of the main ideas behind LifeOS is the separation between two knowledge worlds.
Private World
This contains information belonging to the user:
- Personal documents
- Resumes
- Receipts
- College notices
- Saved information
- Personal actions and reminders
Real World
This contains information outside the user's private data:
- Public information
- Current notices
- Official sources
- Public web information
- Updated information relevant to the user's documents
LifeOS connects these worlds instead of treating them as isolated databases.
For example, a user may have a scholarship notice stored in their documents.
LifeOS can extract the deadline and eligibility requirements from the document and then help the user compare that information with relevant current public information.
If conflicting information is discovered, LifeOS should surface the conflict and show the supporting evidence rather than silently choosing one source.
How We Built It
The application uses a serverless AWS architecture.
The main flow is:
User → CloudFront → Frontend → Cognito → API Gateway → Lambda → AWS services
For document processing:
S3 → Textract → Structured Extraction → AI Analysis → DynamoDB
The frontend is built as a modern web application.
AWS services are used for the core cloud infrastructure and processing pipeline.
AWS Services Used
Amazon S3
Amazon S3 is used for storing uploaded documents and frontend assets.
Documents are stored using user-scoped paths so that application logic can associate each document with the authenticated user.
Amazon Cognito
Amazon Cognito provides user authentication and identity management.
The application uses the authenticated Cognito identity to associate private data with the correct user rather than trusting a user ID supplied by the frontend.
Amazon API Gateway
API Gateway exposes the backend APIs used by the LifeOS frontend.
It provides the entry point between the authenticated web application and the serverless backend.
AWS Lambda
Lambda runs the backend logic without requiring us to manage servers.
It handles API operations, document-processing logic, data operations, and integrations with AWS services.
AWS Step Functions
Step Functions are used to orchestrate multi-step processing workflows.
This is particularly useful for document processing because extraction and AI analysis are separate stages rather than one large backend operation.
Amazon Textract
Textract is used to extract text and structured information from uploaded documents.
This became one of the most important parts of our document intelligence pipeline.
One lesson we learned was that Textract output is structured around blocks and extraction metadata, so we needed an additional normalization layer before presenting information to users.
The pipeline therefore became:
Document → Textract → Normalized Text → AI Analysis → Structured Insight
Amazon DynamoDB
DynamoDB stores application data such as document metadata, extracted information, analysis results, actions, workflows, and user-scoped application state.
Amazon CloudFront
CloudFront is used to securely deliver the frontend over HTTPS and provide a production-style deployment instead of directly exposing an S3 website endpoint.
Amazon EventBridge
EventBridge Scheduler can be used to trigger scheduled application events such as reminders.
Amazon SES
SES can be used for email notifications generated by scheduled LifeOS actions.
Amazon CloudWatch
CloudWatch provides monitoring and logging for the AWS backend and helps us debug the different stages of the application.
Document Intelligence Pipeline
One of the biggest technical challenges was making document processing reliable.
A PDF is a binary file.
Simply reading the PDF bytes as text produces output such as:
%PDF-1.7 followed by binary-looking data.
That is not document extraction.
We therefore designed the pipeline so that the original PDF remains a binary object in S3.
Textract processes the document and returns structured extraction results.
Those results are then normalized into readable text.
The normalized text is passed to the AI analysis layer.
The final result is stored as structured application data.
The user sees the final information rather than raw PDF bytes or raw extraction metadata.
From Documents to Actions
LifeOS is not intended to stop at summarization.
The final goal is action.
For example, if a document contains an important deadline, the system can turn that information into an action or reminder.
The user can move through the lifecycle:
Understand → Verify → Act → Remember
This is what makes LifeOS different from a simple document storage application.
What Changed?
Another important feature is document comparison.
Information changes.
A deadline can move.
A requirement can be added.
A policy can be updated.
Instead of asking users to manually compare two documents, LifeOS can compare structured document information and identify meaningful differences.
For example:
Application deadline
30 September
→
4 October
The system can then show the evidence associated with the change.
This approach is more useful than simply comparing raw PDF text because the comparison focuses on meaningful information.
Security and Privacy
Because LifeOS works with personal documents, security is a fundamental part of the architecture.
The application uses authenticated users through Amazon Cognito.
Private resources are associated with the authenticated user's Cognito identity.
The backend performs authorization checks before returning private documents or application data.
The frontend does not receive AWS secret credentials.
AWS service operations are performed through the appropriate backend AWS permissions.
The production frontend is also being moved from the S3 website endpoint to HTTPS delivery through CloudFront.
Our goal is to make security part of the architecture rather than something added after the application is finished.
What We Learned
Building LifeOS taught us that connecting AWS services is only one part of building a reliable cloud application.
We learned that each service has its own data model and operational behavior.
With Textract, we learned that OCR output needs to be normalized before it becomes useful to an end user.
With Cognito, we learned that authentication is different from authorization and that the backend must enforce ownership of private resources.
With S3 and CloudFront, we learned the difference between simply hosting a website and deploying it securely for real users.
With Step Functions, we learned how complex processing can be represented as an explicit workflow instead of being hidden inside one large function.
Most importantly, we learned that a working end-to-end flow is more valuable than having many partially implemented features.
Challenges We Faced
One of our biggest challenges was making document processing work correctly.
During development, we encountered a situation where the original PDF binary was being displayed as if it were extracted text.
The output started with:
%PDF-1.7 This helped us identify an important architectural mistake: the original binary document must never be treated as extracted text.
We separated the original document, Textract extraction, normalized text, and AI analysis into distinct stages.
This made the pipeline easier to debug and gave us a much cleaner foundation for future features.
We also had to understand how authentication, user identity, API authorization, storage, and AI processing fit together into one system.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article