tech-resume-optimizer

What this skill does

# Tech Resume Optimizer

## When to Use This Skill

Use this skill when the user:
- Is applying for software engineering roles
- Wants to optimize a technical resume
- Needs help with developer/PM/technical job applications
- Mentions: "tech resume", "software engineer resume", "developer resume", "technical resume", "SWE resume", "PM resume"

## Core Capabilities

- Optimize resumes for technical roles (SWE, PM, Data, DevOps)
- Structure technical skills sections effectively
- Highlight projects and technical achievements
- Balance technical depth with business impact
- Format for both ATS and technical recruiters
- Include GitHub, portfolio, and technical links

## Tech Resume Philosophy

**What Tech Recruiters Look For:**
1. Relevant technical skills (languages, frameworks, tools)
2. Scale and impact (users, transactions, data size)
3. Problem-solving abilities
4. System design understanding
5. Collaborative abilities
6. Growth trajectory

## Tech Resume Structure

### Recommended Order

```
1. Contact Information (including GitHub, Portfolio)
2. Professional Summary (optional but helpful)
3. Technical Skills (critical for ATS)
4. Work Experience (with technical achievements)
5. Projects (especially for early career)
6. Education
7. Certifications (if relevant)
```

### Contact Section for Tech

```
John Developer
San Francisco, CA
[email protected] | (555) 123-4567
LinkedIn: linkedin.com/in/johndev
GitHub: github.com/johndev
Portfolio: johndev.io
```

**Include:**
- GitHub (required for SWE roles)
- Portfolio/personal website
- LinkedIn
- Tech blog (if you have one)

**Don't Include:**
- Address (city/state is enough)
- Photo
- Social media (unless relevant)

## Technical Skills Section

### Organization Strategies

**Option 1: By Category**
```
Languages: Python, JavaScript, TypeScript, Go, SQL
Frameworks: React, Node.js, Django, FastAPI
Databases: PostgreSQL, MongoDB, Redis, Elasticsearch
Cloud/Infrastructure: AWS (EC2, S3, Lambda, RDS), Docker, Kubernetes, Terraform
Tools: Git, JIRA, CI/CD, Datadog, Grafana
```

**Option 2: By Proficiency** (use carefully)
```
Expert: Python, React, PostgreSQL, AWS
Proficient: Go, TypeScript, MongoDB, Docker
Familiar: Rust, GraphQL, Kubernetes
```

**Option 3: Flat List** (ATS-friendly)
```
Skills: Python, JavaScript, TypeScript, React, Node.js, Django, PostgreSQL, MongoDB, AWS, Docker, Kubernetes, Git
```

### What to Include

**Languages:**
- List languages you can code in confidently
- Order by relevance to target role
- Include query languages (SQL, GraphQL)

**Frameworks/Libraries:**
- Web: React, Vue, Angular, Django, Flask, Express
- Data: Pandas, NumPy, TensorFlow, PyTorch
- Testing: Jest, Pytest, Selenium

**Databases:**
- Relational: PostgreSQL, MySQL, SQL Server
- NoSQL: MongoDB, DynamoDB, Cassandra
- Caching: Redis, Memcached

**Cloud/DevOps:**
- Cloud: AWS, GCP, Azure (specific services)
- Containers: Docker, Kubernetes
- CI/CD: Jenkins, GitHub Actions, CircleCI
- IaC: Terraform, CloudFormation

### What NOT to Include
- ❌ Microsoft Office (assumed)
- ❌ Operating systems (unless DevOps role)
- ❌ Outdated tech (unless specifically required)
- ❌ Skill bars or ratings (subjective and break ATS)
- ❌ Every technology you've touched once

## Experience Section for Tech Roles

### The Technical Bullet Formula

**[Action Verb] + [Technical What] + [Scale/Impact] + [Technology Used]**

**Examples:**

❌ **Weak Technical Bullet:**
```
- Worked on backend services
- Helped improve system performance
- Built features for the product
```

✅ **Strong Technical Bullet:**
```
- Architected microservices migration from monolith, reducing deployment time from 2 hours to 15 minutes and enabling independent team deployments
- Optimized PostgreSQL queries and implemented Redis caching, reducing API latency by 60% (from 500ms to 200ms) for 100K daily active users
- Built real-time notification system using WebSockets and AWS SNS, handling 1M+ messages daily with 99.9% delivery rate
```

