TresAI: A Serverless
Cloud App on AWS Amplify

A client has a stack of documents and wants them turned into something they can actually read: charts and tables, not raw files. They log in, upload the documents, press a single START button, and wait a moment. Behind that one button sits a set of AWS services, each doing exactly one job, and the whole point of the build was to make them work together without the client ever seeing the machinery.

TresAI is a cloud web application: a clean, minimalist React frontend, built on AWS Amplify, over a serverless AWS backend. A client signs in through AWS Cognito, uploads documents into their own space in Amazon S3, presses START to hand the work to backend Lambdas over an SQS queue, and once processing finishes sees the results, drawn from DynamoDB and S3, as charts and tables.

Put simply, it wires a simple React frontend directly into managed AWS services, so a small interface can run secure per-client uploads, on-demand processing and visual results without a heavy custom backend sitting in the middle.

The Starting Point: A Simple Front End Over a Serverless Backend

The interesting part of TresAI is the join. A minimalist frontend has to talk to several separate AWS services, each doing one job, and the asynchronous flow from upload to processed results has to feel clean and predictable. Getting that join right, without a bulky middle layer to build and maintain, was the work.

The development problems were specific:

• Wiring React to serverless AWS. The frontend has to connect to Cognito, S3, SQS and DynamoDB, each a separate service, without a heavy custom backend in between.
• Secure, per-client storage. Each client must upload to and see only their own files, so storage has to be scoped to the signed-in user.
• Starting processing on demand. A START button has to hand work to the backend Lambdas, rather than processing running on its own.
• Knowing when it is done. Processing is asynchronous and takes time, so the frontend has to know it has finished before trying to show results.
• Turning stored data into insight. The output lives in DynamoDB and S3, so it has to be fetched and rendered as charts and tables.
• Keeping it clean. All of this has to sit behind a modern, minimalist interface across four screens.

The Build: Amplify Ties the Services Together

The frontend is built on AWS Amplify, which is what ties the services together. Login is handled by AWS Cognito through Amplify, covering sign-in, email confirmation and forgotten passwords, and is GDPR compliant, so authentication is secure and standard without custom auth code. Uploads go into a user-specific location in Amazon S3, scoped to the signed-in Cognito identity, so each client uploads to and sees only their own documents. Standing up this kind of managed-service wiring cleanly is the core of the cloud app development behind TresAI.

From the client pressing START to the results appearing, the asynchronous flow runs in order:

1. The client signs in through Cognito and lands on a clean, minimalist interface.
2. They upload documents into their own space in S3, scoped to their Cognito identity.
3. They press START, which places a message on an SQS queue linked to the backend Lambdas.
4. The frontend waits on the completion signal from SQS, showing a clear processing state rather than partial data.
5. Once processing is done, it reads the results from DynamoDB and the files from S3 and renders them as charts and tables.

An account-management section sits alongside the four core screens, and the whole app is built in a modern, minimalist React style and deployed on Amplify hosting, so it stays clean, secure and able to scale.

Technical Architecture

The architecture is a React frontend on AWS Amplify over a serverless AWS backend: Cognito for authentication, S3 for uploads, SQS and Lambda for processing, and DynamoDB and S3 for results. It centres on secure per-client storage, starting and awaiting asynchronous processing, and rendering the output as visuals.

• Cognito login through Amplify. Authentication is handled by AWS Cognito via Amplify, covering sign-in, email confirmation and forgotten passwords, and is GDPR compliant, so login is secure and standard without custom auth code.
• Per-client S3 upload. Documents are dropped into a user-specific S3 location scoped to the signed-in Cognito identity, so each client uploads to and sees only their own space.
• Start processing over SQS. A START button places a message on an SQS queue linked to the backend Lambdas, so the client kicks off processing on demand rather than it running blindly.
• Waiting for completion. The frontend waits on the SQS completion signal before fetching results, showing a clear processing state and only loading data once it is ready.
• Results from DynamoDB and S3. Once processing is done, the app reads processed data from DynamoDB and files from S3 and renders them as charts and tables across the results and analytics screens.
• A clean, minimalist frontend. The four screens, login, upload and start, results, and analytics, plus an account section, are built in a modern, minimalist React style, so the app stays simple and focused.

Challenges Solved

Each problem was resolved by leaning on a managed AWS service rather than building custom infrastructure. Building on Amplify connected Cognito, S3, SQS and DynamoDB, so a React frontend talks to the serverless backend without a heavy middle layer. Scoping storage to the signed-in Cognito identity gave each client a private S3 space by design, not by a rule that could be forgotten. Routing both the START action and the completion signal through SQS gave one clear, decoupled mechanism for kicking off work and learning it had finished. Waiting on that signal before fetching from DynamoDB and S3 meant the app never showed partial or missing data.

Per-client isolation, on-demand processing and subscription-style accounts are the pattern behind most modern multi-tenant products, which is why this build maps naturally onto the needs of SaaS and startup products that give each customer a private, secure workspace over shared cloud infrastructure.

The Result

The outcome is a modern four-screen app, login, upload and start, results, and analytics, that connects securely to AWS, starts backend processing on demand, waits for it to finish, and presents the output as clean charts and tables. Each client’s uploads stay private to them, the interface stays minimal, and Amplify keeps the frontend cleanly wired into a serverless backend that scales without a custom middle layer to maintain.

The build lives or dies on getting the AWS wiring right, from Cognito and S3 to SQS, Lambda and DynamoDB. If you are planning something on that stack, you can hire AWS developers who have shipped exactly this Amplify-to-serverless pattern, or tell us about your app and we will map your uploads, processing and results onto the right AWS services.

Frequently Asked Questions

What is TresAI built on?

TresAI is a React frontend built on AWS Amplify over a serverless AWS backend. Amplify ties the frontend to Cognito for login, S3 for uploads, SQS and Lambda for processing, and DynamoDB and S3 for results, so a simple interface can talk to managed AWS services without a heavy custom backend.

How are each client’s files kept private?

Uploads go into a user-specific location in Amazon S3 that is scoped to the signed-in AWS Cognito identity. Each client uploads to and sees only their own space, so files are private to each user by design rather than by a rule that has to be enforced separately.

How does the app know when processing is finished?

Processing is asynchronous. Pressing START places a message on an SQS queue for the backend Lambdas, and the frontend then waits on the completion signal from SQS, showing a processing state. Only once that signal arrives does it fetch and display results, so it never shows partial data.

Why build on Amplify instead of a custom backend?

Amplify connects a React frontend to Cognito, S3, SQS and DynamoDB directly, so the app avoids building and maintaining a heavy middle layer. Authentication, storage, processing and results all run on managed AWS services, which keeps the build simpler, secure and easier to scale.

Can this upload, process and visualize pattern work for other apps?

Yes. The same shape, secure per-client uploads, on-demand processing kicked off over a queue, and results rendered as charts and tables once complete, suits many document-processing and analytics tools. The AWS services can be re-mapped to a different processing job while keeping the clean frontend and per-client isolation.