AutoPortfolio Builder

FastAPI portfolio generator for recruiter-ready profile content

Turns GitHub, LinkedIn, and manual profile signals into polished portfolio content, dashboards, and exports.

Repository: bhedanikhilkumar-code/AutoPortfolio-Builder
Live demo: autoportfolio-builder.onrender.com (Render free-tier cold starts may take a moment.)

Visual Review

The README keeps a recruiter-friendly visual layer: stack badges, live-demo link, repository-health badge, and a local SVG workflow preview. The preview is stored inside the repo so the project still looks polished without depending on fragile third-party README widgets.

Quick Signal

AutoPortfolio Builder is a full-stack Python web app for converting developer profile data into polished portfolio and resume-style output. It combines FastAPI APIs, a static frontend, authentication flows, profile integrations, portfolio generation, admin tooling, analytics, and export formats.

Signal	Details
Product domain	Developer portfolio automation, resume/portfolio generation, profile storytelling
Backend	FastAPI, Pydantic models, SQLite persistence, Mangum/Vercel adapter
Frontend	Static HTML/CSS/JavaScript SPA served by FastAPI
Integrations	GitHub profile/repository fetch, LinkedIn public-profile fallback chain, Google/GitHub OAuth hooks
Exports	HTML, PDF, ZIP, JSON, Markdown, LaTeX, deploy package helpers
Best review angle	API design + product workflow + recruiter-focused output generation

What It Does

Area	Capability
Profile intake	Accepts GitHub username/URL, LinkedIn username/URL, skills, projects, target role, and theme choices
Portfolio generation	Builds hero, about, projects, skills, and contact sections from GitHub activity and user inputs
Role targeting	Supports role-focused positioning for frontend, backend, fullstack, data, and AI directions
Authentication	Email/password sessions, email verification flow, Google/GitHub OAuth entry points, avatar upload/remove
Dashboard	Saves generated resumes, drafts, generation history, duplicated versions, exports, and activity views
Admin tools	Admin stats, users/resumes overview, CSV exports, force publish, and delete actions
Growth modules	ATS analyzer, SEO helpers, themes, PDF templates, API keys, webhooks, i18n, cover letters, job tracker, QR/vCard tools

Architecture at a Glance

flowchart LR
    Browser[Static SPA] --> API[FastAPI App]
    API --> Validation[Pydantic + input validation]
    API --> Integrations[GitHub / LinkedIn / OAuth Services]
    API --> Generator[Portfolio Generation Service]
    API --> Dashboard[Dashboard + Admin Services]
    API --> DB[(SQLite app_data.db)]
    Generator --> Exports[HTML / PDF / ZIP / JSON / Markdown / LaTeX]
    API --> Static[Static assets + SPA routes]

Loading

Core Workflow

sequenceDiagram
    participant U as User
    participant UI as Static Frontend
    participant API as FastAPI
    participant GH as GitHub Service
    participant GEN as Portfolio Generator
    participant DB as SQLite
    participant EX as Export Layer
    U->>UI: Enter profile, skills, role, and theme
    UI->>API: Submit generation request
    API->>GH: Fetch GitHub profile and repositories
    API->>GEN: Build recruiter-ready portfolio sections
    GEN-->>API: Return structured portfolio response
    API->>DB: Save resume/draft/history when requested
    U->>EX: Export HTML, PDF, ZIP, or deployment assets

Loading

Best Review Path

1. Open the live demo and try the main generator flow.
2. Inspect app/main.py for route organization and API surface.
3. Review app/services/portfolio.py for portfolio section generation and export logic.
4. Review app/static/js/generator.js and app/static/js/dashboard.js for frontend workflow handling.
5. Run the local checks below.
6. Read the docs hub for architecture, roadmap, quality, and review notes.

Local Setup

1. Clone and create an environment

git clone https://github.com/bhedanikhilkumar-code/AutoPortfolio-Builder.git
cd AutoPortfolio-Builder
python -m venv .venv

Activate it:

# Windows
.venv\Scripts\activate

# macOS/Linux
source .venv/bin/activate

2. Install dependencies

python -m pip install --upgrade pip
pip install -r requirements.txt

