Developer Job Hunting Guide | Resume, Portfolio, Interviews & Negotiation

The Developer Job Process

1. Resume & LinkedIn    → get past the first filter (ATS + recruiter)
2. Portfolio            → show you can build real things
3. Recruiter screen     → 30min, background and culture fit
4. Technical interview  → coding, system design, or take-home
5. Final/team interview → behavioral, values, team fit
6. Offer & negotiation  → don't leave money on the table

---

Resume

What Actually Matters

ATS systems scan for keywords — use the job description's words
Human reviewers spend 6-10 seconds — make it scannable

Format:
  1 page (0-5 years experience)
  Single column
  Standard section headers (ATS-safe)
  No tables, graphics, or images
  PDF format

Resume Structure

[Name]                     [City, State | Remote]
[Email] | [LinkedIn] | [GitHub] | [Portfolio URL]

SUMMARY (optional, 2-3 lines)
  Full-stack developer with 2 years experience building React/Node.js
  applications. Contributed to open source (1,200+ GitHub stars).

SKILLS
  Languages: TypeScript, Python, SQL
  Frontend:  React, Next.js, Tailwind CSS
  Backend:   Node.js, FastAPI, PostgreSQL, Redis
  Tools:     Docker, GitHub Actions, AWS (EC2, S3, RDS)

EXPERIENCE
  [Company Name] — [Title]                    [Month Year – Present]
  • [Achievement with number, not task description]
  • Reduced API response time by 60% by adding Redis caching layer
  • Migrated 3 legacy services to TypeScript, reducing runtime errors by 40%
  • Led development of user authentication system handling 10K+ daily logins

PROJECTS
  [Project Name] | GitHub: github.com/you/project | Live: project.com
  • What it is and what problem it solves (1 line)
  • Tech stack: React, Node.js, PostgreSQL, Docker
  • Notable achievement: 500+ users, featured in HackerNews, etc.

EDUCATION
  [Degree] | [Institution] | [Year]
  Relevant coursework: Data Structures, Algorithms (if relevant)

Writing Strong Bullets

❌ Weak (task):
  "Worked on the frontend using React"
  "Fixed bugs in the API"
  "Helped with database design"

✅ Strong (achievement + impact):
  "Rebuilt checkout flow in React, reducing cart abandonment by 23%"
  "Identified and fixed N+1 query causing 2-second API timeout; reduced to 50ms"
  "Designed PostgreSQL schema for inventory system handling 50K+ products"

Formula: [Action verb] [what you did] [measurable result]

---

Portfolio

What to Build

Tier 1 (most impactful — shows real engineering):
  - A SaaS product with actual users (even 10 is impressive)
  - Open source contribution to a known project
  - Tool that solves your own problem and has GitHub stars

Tier 2 (solid, shows full-stack skills):
  - Full-stack CRUD app with auth, DB, deployment
  - REST or GraphQL API with documentation
  - Chrome extension with users

