AWS Builder Center

Weekend Annoying Task Challenge: Receipt2CSV

In this article, I share how I built Receipt2CSV, a simple serverless productivity application that automates receipt processing using AWS services, helping users quickly extract expense details and export them as CSV files while eliminating repetitive manual data entry. It was my first time using AWS services and they didn't let me down!

Computer Science Enthusiast | BCI | AWS Builder

Introduction

We've all been there—after shopping, grabbing lunch, or buying office supplies, we end up with a pile of receipts that need to be recorded for budgeting, reimbursements, or expense tracking. Although each receipt only takes a minute or two to type manually, repeating the same task multiple times every week quickly becomes tedious and time-consuming.
For this Weekend Challenge, I wanted to solve a small but common annoyance with a simple cloud application called Receipt2CSV.
Receipt2CSV is a lightweight web application that extracts important information from a receipt image and converts it into structured data in seconds. Instead of manually reading and typing details such as the store name, purchase date, tax, and total amount, users simply upload a photo of their receipt and let the application do the work. Once the information is extracted, it can be downloaded as a CSV file, making it easy to import into spreadsheets, accounting software, or personal finance trackers.
My goal for this project was not to build a large enterprise expense management system, but rather to demonstrate how a focused application powered by AWS services can automate a repetitive everyday task. I also wanted to keep the architecture simple, inexpensive, and deployable using AWS Free Tier services while still following modern serverless development practices.
Throughout this article, I'll walk through the motivation behind the project, the architecture I chose, the AWS services I used, the challenges I encountered during development, and the lessons I learned while building and deploying Receipt2CSV.

Vision & What the App Does

The idea behind Receipt2CSV came from a simple but repetitive task that many of us face: manually entering receipt information into spreadsheets. Whether it's for tracking personal expenses, submitting reimbursement claims, or organizing business purchases, the process is usually the same—read the receipt, type the details, and repeat.
While each receipt only takes a minute or two to process, those minutes add up over time. More importantly, manual data entry is prone to errors such as mistyped totals, incorrect dates, or missing tax values. I wanted to build a tool that could remove this repetitive work and make expense tracking much faster.
Receipt2CSV is designed with a single purpose: convert a receipt image into structured data with as little user effort as possible.
The workflow is intentionally simple:
  1. The user opens the web application.
  1. A receipt image is uploaded from their device.
  1. The image is securely sent to the backend through an API.
  1. The backend extracts the receipt text and identifies the most important fields:
  • Store Name
  • Purchase Date
  • Tax Amount
  • Total Amount
  1. The extracted information is displayed instantly on the page.
  1. The user can download the results as a CSV file for use in Microsoft Excel, Google Sheets, or any accounting software that supports CSV imports.
My primary objective was not to build a complete expense management platform, but rather to demonstrate how a focused automation tool can eliminate a small yet common annoyance using a modern serverless architecture. By concentrating on one problem and solving it well, the application remains lightweight, easy to understand, and inexpensive to run.
Another important design goal was simplicity. The frontend was intentionally built using plain HTML, CSS, and JavaScript without relying on large frameworks. This kept the application lightweight and allowed me to focus on the backend logic and AWS integration. On the backend, AWS Lambda handles the processing, while Amazon API Gateway exposes a secure endpoint that connects the frontend with the serverless function.
The result is a responsive web application that reduces manual effort, improves accuracy, and demonstrates how even a small cloud-based application can make an everyday task more efficient.
Figure 1: Receipt2CSV web interface showing a receipt upload, extracted fields (Store, Date, Tax, and Total), and the option to download the results as a CSV file.


How I Built It

I wanted to keep the application simple, lightweight, and easy to deploy while still demonstrating a practical use of AWS services. The frontend was built using HTML, CSS, and JavaScript, providing users with an interface to upload receipt images and view the extracted information.
When a user uploads a receipt, the image is converted to Base64 in the browser and sent through an HTTP POST request to Amazon API Gateway. API Gateway triggers an AWS Lambda function written in Python, which handles all backend processing.
My original plan was to use Amazon Textract because it is designed specifically for document and receipt processing. However, I had just created my AWS account during the challenge, and Textract was temporarily unavailable while my account registration was still being completed. Rather than stopping the project, I adapted the implementation by replacing only the OCR component with OCR.Space while keeping the overall architecture unchanged.
The Lambda function sends the image to the OCR service, receives the extracted text, and uses Python regular expressions to identify the store name, purchase date, tax amount, and total amount. These values are returned as a JSON response, displayed on the frontend, and can also be downloaded as a CSV file.
One of the biggest lessons from this challenge was the importance of modular design. Because the OCR logic was isolated inside the Lambda function, changing providers required only a small backend modification without affecting the frontend or API interface.

AWS Services Used / Architecture Overview

Receipt2CSV follows a simple serverless architecture that minimizes infrastructure while remaining scalable and easy to maintain.

AWS Services Used

  • AWS Amplify – Hosts the frontend web application.
  • Amazon API Gateway – Provides a REST API endpoint for the frontend.
  • AWS Lambda – Processes uploaded receipt images, communicates with the OCR service, extracts relevant information, and returns structured JSON.
The application flow is straightforward:
  1. The user uploads a receipt image.
  1. AWS Amplify serves the frontend.
  1. The frontend sends the image to Amazon API Gateway.
  1. API Gateway invokes an AWS Lambda function.
  1. Lambda sends the image to the OCR service.
  1. The OCR service returns the extracted text.
  1. Lambda parses the text using Python regular expressions.
  1. The extracted fields are returned as JSON.
  1. The frontend displays the results and allows the user to download them as a CSV file.
Architecture Diagram


What I Learned

This challenge reinforced how quickly useful applications can be built using serverless AWS services. I gained hands-on experience working with AWS Amplify, Amazon API Gateway, and AWS Lambda while building and deploying a complete web application.
One of the most valuable lessons was learning to adapt when technical challenges arise. Although my original design depended on Amazon Textract, service availability on my newly created AWS account required me to adjust the implementation. By designing the application with clear separation between components, I was able to replace only the OCR layer without changing the frontend or API design.
I also learned the importance of building focused applications. Rather than trying to solve every expense management problem, Receipt2CSV focuses on one repetitive task and performs it efficiently. This approach kept the project manageable within a weekend while still delivering a useful productivity tool.
Finally, this project strengthened my understanding of serverless architectures and demonstrated how AWS services can be combined to build practical applications with minimal operational overhead.

Live Demo

GitHub Repository

Source Code

Conclusion

Building Receipt2CSV for the AWS Weekend Challenge was an enjoyable opportunity to solve a real-world productivity problem using AWS serverless services. The project demonstrates that even a small application can eliminate repetitive manual work while remaining simple, scalable, and cost-effective.
By combining AWS Amplify, Amazon API Gateway, AWS Lambda, and an OCR service, I created an application that transforms receipt images into structured data in just a few seconds. Although I encountered unexpected challenges during development, adapting the architecture without changing the overall user experience reinforced the value of modular system design.
This challenge was a great learning experience, and there are several improvements I would like to explore in the future, including support for multiple receipt formats, improved field extraction accuracy, additional export options, and direct integration with expense management platforms.
Thank you for reading, and I hope this project inspires other builders to automate small everyday tasks using AWS services.
 The complete source code is available on GitHub, and the application is deployed on AWS Amplify for anyone to try. 
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