Problem and approach
Students often find roles in several places, check whether they qualify, rewrite the same information, and then track applications in a spreadsheet. The workflow gets harder when postings are duplicated or application forms use different layouts.
OfferKite separates the process into two responsibilities. The discovery side finds and prioritizes openings. The application side prepares answers and fills forms after the student chooses where to apply. A tracker keeps the resulting pipeline in one place.
Aggregate internship listings, normalize inconsistent fields, remove duplicates, and filter by student preferences.
Reuse resume details and saved answers, generate contextual responses, and interact with supported applicant tracking systems.
Students shortlist roles, review materials, and take over when authentication, CAPTCHA, or an unfamiliar field needs a decision.
Keep application statuses, follow-up dates, and contact details together with manually submitted applications.
Design principle. Automate repeatable steps without taking application decisions away from the student.
End-to-end workflow
The product brief describes a workflow that starts with a student profile and ends with a recorded application. Discovery and application automation run as separate parts of the product.
This diagram summarizes the workflow described in the product brief. It is not a measured execution trace.
Students configure a profile with academic level, target roles, location, work authorization, term, and experience. The discovery interface produces a list of roles to review. For a shortlisted role, the application tool uses saved profile fields and documents to prepare an application in the employer's own form.
Job discovery and normalization
The discovery service reads community-maintained GitHub internship lists. The project brief names SimplifyJobs, SpeedyApply, and several regional or season-specific lists. These sources commonly describe openings as Markdown rows with company, title, location, application link, and status information.
Deduplication
OfferKite describes three checks for duplicate roles: exact application URL, a company/title/location match, and fuzzy text similarity when the first two checks are inconclusive. A rolling window helps identify reposted roles without keeping outdated duplicates indefinitely.
Recency and refresh
Posting age is estimated using repository commit timestamps and position in the source lists. The product brief describes a one-hour cache and scheduled refreshes, with older listings receiving lower ranking priority or moving to an archive. These are design parameters, not proof that every listing becomes available earlier than on other job boards.
Practical constraint. GitHub list updates are a useful signal, but commit time is not necessarily the employer's original posting time. Links, sponsorship tags, and job status also need ongoing validation.
Matching and ranking
Filtering handles requirements that users can state directly, such as location, work mode, and job category. Ranking adds a preference score so students can focus on roles likely to be a better match.
The published formula combines six normalized factors:
Bars are scaled to the largest weight. Percentages are configuration weights, not measured predictive accuracy.
Each component is described as a value between zero and one. The total can therefore be read as a weighted match score on the same scale. The brief also refers to display tiers such as strong, good, weak, and poor, which implies a conversion to a 0–100 presentation scale.
Rule-based scoring is easy to inspect and change. Its tradeoff is that fixed weights cannot capture every student's priorities. An employer's tier is also a preference signal, not an objective measure of internship quality.
Application automation
The application workflow is built around the user's browser session. This matters because employer applications often include file uploads, dynamic fields, single sign-on, or challenges that cannot be completed through a simple server request.
Creates sessions, reads profile data, proposes responses, and returns fill plans.
Chrome extension reads form fields and interacts with the active page.
Reusable loop for inspecting, classifying, filling, and checking fields.
The layers separate planning, browser interaction, and field-level control logic.
The agent loop
- Inspect. Read visible input labels, field types, required flags, and available options.
- Classify. Map fields to known data categories such as name, email, start date, authorization, and document uploads.
- Plan. Select a value from the student profile or saved Q&A bank. Ask an LLM to draft an answer when required.
- Fill and verify. Update the form and check whether required fields remain incomplete.
- Pause or submit. Hand control back for blockers or review, then submit only after the user's approval.
Supported form types and exceptions
The product brief identifies structured paths for Ashby, Lever, and Greenhouse. It describes Workday-specific handling as in progress and a vision-based fallback for more varied forms as planned. Neither should be presented as established coverage without testing against real application pages.
For CAPTCHA, SSO, and two-factor authentication, the extension is designed to pause and ask the user to complete the step. This is a better boundary than attempting to bypass a site's access controls.
Submission control. Generated answers and filled forms can be wrong even when the fields appear complete. The user should confirm application details before an irreversible submission.
System architecture
The product brief describes a Next.js application backed by API routes, a Chrome Manifest V3 extension, reusable form-filling logic, and server-side session handling. The browser and server play different roles: one has access to the active application page, while the other can coordinate planning and language-model requests.
A simplified view based on the project's published architecture. Network boundaries and deployment topology are not independently verified.
Session lifecycle
The web application creates a session with job and profile context. The extension opens the employer form, describes the fields it detects, and requests a fill strategy when needed. The extension then interacts with the page and reports progress or errors. The site describes temporary in-process session storage, which makes reconnecting after a server restart a known constraint.
Why separate the agent loop?
A standalone apply-core layer can be reused by the Chrome extension and by Playwright-based development tests. It also makes it easier to test classification rules and field handling without launching the full application each time.
Data persistence and privacy
OfferKite's brief takes a local-first approach for the student's search state. It distinguishes local resume and tracker data from the server records needed for accounts, billing, and temporary application sessions.
| Data | Where stored | Purpose |
|---|---|---|
| Preferences and onboarding | Browser localStorage | Local matching settings |
| Shortlist, tracker, answers, documents | Browser localStorage | Single-device job-search state |
| Account and session credentials | Server, Prisma + SQLite | Login and account access |
| Subscription and plan data | Server, with local mirror | Billing and feature access |
| Application sessions | Temporary server memory | Coordinate form-filling requests |
Local storage avoids syncing a student's full job-search record by default, but it also creates tradeoffs. Browser data can be lost when a device is replaced or storage is cleared. Sensitive resume details in localStorage also need protection against script injection and unauthorized local access.
There is an important distinction in the source material: the brief says resume files remain on-device, while its application-planning layer sends profile and form context to the server for assistance. The exact boundaries for transferred personal information and model-provider retention are not fully specified on the page. Those flows should be documented before making stronger privacy guarantees.
Subscriptions and access
The brief describes a free discovery tier, a paid ranking and tracking tier, and additional plans for application automation. Stripe webhooks manage subscription state, while server checks enforce plan access and available application credits. Plan prices and limits can change, so they are product configuration rather than an architectural requirement.
Technology stack
| Layer | Technology named in the brief |
|---|---|
| Web application | Next.js 15, React 19, TypeScript 5.7 |
| Interface | Tailwind CSS 3, PostCSS |
| Database | Prisma ORM, SQLite |
| Authentication | bcryptjs, hashed session cookies |
| Payments | Stripe Checkout, customer portal, webhooks |
| Language model | OpenAI API, GPT-4o listed as default |
| Browser automation | Chrome Manifest V3 extension, Playwright for testing |
| Extension tooling | esbuild, Chrome extension APIs |
The main technical decision is to keep form interaction in a real user browser while handling reusable planning and account logic outside the page. That division makes the product easier to adapt to new application systems, but it requires reliable communication between the web app, extension, and server.
Limits and next steps
The project site is a product brief, not a published benchmark. It describes the intended system and implementation structure but does not provide a repeatable evaluation dataset, recorded fill-success rate, confirmed application throughput, or measured time saved. Claims about finding jobs before major boards should be treated as product goals until they are tested using comparable posting timestamps.
Form layouts change. Track field-fill success, manual interventions, failed uploads, and submission confirmation for each platform.
Check that LLM-written responses match the student's actual experience and saved preferences. Avoid invented qualifications.
In-memory session state is temporary. Recoverable sessions need persistence, expiry rules, and careful handling of partial submissions.
Document what profile and resume text crosses the network, where it is stored, and when it is deleted.
Validate application links and compare source timestamps with employer posting times rather than assuming every list entry is new.
Keep an approval step for each submission, identify unknown answers, and make it easy to stop the agent or correct fields.
Roadmap in the product brief
The site lists Workday support, cross-device synchronization, durable application sessions, broader form coverage, and future integrations for email, interview preparation, and offer management. These should remain labeled as planned or in-progress until their availability is confirmed.
Recommended measurement plan. Test against a fixed sample of applications from each supported ATS. Record fields detected, fields filled correctly, user corrections, blockers, completed submissions, and elapsed time. Repeat after parser or model updates to catch regressions.
Conclusion
OfferKite combines internship discovery and application automation in a single student workflow. Its design addresses two different problems: deciding which jobs deserve attention and reducing the repetitive work involved in applying. The GitHub-list discovery pipeline and preference scoring support the first task. The Chrome extension, planning API, and reusable form-filling loop support the second.
The architecture gives the student control over shortlist decisions, authentication challenges, and final submission. The next engineering priority is to measure reliability across application systems and make data handling clear. That evidence will matter more than adding another feature before the core workflow is proven.