Engineering Career Resources

Comprehensive reference for engineering career resources covering essential concepts, practical examples, and production best practices.

Engineering Career Resources is a curated collection of tools, practices, and workflows that help engineers navigate and accelerate their professional growth—from early-career to staff and principal levels—across technical, collaborative, and strategic dimensions. It matters when you’re preparing for a promotion, building your personal brand, advancing beyond individual contributor roles, or transitioning between companies or domains.

Planning Your Career Path

Identify your current stage and desired trajectory using a simple, repeatable process. Begin with a self-assessment of technical depth, leadership, and impact across three dimensions:

Use a career stage rubric with five levels:

For each level, maintain a career map in a single file, updated quarterly. The file is a YAML document with the following keys:

level: 4
current_role: "Staff Engineer, Backend"
target_role: "Principal Engineer, Infrastructure"
timeframe: 18 months
progress:
  - milestone: "Lead migration to cloud-native platform"
    status: "In Progress"
    expected_completion: "2025-06-15"
    evidence:
      - "pull request: #482 (design doc)"
      - "meeting notes: 2024-10-12 (architecture review)"
      - "feedback from 3 peer reviews"
  - milestone: "Publish internal library as open source"
    status: "Completed"
    evidence:
      - "GitHub repository: https://github.com/org/lib-core"
      - "12 contributors in 4 months"
      - "presentation at engineering summit"

Update this file after every 1:1 with your manager, after every project delivery, and before every promotion cycle.

Building and Sharing Your Work

Document your engineering work in a portfolio that is both public and searchable. The core artifact is a project log in a projects/ directory, each with its own index.md and evidence/ subdirectory.

A project log includes:

Example of a project log entry:



## Problem
Legacy monolith used session cookies for auth; slow, hard to scale, difficult to integrate with mobile apps.

## Scope
- Replace session-based auth with JWTs.  
- Add refresh token support.  
- Enable SSO with Okta.  
- Deploy to AWS ECS.

## Design
- Chose JWT with RSA-256 signing.  
- Used Redis for token invalidation.  
- Implemented `/auth/login` and `/auth/refresh` endpoints.  
- Chose 15-minute access and 7-day refresh tokens.

## Results
- 40% reduction in auth latency (p95: 120ms → 72ms).  
- SSO adoption increased by 60% in first month.  
- No auth-related incidents in 12 weeks.

