Tenalyser

Inspiration

We created Tenalyser after hearing real stories from renters in the UK who were blindsided by hidden clauses in their tenancy agreements, resulting in unexpected charges, and financial loss. What seemed like isolated cases turned out to be a widespread issue: according to research from Shelter UK, 1 in 4 renters reported facing surprise fees or terms they hadn’t noticed before signing.

This revealed a deeper problem, tenancy contracts are often complex and difficult to navigate, especially for first-time renters or those unfamiliar with legal jargon. We saw a clear opportunity to build a transparent, AI-powered tool that empowers renters with clear highlighted insights into what they’re agreeing to before it’s too late.

With Tenalyser, we aim to reduce legal disputes, increase trust, and give tenants peace of mind when making one of life’s most important decisions.

What it does

This service turns complex PDF tenancy agreements into easy-to-understand summaries. It starts by taking the PDF and extracting all the text inside. Then, it carefully prepares the text to work with advanced AI without losing any important details. The AI analyses the text to find and explain the main contract clauses and any possible risks. It turns the complicated legal language into simple and clear information. Finally, the service sends this summary back to users, so they can quickly and confidently understand their contracts. This solution saves time and makes legal analysis simple and accessible for everyone.

How we built it

We built a fast and serverless system using AWS to analyse tenancy agreements.

The user starts by uploading a PDF (tenancy agreement) through our web app, which is hosted on CloudFront for speed and global access. After a successful upload, the frontend asks our backend (via API Gateway and Lambda) for a secure upload link. This pre-signed URL is used by the web app to upload the file directly to S3 thereby keeping things fast, secure, and lightweight.

Once the file is stored on S3, a Lambda function is automatically triggered. This function extracts the text, splits it into smaller parts, and sends each one to a powerful AI model like OpenAI or Bedrock. The analysis happens in parallel to speed things up.

Each contract is summarised, checked for risks, and stored in DynamoDB. The frontend checks back using a simple API to get the final result once the analysis is ready.

We tied together S3, CloudFront, API Gateway, Lambda, DynamoDB, and AI models, all without managing any servers, making the system scalable, secure, and easy to use.

Challenges we ran into

Integrating a full stack of AWS services in just a short hackathon window was both exciting and challenging.

One of the first roadblocks we hit was CORS errors when trying to connect our CloudFront-hosted frontend with API Gateway. Although CORS is a common issue, dealing with it across CloudFront, S3, and API Gateway simultaneously added complexity. We resolved this by configuring CORS headers directly in the API Gateway UI and fine-tuning the CloudFront behaviour settings to pass through required headers correctly.

Another major challenge was securely uploading files from our frontend. For security and scalability, we didn’t want to allow the frontend to communicate directly with S3 using static credentials. This meant we couldn’t simply do a regular PUT or POST to S3. We solved this by implementing a Lambda-backed API that generates short-lived pre-signed URLs. These URLs allow secure, temporary, and direct file uploads to S3 without exposing any secrets—perfect for a serverless, stateless architecture.

We also had to manage the complexity of wiring together event-driven workflows. The Lambda had to be able to scale, handle large documents, and coordinate chunked AI processing—so we relied on Python’s asyncio and multithreading to keep processing efficient and parallel.

Finally, we faced challenges around coordinating the flow of status updates and results between asynchronous backend processing and a polling-based frontend. We addressed this by storing all contract state and metadata in DynamoDB, ensuring a single source of truth that could be accessed quickly and reliably from the frontend.

These obstacles forced us to deeply understand the nuances of AWS integrations, and ultimately helped us build a more secure, resilient, and high-performance system.

Accomplishments that we're proud of

We integrated multiple AWS services seamlessly into a fully serverless and event-driven architecture.

Designed a secure, scalable upload flow using pre-signed URLs without exposing our backend.

Successfully processed and analysed tenancy contracts using LLMs in parallel, making results fast and useful even for non-legal users.

Built a working end-to-end pipeline, from upload to analysis to result delivery, within the hackathon timeframe.

What we learned

How to connect S3, API Gateway, Lambda, DynamoDB, and CloudFront effectively to build production-ready pipelines.

The importance of optimizing for user experience even in a backend-heavy project, especially with secure file uploads.

How to tailor language model prompts to get structured, actionable insights from complex legal documents.

What's next for Tenalyser

Collaborate with tenant lawyers and legal professionals to review outputs and contribute expertise, ensuring the analyser is robust, reliable, and aligned with real-world legal standards.

Add support for more contract types like employment and lease agreements.

Build a feedback loop so users can flag incorrect analyses to improve future model responses.

Integrate notifications (email/SMS) when processing is complete.

Launch as a full SaaS tool with user accounts, history tracking, and multi-document support.

Explore fine-tuning and private LLMs for on-premises or enterprise use cases.

Built With

• amazon-web-services
• aws-cloudfront
• aws-dynamodb
• aws-gateway
• aws-lambda
• css
• html
• javascript