### Technical Metrics to Include

**Scale:**
- Users: "serving 500K DAU"
- Requests: "handling 10K requests/second"
- Data: "processing 50TB daily"
- Uptime: "maintaining 99.99% availability"

**Performance:**
- Latency: "reduced from Xms to Yms"
- Speed: "improved by X%"
- Load time: "decreased by X seconds"

**Efficiency:**
- Cost: "reduced AWS costs by 40%"
- Time: "cut deployment time from X to Y"
- Resources: "reduced memory usage by X%"

**Business:**
- Revenue: "features drove $XM revenue"
- Conversion: "improved checkout by X%"
- Engagement: "increased DAU by X%"

### Role-Specific Bullet Examples

**Software Engineer:**
```
• Designed and implemented authentication service using OAuth 2.0 and JWT, securing 2M+ user accounts with zero security incidents
• Led migration to Kubernetes, achieving 99.99% uptime and reducing infrastructure costs by 35% ($200K annually)
• Mentored 3 junior engineers through code reviews and pair programming, improving team velocity by 25%
```

**Data Engineer:**
```
• Built data pipeline processing 100M+ events daily using Apache Kafka and Spark, reducing data latency from hours to minutes
• Designed data warehouse schema in Snowflake, enabling self-service analytics for 50+ business users
• Implemented data quality monitoring with Great Expectations, catching 95% of data issues before impacting downstream systems
```

**DevOps/SRE:**
```
• Implemented infrastructure as code using Terraform, reducing provisioning time from 2 days to 30 minutes
• Built monitoring and alerting system with Prometheus and Grafana, reducing MTTR from 4 hours to 30 minutes
• Automated deployment pipeline with GitHub Actions, enabling 50+ daily deployments with zero-downtime releases
```

**Product Manager (Technical):**
```
• Led API platform roadmap for developer tools used by 10K+ developers, driving 40% increase in API adoption
• Defined technical requirements for ML recommendation engine, resulting in 25% increase in user engagement
• Partnered with engineering to reduce technical debt by 30%, improving release velocity from bi-weekly to weekly
```

## Projects Section

**Critical for:**
- Junior engineers
- Career changers
- Bootcamp graduates
- Anyone with gaps

### Project Format

```
Project Name | Technologies | Link
• Description of what it does
• Technical highlights and challenges solved
• Scale or usage metrics if available
```

### Example Projects Section

```
PROJECTS

Distributed Task Queue | Python, Redis, Docker | github.com/user/taskqueue
• Built distributed task queue handling 10K+ jobs/hour with automatic retries and dead letter queue
• Implemented priority queuing and rate limiting for multi-tenant support

Real-time Chat App | React, Node.js, WebSocket, MongoDB | chatapp.demo.com
• Full-stack chat application supporting 100+ concurrent users with real-time messaging
• Implemented end-to-end encryption and message persistence

ML Price Predictor | Python, TensorFlow, FastAPI | github.com/user/predictor
• Trained regression model on 1M+ data points achieving 92% accuracy for price prediction
• Deployed as REST API with automatic model retraining pipeline
```

### What Makes a Good Project

**Do Include:**
- Projects with real users
- Open source contributions
- Technical blog posts
- Hackathon projects (especially winners)
- Complex personal projects

**Don't Include:**
- Tutorial follow-alongs
- Trivial to-do apps
- Incomplete projects
- Coursework (unless exceptional)

## Education Section for Tech

### Standard Format
```
B.S. Computer Science | Stanford University | 2020
GPA: 3.8/4.0 (include if above 3.5)
Relevant Coursework: Distributed Systems, Machine Learning, Database Systems
```

### For Bootcamp Graduates
```
Software Engineering Certificate | App Academy | 2023
- 1000+ hour immersive program
- Full-stack JavaScript, React, Node.js, PostgreSQL

B.A. Economics | UCLA | 2020
```

### For Self-Taught Engineers
```
Professional Certifications:
- AWS Solutions Architect Associate | 2023
- MongoDB