3. Configure environment variables

cp .env.example .env

Key variables are documented in .env.example:

Variable	Purpose
GITHUB_TOKEN	Optional higher-rate GitHub API access
GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET	Google OAuth setup
GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET	GitHub OAuth setup
ADMIN_EMAILS	Comma-separated admin account allowlist
SMTP_*	Email verification delivery configuration
AI_API_KEY, AI_BASE_URL, AI_MODEL	Optional AI content generation; deterministic fallback works without it

Do not commit real secrets. Keep .env local.

4. Run locally

uvicorn app.main:app --reload

Open: http://localhost:8000

Quality Checks

python -m compileall app api tests
pytest

Current verified checks for this polish pass:

Check	Result
Repository health validation	Passes locally and in GitHub Actions
Python compile check	Passes with python -m compileall app api tests
Test suite	Passes with pytest

Important Routes

Route	Purpose
/	Static landing page / SPA shell
/api/health	Health check endpoint
/api/profile	Fetch and normalize GitHub/LinkedIn profile data
/api/generate	Generate structured portfolio response
/api/export/html	Export portfolio as HTML
/api/export/pdf	Export portfolio as PDF
/api/export/zip	Export portfolio package
/api/dashboard	Authenticated dashboard state
/api/admin/*	Admin stats, users, resumes, and CSV tooling

Project Structure

AutoPortfolio-Builder/
├── api/
│   └── index.py                 # Vercel/Mangum entrypoint
├── app/
│   ├── main.py                  # FastAPI app, routes, and app factory
│   ├── schemas.py               # Pydantic request/response contracts
│   ├── core/                    # SQLite connection and schema setup
│   ├── services/                # GitHub, LinkedIn, validation, portfolio generation
│   ├── auth/                    # Sessions, OAuth helpers, email verification
│   ├── admin/                   # Admin dashboard and CSV service logic
│   ├── static/                  # Static SPA, CSS, JS, icons, and brand assets
│   └── */service.py             # ATS, SEO, themes, analytics, exports, jobs, QR, etc.
├── docs/                        # Architecture, case study, quality, roadmap, review checklist
├── templates/                   # Resume/export templates
├── tests/                       # FastAPI and service tests
├── .github/workflows/           # Repository health workflow
├── render.yaml                  # Render deployment config
├── vercel.json                  # Vercel deployment config
└── requirements.txt             # Python runtime/test dependencies

Deployment Notes

Platform	Config
Render	render.yaml runs uvicorn app.main:app --host 0.0.0.0 --port $PORT
Vercel	vercel.json routes requests through api/index.py with Mangum
Procfile	Provides a generic web process command for Python hosts

Use platform secret managers for OAuth, SMTP, and AI keys.

Known Current State

• The app has a broad feature surface and strong portfolio value, but the next production-hardening step is trimming/organizing the largest route surface into clearer routers.
• LinkedIn support uses public-page/meta/fallback inference because LinkedIn data access is restricted without approved APIs.
• The included preview image is a workflow visual; browser screenshots or a short demo GIF should be added after the next UI capture pass.
• AI generation is optional and falls back to deterministic portfolio content when no AI key is configured.

Roadmap

• Add a screenshot strip or GIF covering landing → generator → dashboard → export
• Split app/main.py into smaller FastAPI routers by domain
• Add OpenAPI examples for core portfolio-generation endpoints
• Add frontend smoke tests for generator and dashboard flows
• Add sample profiles/fixtures for quick reviewer demos
• Improve deployment observability and cold-start notes

Documentation Hub

Document	Purpose
Architecture	System layers, workflow, data/state model, and extension points.
Case Study	Product framing, decisions, tradeoffs, and portfolio story.
Roadmap	Practical next steps for turning the project into a stronger product.
Quality Standard	Repository health checks, review standards, and quality gates.
Review Checklist	Final share/recruiter review checklist for a stronger GitHub impression.
Contributing	Branching, commit, review, and quality guidelines.
Security	Responsible disclosure and safe configuration notes.
Support	How to ask for help or report issues clearly.
Code of Conduct	Collaboration expectations for respectful project activity.

License

This project is available under the MIT License.