CarryForward

Home Page
Initial
Step 1
Step 2
Step 3
Step 4
Working Principle
Summery

Small document mismatches can create big problems later. CarryForward helps applicants find those problems before they submit.

Inspiration

In many developing countries, people from rural areas often submit documents online without knowing that small issues, such as a name mismatch, can cause serious problems later. For example, a student may have one spelling of their name on an ID card and a slightly different spelling on a transcript. These mistakes can lead to delays, rejection, wasted money, and a lot of stress.

CarryForward was inspired by this practical problem. Our goal is to help users check their documents before submission, so they have a chance to find and fix an issue instead of learning about it after a rejection or delay.

We live in Pakistan, where these paperwork problems are common. Our team researched around 50 project ideas, selected the best three, and then chose CarryForward because we believed it was the most practical and meaningful idea for the people around us.

What it does

First, CarryForward asks the user what the application requires, such as a legal name, date of birth, or official academic transcript. The user then uploads the documents they want to check.

CarryForward reads the uploaded files and extracts visible information related to the selected requirements. It then shows whether each requirement is:

Matched
Conflict
Missing
Unclear

For example, if one document contains the name Ayesha Khan and another contains Aisha Khan, CarryForward shows both values and where they were found. It does not decide which name is correct. Instead, it warns the user about the conflict and suggests checking it before submitting the application.

The result also gives the user a practical next step, a Plan B, and an editable email that can be sent to the university or other institution.

CarryForward is only a readiness-checking tool. It does not verify whether a document is authentic, and it does not make an admissions or eligibility decision.

How it works

The user enters the university, scholarship, or application they are preparing for.
The user selects what the documents need to prove.
The user uploads PDF, PNG, or JPEG files.
CarryForward validates the files and temporarily stores accepted files privately.
After the user gives consent, Gemini 2.5 Flash extracts visible, source-linked facts from the documents.
Rule-based logic compares those facts and shows the readiness result.

We separated AI extraction from the final comparison. Gemini reads the visible facts, while deterministic TypeScript rules decide whether the evidence is matched, conflicting, missing, or unclear. This makes the result more consistent and easier for the user to review.

How we built it

CarryForward was created through our team's collaboration, step-by-step engineering, and AI support. We planned, designed, debugged, tested, and built the project using Codex with GPT-5.6.

We built a web application for selecting requirements and uploading documents, backend API routes for processing them, and a live connection to the Gemini 2.5 Flash API for extracting important information from the uploaded files.

The frontend was built with React, Vinext, and TypeScript. The backend runs through Cloudflare Workers. We use private R2 storage for temporary files and Zod to validate structured data before it reaches our comparison rules.

After Gemini extracts the visible facts, CarryForward applies rule-based logic to compare them with the user's selected requirements. This is how the app produces the matched, conflict, missing, or unclear result.

We also added validation and exception handling for common problems, including unsupported file types, misleading file extensions, large files, duplicate files, missing consent, invalid API configuration, failed extraction requests, incomplete documents, and unclear content.

How we used Codex and GPT-5.6

We used Codex and GPT-5.6 during almost every development phase. It helped us compare project ideas, make the roadmap, plan the architecture, write and improve the frontend and backend, debug errors, create tests, handle exceptional cases, improve security, and prepare the project for deployment.

We also learned when to use deeper reasoning for difficult architecture and debugging problems and when a faster model response was enough for a smaller task. This helped us save time and avoid unnecessary token use.

GPT-5.6 helped us build and test the project, but it is not the model that reads documents in the live application. Gemini 2.5 Flash performs the document extraction at runtime.

Challenges we ran into

The most difficult part was turning the project into a working web application instead of keeping it as a demo. At first, some results were hardcoded so we could test the idea and interface. We later had to redesign the complete workflow so the upload, validation, storage, extraction, and analysis would all work dynamically through backend API routes.

Another challenge was choosing the correct AI model for the correct job. We had to understand when stronger reasoning was useful and when speed was more important. We also needed to think about token use and avoid using an expensive approach for every small task.

API configuration was also challenging. We worked through environment variables, local development setup, credentials, quota limitations, model access, and the switch to Gemini 2.5 Flash for the live extraction system.

Real uploaded documents can also be incomplete, unclear, mismatched, unsupported, duplicated, or too large. Network requests and extraction services can fail too. We spent a lot of time testing these cases and making sure the user receives a useful error instead of nothing happening.

Accomplishments that we're proud of

We are proud that CarryForward is not only an idea. It is a working project that could practically be integrated into a real application system.

As second-semester students, we built this AI-based document-readiness tool from scratch. We started with a simple prototype and changed it into a dynamic application that accepts user-selected requirements and files, sends them through a real backend, and produces evidence-linked results.

We are also proud that we worked on a problem that is common in Pakistan and other developing countries. Small paperwork errors can waste a person's time, money, and energy. CarryForward may look like a simple checker, but finding a mismatch before submission could save someone from a major problem later.

Our team gave its time, effort, and resources to build the project together, and seeing the final workflow work clearly was a major achievement for us.

What we learned

We learned the importance of building a real system and not only a visual demo. Through this project, we learned about frontend uploads, backend API routes, file validation, private temporary storage, AI extraction, and how all these parts communicate in a working web application.

We learned about prompt engineering, model selection, and cost awareness. We had to think about when a more powerful reasoning model was needed, when a faster response was enough, and how to reduce unnecessary token use.

We also learned that AI should not be trusted to make every decision by itself. In CarryForward, AI extracts the visible information, deterministic rules compare it, and the user reviews the result. This combination is more careful and practical for important documents.

Teamwork and problem research were equally important. We brainstormed many ideas, narrowed them down to one local problem, divided the work, solved issues together, and completed the project within a limited time. It was challenging, but it was also exciting and fun for our team.

What's next for CarryForward

CarryForward currently focuses on English documents. Our next step is to test and improve it for more languages, including Urdu, Hindi, Persian, and other regional languages. We also want to improve its understanding of different English document styles.

We plan to support more document formats and types because applicants may upload ID records, certificates, transcripts, test reports, letters, and many other documents.

In the future, CarryForward could be integrated with universities, scholarship platforms, and online application portals. This would allow applicants to check their documents before final submission and could reduce delays caused by missing or mismatched information.

We would also like to improve mobile accessibility and performance on slower internet connections so the project can better serve the communities that inspired it.