OfferKite / technical project paper
OKProduct engineering / AI agents
Technical project paper

OfferKite.

An internship search and application platform that combines job discovery, role matching, browser automation, and application tracking.

ProductOfferKite
FocusJob discovery + agent workflows

Abstract

Internship searches involve two kinds of repetitive work: finding new roles and completing similar forms across employer websites. OfferKite brings those tasks into one workflow. Its discovery service aggregates internship listings from community-maintained GitHub sources, removes duplicates, and matches roles to a student's preferences. A separate application agent uses a Chrome extension to inspect and fill forms in the user's active browser. Students review job selections and application materials, handle authentication challenges, and retain control over submission. The product brief also describes a local application tracker, subscription-based access, and a shared planning layer for answering form questions. This paper explains the architecture, design choices, and operational limits documented on the project site. It does not treat planned capabilities as tested results.

Next.jsTypeScriptChrome MV3LLM planningJob matchingLocal-first tracking

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.

Find relevant roles

Aggregate internship listings, normalize inconsistent fields, remove duplicates, and filter by student preferences.

Prepare and apply

Reuse resume details and saved answers, generate contextual responses, and interact with supported applicant tracking systems.

Keep the student in control

Students shortlist roles, review materials, and take over when authentication, CAPTCHA, or an unfamiliar field needs a decision.

Track the process

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.

Product workflowConceptual sequence
DiscoverRead GitHub job lists, parse postings, and clean source data.
MatchFilter and score roles by recency, role fit, location, and other preferences.
Review and applyShortlist a role, approve materials, and launch the browser extension.
TrackRecord the application and manage statuses and follow-ups.

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.

Discovery pipelineFrom raw lists to job cards
Fetch and parseRead source Markdown and extract role fields from tables.
Normalize and dedupeClean labels and URLs, then match listings that refer to the same job.
Cache and serveTemporarily store normalized results and expose them to search and ranking.

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:

Published ranking weights
Recency
25%
Role fit
20%
Company tier
20%
Location match
15%
Work authorization
15%
Internship term
5%

Bars are scaled to the largest weight. Percentages are configuration weights, not measured predictive accuracy.

score = 0.25 × recency + 0.20 × role_fit + 0.20 × company_tier + 0.15 × location_match + 0.15 × visa_alignment + 0.05 × term_match

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.

Application agent layers
Brain

Creates sessions, reads profile data, proposes responses, and returns fill plans.

→
Hands

Chrome extension reads form fields and interacts with the active page.

→
Apply-core

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.

Component relationshipsLogical view
Web applicationOnboarding, discovery, shortlist, tracker, and billing interface
API and planningSession endpoints, LLM requests, entitlement checks
Chrome extensionService worker, content script, DOM driver, and page overlay
Shared application logic: inspect → classify → plan → fill → verify

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.

Published storage design
DataWhere storedPurpose
Preferences and onboardingBrowser localStorageLocal matching settings
Shortlist, tracker, answers, documentsBrowser localStorageSingle-device job-search state
Account and session credentialsServer, Prisma + SQLiteLogin and account access
Subscription and plan dataServer, with local mirrorBilling and feature access
Application sessionsTemporary server memoryCoordinate 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

LayerTechnology named in the brief
Web applicationNext.js 15, React 19, TypeScript 5.7
InterfaceTailwind CSS 3, PostCSS
DatabasePrisma ORM, SQLite
Authenticationbcryptjs, hashed session cookies
PaymentsStripe Checkout, customer portal, webhooks
Language modelOpenAI API, GPT-4o listed as default
Browser automationChrome Manifest V3 extension, Playwright for testing
Extension toolingesbuild, 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.

ATS coverage

Form layouts change. Track field-fill success, manual interventions, failed uploads, and submission confirmation for each platform.

Accuracy of generated answers

Check that LLM-written responses match the student's actual experience and saved preferences. Avoid invented qualifications.

Durable runs

In-memory session state is temporary. Recoverable sessions need persistence, expiry rules, and careful handling of partial submissions.

Privacy controls

Document what profile and resume text crosses the network, where it is stored, and when it is deleted.

Discovery freshness

Validate application links and compare source timestamps with employer posting times rather than assuming every list entry is new.

User safeguards

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.