Internship Copilot V2

Internship Copilot is an AI-powered internship intelligence backend that ingests real public job postings, normalizes them into a shared schema, extracts skills, compares resumes against roles, and recommends learning paths.

The V2 architecture replaces mock internship data with an extensible ingestion pipeline for public Greenhouse and Lever job boards.

Features

• FastAPI backend with portfolio-ready API docs
• Async ingestion orchestration for multiple job board connectors
• Greenhouse and Lever public board connectors
• Normalized job schema stored in SQLite
• Skill extraction from real job descriptions with BeautifulSoup cleanup
• Resume-to-job match scoring and skill-gap analysis
• Learning path recommendations for missing skills
• pandas-backed skill demand analytics
• Environment variable configuration via .env
• Optional OpenAI service hook for coaching-style recommendations

Evolution

V1

• Mock internship dataset
• Basic resume matching
• Prototype recommendation logic

V2

• Real-world internship ingestion
• FastAPI backend architecture
• Async connectors
• SQLite persistence
• Skill extraction and analytics
• AI-assisted development workflow

Architecture

app/
  api/
    routes.py                 # FastAPI endpoints
  core/
    config.py                 # Environment-backed settings
  db/
    database.py               # SQLite connection and schema setup
  ingestion/
    base.py                   # Connector interface
    http.py                   # Async wrapper around requests
    pipeline.py               # Concurrent ingestion orchestration
    connectors/
      greenhouse.py           # Greenhouse public board connector
      lever.py                # Lever public board connector
  models/
    job.py                    # Pydantic request/response models
  repositories/
    jobs.py                   # SQLite persistence layer
  services/
    analytics.py              # pandas skill analytics
    ai.py                     # Optional OpenAI recommendation helper
    learning_paths.py         # Missing-skill learning recommendations
    matching.py               # Resume/job scoring
    skills.py                 # HTML cleanup and skill extraction
  main.py                     # FastAPI app factory entrypoint

AI-Assisted Development Workflow

Internship Copilot V2 was built as an example of AI-native software engineering: human-directed product and system design, accelerated by AI-assisted implementation.

The product direction, system architecture, feature planning, backend structure, ingestion pipeline strategy, and AI workflow logic were intentionally designed through iterative engineering decisions. OpenAI Codex was used as an implementation partner to accelerate backend scaffolding, FastAPI structure, connector implementation, schema normalization, service-layer organization, debugging support, and refactoring.

This workflow reflects a modern engineering approach in the AI era: combining system reasoning, prompt engineering, code review, debugging judgment, and orchestration of AI tools. The project is not presented as software built automatically by AI; it is a human-led system where AI support helped increase development speed while preserving architectural ownership and engineering understanding.

Setup

python -m venv venv
.\venv\Scripts\activate
pip install -r requirements.txt
Copy-Item .env.example .env

Edit .env with the job board company slugs you want to ingest:

GREENHOUSE_COMPANIES=airbnb,stripe
LEVER_COMPANIES=netflix,scaleai
OPENAI_API_KEY=

Run

uvicorn app.main:app --reload

Open the generated API docs:

http://127.0.0.1:8000/docs

Core Endpoints

Health

GET /api/health

Ingest Real Jobs

POST /api/ingest

Example body:

{
  "greenhouse_companies": ["airbnb", "stripe"],
  "lever_companies": ["netflix"],
  "internship_only": true
}

Search Stored Jobs

GET /api/jobs?query=data&source=greenhouse&limit=25

Match Resume to Job

POST /api/match

Example body:

{
  "job_id": 1,
  "resume_text": "Python, SQL, pandas, machine learning, FastAPI..."
}

Response:

{
  "job_id": 1,
  "match_score": 72,
  "matched_skills": ["python", "sql"],
  "missing_skills": ["docker", "aws"],
  "learning_path": [
    "Containerize a FastAPI app and run it locally with environment variables.",
    "Deploy a small API or static dashboard using one managed AWS service."
  ]
}

Skill Demand Analytics

GET /api/analytics/skills

Connector Design

Each source implements JobBoardConnector:

class JobBoardConnector(ABC):
    source: str

    @abstractmethod
    async def fetch_jobs(self) -> list[JobCreate]:
        ...

To add a new source:

1. Create app/ingestion/connectors/new_source.py.
2. Fetch raw postings from the public API.
3. Normalize each posting into JobCreate.
4. Register the connector in JobIngestionPipeline.

Notes

• Greenhouse uses public board tokens such as boards-api.greenhouse.io/v1/boards/{token}/jobs.
• Lever uses public company slugs such as api.lever.co/v0/postings/{company}.
• The deterministic scoring service works without OpenAI, which makes demos reliable.
• The OpenAI helper is available for richer narrative career recommendations when OPENAI_API_KEY is configured.