Inspiration
Finding a job is not a single action. Candidates move between resume editors, job boards, spreadsheets, interview-preparation tools, and career advice—often without a clear connection between them. Employers face the other side of the same problem: applications contain plenty of information, but not always the structured context needed to make consistent hiring decisions.
Career CoPilot was inspired by this fragmentation. We wanted to build a guided workspace that helps candidates move from career intent to stronger applications and interview readiness, while giving employers a more structured way to discover, review, and advance talent.
Instead of trying to replace platforms such as LinkedIn or Indeed, Career CoPilot complements them by focusing on what happens before, during, and after an application.
What it does
Career CoPilot connects career development and hiring in one multilingual workflow.
For candidates, it provides:
- Resume readiness analysis with actionable improvement suggestions
- Career-path planning with milestones, skills, and next steps
- Job discovery and explainable candidate-to-role matching
- Application tracking in a structured pipeline
- Timed interview practice with session-level feedback
- Cover letters, outreach messages, learning plans, and other career tools
For employers, it provides:
- Job posting and applicant management
- Consent-gated talent discovery
- Candidate matching with evidence-based explanations
- A structured applicant funnel with status history
- Interview scheduling, scorecards, messaging, and shortlists
- Company profiles and organization-level workflows
The platform also includes an administration surface for managing model routing, prompts, quotas, permissions, API access, billing controls, and audit records.
Career CoPilot currently supports seven interface languages: English, French, Chinese, Japanese, German, Vietnamese, and Arabic.
How we built it
The frontend is a React 19 and TypeScript single-page application built with Vite and Tailwind CSS. It is divided into four role-aware surfaces: the public website, the candidate workspace, the employer portal, and the administration portal.
Firebase provides authentication, Firestore, Cloud Storage, and Cloud Functions. Privileged operations—including AI execution, credit accounting, job-application transitions, billing entitlements, and administrative actions—run through server-side functions instead of trusting the browser.
We built a provider abstraction that supports Gemini and OpenAI-compatible Chat Completions providers. The platform can apply model tiers, administrator-controlled routing, key rotation, availability-based fallback, and business bring-your-own-provider configurations.
Every AI request follows a governed pipeline:
- Authenticate the user
- Validate and limit the request
- Claim the operation using an idempotency key
- Check and deduct credits when required
- Select an allowed model through server-side routing
- Validate the generated structured response
- Record usage or refund the charge if execution fails
Firestore and Storage security rules enforce owner-only and server-only boundaries. Sensitive information such as provider credentials, frozen application resumes, billing records, and credit ledgers is never directly writable by clients.
We also created a layered release gate using TypeScript checks, Vitest, Firebase emulator contracts, Playwright end-to-end tests, runtime smoke tests, dependency auditing, and production-shaped builds.
Challenges we faced
Making AI output dependable
Generative output is naturally variable, but product interfaces need stable data. We introduced structured response schemas, validation, correction passes, and quality checks so that resume reports, interview evaluations, and career plans can be rendered consistently.
Designing trustworthy permission boundaries
Career CoPilot serves candidates, employers, agencies, reviewers, administrators, and super administrators. Separating interface visibility from server authority—and preventing clients from changing roles, credits, subscriptions, or hiring states—required carefully designed callable functions and security rules.
Coordinating a two-sided workflow
A candidate action can affect an employer’s pipeline, while an employer decision can update the candidate’s application history. We had to make these transitions traceable, idempotent, and resistant to race conditions.
Protecting consent and personal information
Talent discovery could not simply expose a candidate’s live profile. Candidates must opt in, and an employer receives a limited, frozen candidate packet only after explicit consent. That packet can expire or be revoked without exposing later profile edits.
Handling money-equivalent failures
AI credits and billing entitlements behave like financial state. A failed AI request must not silently consume credits, and a repeated checkout or webhook must not grant the same entitlement twice. We used transactional ledgers, deterministic identifiers, refund recovery queues, and reconciliation records to make these failures observable and recoverable.
Keeping a multilingual product consistent
Maintaining seven locales across candidate, employer, administration, authentication, and marketing surfaces required automated localization parity checks instead of relying only on manual review.
Accomplishments that we are proud of
- Built a working candidate-to-employer workflow instead of a collection of disconnected AI tools
- Moved AI credentials and privileged decisions behind a server-controlled boundary
- Implemented explainable candidate matching rather than presenting unexplained scores
- Added consent-gated talent discovery with revocable, time-limited candidate packets
- Created transactional credit accounting with idempotent failure recovery
- Built model governance with routing, quotas, fallback, and business provider support
- Established a release-gate system that has completed a fully green run on an exact reviewed commit
- Captured product screenshots directly from the working application rather than using conceptual mockups
What we learned
The biggest lesson was that building an AI product is not mainly about writing a better prompt. Reliability comes from everything around the model: authentication, authorization, input limits, schemas, retries, idempotency, observability, cost controls, and honest failure states.
We also learned that explainability matters more than a single AI-generated score. Candidates and employers need to understand which resume evidence supports a match, which requirements are missing, and what action should happen next.
Finally, we learned to separate engineering readiness from production readiness. Automated tests can prove that the software behaves correctly in controlled environments, but a public launch still requires evidence from real payment, email, cloud configuration, monitoring, privacy, and device-testing workflows.
What's next for Career CoPilot
Before opening the platform to broad public traffic, our next priorities are:
- Complete live Stripe and signed-webhook validation
- Verify production Firebase rules, indexes, TTL policies, IAM, and rollback procedures
- Test verification, password-reset, and notification email delivery across real mail providers
- Expand AI quality, latency, and cost evaluation with representative datasets
- Run pilot programs with candidates, career advisors, and employers
- Improve accessibility and real-device coverage
- Break the largest candidate, employer, and administration modules into smaller maintainable components
- Continue evaluating OpenAI and other model providers through the governed routing layer
Our long-term goal is to make Career CoPilot a trusted decision-support layer between career intent and hiring—not an AI system that makes decisions for people, but one that helps both sides make better-informed decisions.
Log in or sign up for Devpost to join the conversation.