Tier 3 (still useful as learning projects):
  - Tutorial projects (don't make the hero project)
  - Clones (clone Trello, Twitter, etc. — shows you can read real requirements)

What NOT to build:
  - Todo apps (everyone has one)
  - Another weather app
  - Portfolio of portfolio apps

Making Projects Stand Out

README structure for a portfolio project:

# Project Name — One-sentence description

## Live Demo
[Link to live app] | [Video demo (2-min Loom)]

## What It Does
3 sentences: what problem it solves, who uses it, what makes it interesting.

## Tech Stack
- Frontend: React 18, TypeScript, Tailwind CSS
- Backend: Node.js, Express, PostgreSQL
- Infrastructure: Docker, deployed on Railway

## Key Technical Decisions
- Chose PostgreSQL over MongoDB because the data is highly relational
- Implemented optimistic updates for instant UI feedback
- Added Redis caching, reducing DB load by 70%

## Local Setup
```bash
git clone ...
docker compose up -d
npm install && npm run dev

---

## Technical Interview Preparation

### Coding Interviews (LeetCode-style)

Study plan (3 months, 1-2 hours/day):

Month 1: Foundations Arrays, strings, hash maps, two pointers, sliding window Target: Easy problems in 15-20 min

Month 2: Core patterns Binary search, recursion, DFS/BFS, stack/queue Target: Medium problems in 25-35 min

Month 3: Hard problems + review Dynamic programming, graphs, trees Practice under timed conditions

Resources: NeetCode.io — structured curriculum + video explanations Blind 75 list — 75 essential problems LeetCode — practice platform

```python
# During the interview:
# 1. Clarify constraints before coding
#    "Can the input be empty? What are the value ranges?"
# 2. State your approach before coding
#    "I'll use a hash map to track frequencies — O(n) time, O(n) space"
# 3. Write clean, readable code (not clever)
# 4. Test with examples (including edge cases)
# 5. Discuss time/space complexity

def two_sum(nums: list[int], target: int) -> list[int]:
    seen = {}  # value → index
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

System Design Interviews

Framework (45-minute interview):

1. Clarify requirements (5 min)
   "How many daily active users?"
   "Read-heavy or write-heavy?"
   "Consistency vs availability tradeoff preference?"

2. Capacity estimation (5 min)
   "10M DAU, 100 requests/user/day = 1B requests/day"
   "~12,000 requests/second (10% write, 90% read)"

3. High-level design (15 min)
   Draw: clients → CDN → load balancer → app servers → DB + cache

4. Deep dive (15 min)
   Database schema, API endpoints, caching strategy, scaling

5. Handle bottlenecks (5 min)
   "DB is bottleneck → read replicas → then shard"

Common systems to practice:
  URL shortener, Twitter feed, YouTube, Uber, WhatsApp, Google Drive

Behavioral Interviews (STAR Format)

STAR: Situation, Task, Action, Result

Prepare 6-8 stories that cover:
  - Leadership / taking initiative
  - Technical challenge overcome
  - Conflict with a teammate
  - Failure and what you learned
  - Handling ambiguity
  - Collaboration and mentoring

Example:
Q: "Tell me about a time you faced a difficult technical problem."

S: "Our e-commerce checkout was failing for ~5% of users at peak times."
T: "I was tasked with finding and fixing the root cause within 2 days."
A: "I added logging to identify the pattern — all failures were during
    DB writes. Traced to connection pool exhaustion. Implemented PgBouncer
    for connection pooling and increased pool size."
R: "Failure rate dropped from 5% to <0.01%. Also documented the incident
    and set up alerts for connection pool metrics."

---

Job Search Strategy

Where to Apply

Tier 1 (higher interview → offer rate):
  Employee referrals — ask everyone you know
  LinkedIn connections at target companies
  Recruiter outreach responses

Tier 2 (solid volume):
  Company career pages (bypass ATS at smaller companies)
  LinkedIn Jobs
  Indeed

Tier 3 (high volume, lower conversion):
  AngelList / Wellfound (startups)
  Glassdoor
  Built In (tech hubs)

Specialties:
  Remote: Remote.com, We Work Remotely, Remote OK
  Startups: YC Job Board, AngelList
  Freelance: Toptal, Upwork, Gun.io

Application Process

Research before applying:
  - Read recent company blog / engineering blog
  - Check Glassdoor reviews (interview process, culture)
  - Find the tech stack (LinkedIn jobs, StackShare, their GitHub)

Customize for each application:
  - Match your skills to their requirements
  - Reference their specific tech stack
  - Mention something specific about the company/product

Cover letter (when required):
  3 paragraphs:
  1. Why this company / product (specific, not generic)
  2. Your most relevant experience for THIS role
  3. What you'll contribute + call to action

---

Salary Negotiation

Do your research first:
  Levels.fyi — public comp data by company/level
  Glassdoor — salary ranges
  LinkedIn Salary
  Blind — anonymous discussion (grain of salt)
  Asking peers in the field

The conversation:

Recruiter: "What are your salary expectations?"
You: "I'm flexible, but based on my research for this role and
      my experience, I'm targeting around $X. Is that in range?"

(Never be the first to accept — always counter)

Offer received: "Thank you, I'm very excited about this opportunity.
I'd like a week to review the full package. Would that be possible?"

Counter offer: "I'm very interested in joining the team. Based on my
research and the scope of this role, I was hoping we could get to $Y
[10-15% above offer]. Is there flexibility there?"

If they say no: negotiate other things:
  - Signing bonus
  - Extra PTO
  - Remote work flexibility
  - Earlier performance review
  - Professional development budget

---

Networking

Effective networking (not asking for jobs):

1. Twitter/X — follow engineers at target companies, engage genuinely
2. LinkedIn — comment on posts, not just connect
3. Discord/Slack communities — contribute answers, ask good questions
4. Local meetups / conferences — in-person connection is memorable
5. Open source — contribute to projects the company maintains

When reaching out:
  "I saw your talk on [topic] at [conference] — your point about [X]
  resonated with my experience at [Y]. I'm working on [similar thing]
  and would love to chat for 20 minutes if you have time."

  Not: "Hey, can you refer me to your company?"

  Genuine connection first → job conversation naturally follows

---

Post-Interview Checklist

After each interview:
  [ ] Send thank-you email within 24 hours
      "Thank you for the time today. I really enjoyed discussing [X].
       It clarified my excitement about [specific thing about role/company]."
  [ ] Note what questions were asked (for your prep notes)
  [ ] Note anything you struggled with (address in your prep)
  [ ] Follow up if no response after 1 week
      "I wanted to follow up on my interview from [date].
       I remain very interested in the role and would love to hear
       if there are any updates."

---

More career guides (Korean on pkglog.com)

This site also publishes Korean deep-dives that pair well with this English overview: job posting channels & application tracking, resume, screening, and interview delivery, habits & weekly review, and senior / return-to-work positioning. Use them if you read Korean or run pages through translation.

Related posts:

• Git Workflow Best Practices
• GitHub Actions CI/CD Guide