## Evidence
- [Design doc](https://docs.org/auth-jwt-migration)
- [API spec](https://api.example.com/v1/auth/openapi.json)
- [Deployment checklist](https://github.com/org/auth-service/blob/main/deploy/checklist.md)
- [Screenshot: Postman test suite](evidence/postman-1.png)

Publish this portfolio as a static site using mkdocs or hugo. Host it on GitHub Pages or Netlify.

Preparing for Promotions

Build a promotion packet using a consistent structure. Start with a promotion dossier in a dossier/ directory.

The dossier includes:

  1. Personal summary (one page):
  1. Impact statements (3–5 pages):

Example of an impact statement:

> Situation: The onboarding workflow for new hires took 4 weeks on average; 30% of hires left before completing it. > Task: As lead engineer, I was responsible for redesigning the onboarding experience. > Action: I led a team of 3 engineers to build a self-service onboarding portal, integrated with HR systems and Slack. > Result: Average onboarding time dropped to 1.8 weeks. 85% of hires completed all steps. > Evidence: > - Onboarding dashboard > - [User survey: 4.7/5 satisfaction] > - [GitHub PR: #103 (feature)] > - [Video walkthrough: 2.5 min]

  1. Peer feedback: Collect at least 5 written evaluations from peers, managers, and cross-functional partners.
  1. Technical artifacts:

Run the promotion packet through a review loop:

When applying for roles, use a job tracking system in a jobs/ directory. Each job has its own index.md and applications/ subdirectory.

A job entry includes:

# Staff Engineer – Backend, Company X

## Application Status
- Applied: 2024-10-05
- Screening call: 2024-10-18
- Technical interview: 2024-11-01
- Onsite: 2024-11-15
- Decision: Expected 2024-11-25

## Materials
- [Resume](applications/resume-john-smith.pdf)
- [Cover letter](applications/cover-letter-company-x.md)
- [Coding challenge solution](applications/code-challenge.zip)
- [System design doc](applications/system-design.md)

## Interview Prep
- [Study guide: 3 hours](interviews/study-guide.md)
- [Mock interview recording](interviews/mock-1.mp4)
- [List of common questions](interviews/faq.md)

Use git to manage all stages. Create a branch for each stage:

git checkout -b interview-screening
git add applications/
git commit -m "Submitted screening application"
git push origin interview-screening

Track questions and answers in a questions/ file for each round:

{
  "round": "Technical",
  "date": "2024-11-01",
  "questions": [
    {
      "question": "How do you design a scalable message queue?",
      "answer": "Use a distributed, persistent queue with partitioning, replication, and backpressure handling. Consider Kafka or RabbitMQ. Use a heartbeat-based liveness check for consumers.",
      "followup": [
        "What happens when a consumer crashes?",
        "How do you handle message ordering?"
      ]
    },
    {
      "question": "Describe a time you led a project with tight deadlines.",
      "answer": "Led migration from MySQL to Postgres. Used a phased rollout with blue-green deployment. Reduced downtime to under 5 minutes. Delivered two weeks ahead of schedule."
    }
  ]
}

Continuous Learning and Skill Development

Maintain a learning backlog with todo.md in your home directory. Use taskwarrior or todo.txt format:

[ ] 2024-10-01: Read "Designing Data-Intensive Applications" Chapter 3
[ ] 2024-10-05: Implement gRPC service in Go
[ ] 2024-10-10: Write a blog post on observability in microservices
[ ] 2024-10-15: Contribute to open source project (https://github.com/org/project)

Each item includes a reference to the learning material and a completion checklist.

For technical deep dives, use structured study sessions:

  1. Select a topic (e.g., "distributed tracing").
  2. Gather resources:
  1. Run a session: 
     curl -H "X-Trace-ID: 12345" http://localhost:8080/api/users
  1. Document the session:

Example of a session note:

# Distributed Tracing with OpenTelemetry

## Setup
- Run: `docker-compose up -d`
- Access Jaeger at `http://localhost:16686`

## Tracing Flow
1. Client sends request to `http://localhost:8080/api/users`  
2. Service logs `Received request for /api/users`  
3. Service calls `user-service` via gRPC  
4. gRPC spans are nested under HTTP span

## Observations
- Trace ID: `12345`  
- Total duration: 234ms  
- Two services: `api-gateway`, `user-service`  
- Spans show client request, server processing, gRPC call

## Commands
```bash
curl -H "X-Trace-ID: 12345" http://localhost:8080/api/users
docker-compose logs api-gateway

Key Learnings


## Sharing Knowledge and Growing Your Network

Participate in **engineering communities** by contributing to open source, giving talks, and writing articles.

For **open source contribution**, follow this workflow:

1. Find a project on GitHub (e.g., `https://github.com/organization/project`).
2. Clone it: `git clone https://github.com/organization/project.git`
3. Create a branch: `git checkout -b fix/bug-123`
4. Make changes, write tests, update documentation.
5. Commit with a conventional message:
   ```bash
   git commit -m "fix: handle null user in login endpoint"
  1. Push: git push origin fix/bug-123
  2. Open a pull request via hub pull-request or web UI.
  3. Add a PR.md file with:

For talks and presentations, use a consistent template:

# The Evolution of API Gateways

## Abstract
API gateways have transformed how services communicate. This talk covers their history, key patterns, and modern implementations.

## Outline
1. Introduction: What is an API gateway?
2. Historical progression: from reverse proxy to full service mesh.
3. Key patterns: routing, authentication, rate limiting, transformation.
4. Case study: building a gateway at scale.
5. Future directions: serverless gateways, edge computing.

## Slides
- [Google Slides: https://slides.example.com/api-gateways]
- [PDF: slides.pdf]

## Speaker Notes
- Start with a real-world example: Netflix's API gateway.
- Use `figlet` to generate title: `figlet -f banner "The Evolution"`.

## Video
- [Recording: https://vimeo.com/123456]
- [Transcript: transcript.txt]

Use ffmpeg to process video:

ffmpeg -i input.mp4 -vf "scale=1280:720" -c:v libx264 -preset medium -crf 23 -c:a aac -b:a 128k output.mp4

Managing Your Engineering Identity

Maintain a personal engineering brand using a single about.md file that is updated and shared across platforms.

The file includes:

Publish this file to a static site, and use it as the about page on your personal website.

Use git to version the file and track changes:

git log --oneline --since="1 month ago"
git diff HEAD~1 HEAD

Update the file after every talk, project, or promotion. Share it via:

This system ensures your engineering identity remains consistent, visible, and evolving.

This page was rewritten on 18 October 2026. It replaced a templated version that was not specific to its own title. How these pages are written and checked. If anything here is wrong, tell us at [email protected] and we will correct it.