pkglog
KO

A 12-Week Plan for Changing Developer Jobs: Portfolio, Resume, Coding Tests and Offer Negotiation

By · · 5 min read · Updated Beginner Guide

Key takeaways

A practical guide for developers preparing for job changes after resignation. Presents a 3-month roadmap covering portfolio preparation, resume writing, technical interview preparation, coding tests, and salary negotiation based on real experiences.

Introduction

The process of deciding to resign and looking for a new company is both exciting and daunting. What people preparing for their first job change lose most is time: they rewrite the resume again and again without deciding what to do first, and only after a few failed interviews do they see what they should have prepared. Especially, job hunting after resignation is different from job hunting while employed. You have time flexibility but greater psychological pressure, and there’s burden about the employment gap. However, with proper preparation, you can actually seize better opportunities. In this article, I’ve organized a practical roadmap to get hired at your desired company within 3 months after resignation, organized by week so you can see what to prepare first.

Week 1: Rest and Direction Setting

Recovering from Burnout

Take 1-2 weeks to rest properly right after resignation. Starting preparation the day after you leave feels productive, but when you are burned out you cannot concentrate, and it shows in interviews as a lack of energy. Recommended Activities:

  • Catch up on sleep
  • Light exercise (walking, running)
  • Read tech blogs you’ve been interested in (casually)
  • Meet friends and chat

Setting Job Change Direction

After resting, clearly define what you want.

// Job change goal checklist
type JobGoal struct {
    // Priority (1-5 points)
    Salary        int  // Salary (how important?)
    Technology    int  // Tech stack (want latest tech?)
    WorkLifeBalance int // Work-life balance (no overtime?)
    Culture       int  // Company culture (horizontal? autonomous?)
    Growth        int  // Growth opportunity (lots to learn?)
    Stability     int  // Stability (large corp? startup?)
}
// Example: My priorities
myGoal := JobGoal{
    Salary:        4,  // Important but not top priority
    Technology:    5,  // Latest tech stack most important
    WorkLifeBalance: 3, // Somewhat important
    Culture:       4,  // Prefer horizontal culture
    Growth:        5,  // Growth opportunity very important
    Stability:     2,  // Stability less important
}

Having these priorities set will keep you from wavering when choosing companies. A common regret is choosing on salary alone and discovering a legacy stack or a culture that does not fit, which often leads to another move within a year.

Creating Target Company List

Create a list of 20-30 companies. Too few means no options, too many makes preparation scattered.

How to Find Companies:

  • Wanted, Rocketpunch, Programmers job postings
  • LinkedIn “Jobs” tab
  • Directly visit career pages of services you’re interested in
  • Developer communities (Blind, Disquiet) recommendations

Week 2-3: Portfolio Refinement

Organizing GitHub Profile

Interviewers check GitHub first. Questions like “I see on GitHub you’ve been studying Go recently?” are common, so what is pinned there becomes part of the conversation.

Checklist:

  • Add profile photo (professional feel)
  • Write bio (one-line identity)
  • Create README.md (self-introduction + tech stack)
  • Set pinned repositories (3-4 representative projects)
  • Fill contribution graph (last 3 months activity) Pinned Project Selection Criteria:
  1. High-quality projects (README, tests, documentation)
  2. Latest tech stack (similar to target companies’ tech)
  3. Practical projects (solving real problems rather than toy projects)

Creating Representative Projects

If you have time, create 1-2 new projects. A project built during the job search is fine, as long as you can explain the decisions in it (why WebSocket, how you handle reconnects, what you measured). Project Ideas:

  • REST API server (Express, Go Gin, FastAPI)
  • Real-time chat (WebSocket, Redis)
  • Data pipeline (Kafka, Airflow)
  • Crawler + Dashboard (Puppeteer, React)
  • CLI tool (Go, Rust) What’s Important:
  • Code quality (linter, formatter, tests)
  • README writing (installation, execution, architecture explanation)
  • Commit messages (Conventional Commits)
  • Branch strategy (feature, develop, main)
# Real-time Chat Server
## Tech Stack

- Backend: Go (Gin, WebSocket)
- Database: PostgreSQL, Redis
- Infrastructure: Docker, Kubernetes
## Key Features

- Real-time message transmission (WebSocket)
- Message persistence (PostgreSQL)
- Online user management (Redis)
- Load testing (10,000 concurrent connections)
## Architecture

[Architecture diagram image]
## How to Run

\`\`\`bash
docker-compose up -d
go run main.go
\`\`\`
## Performance Optimization

- Server-to-server message broadcast with Redis Pub/Sub
- Connection pool optimization
- Message batch processing

Week 4-5: Resume Writing and Applications

Resume Writing Essentials

Put only the essentials on 1 page. Interviewers skim resumes in 30 seconds. Structure (Recommended):

1. Name, contact, GitHub, blog
2. Brief introduction (2-3 lines)
3. Tech stack (only what you're proficient in)
4. Experience (most recent first, project-focused)
5. Education (briefly)

Experience Writing Tips

Before (Bad Example):

- Backend development
- API development and maintenance
- Bug fixes

After (Good Example):

- Payment API performance improvement: Response time 500ms → 50ms (10x improvement)
  * Introduced Redis caching, optimized DB queries (solved N+1 problem)
  * Stabilized processing of 1 billion KRW daily transactions
  
- Built real-time notification system (WebSocket, Redis Pub/Sub)
  * Handled 10,000 concurrent users
  * Achieved message delivery latency under 100ms
  
- Legacy code refactoring: Test coverage 0% → 80%
  * Deployment time reduced from 30 min → 5 min
  * Production bugs reduced from 10/month → 2/month

Key Points:

  • Prove with numbers (performance, scale, results)
  • Specify tech stack (Redis, WebSocket)
  • Business impact (transaction volume, user count)

Application Strategy

Apply to 5-10 places simultaneously. Applying one at a time takes too long. Application Priority:

  1. Priority 1 (3-5 places): Companies you really want to join
  2. Priority 2 (5-7 places): Decent companies
  3. Priority 3 (5-10 places): For interview practice Tip: Interview with Priority 3 companies first. It’s advantageous to interview with Priority 1 companies after gaining interview experience.

Week 6-8: Coding Test Preparation

Efficient Preparation Method

2-3 hours a day for 3 weeks is enough. Most coding tests reuse a small set of patterns, so the key is focusing on the frequently appearing ones rather than trying to cover everything.

Essential Algorithms (Priority Order)

# 1. HashMap (most common)
# Problem: Two Sum
def twoSum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []
# 2. Two Pointers
# Problem: Two sum in sorted array
def twoSumSorted(nums, target):
    left, right = 0, len(nums) - 1
    while left < right:
        current = nums[left] + nums[right]
        if current == target:
            return [left, right]
        elif current < target:
            left += 1
        else:
            right -= 1
    return []
# 3. Sliding Window
# Problem: Maximum subarray of length k
def maxSubArray(nums, k):
    max_sum = sum(nums[:k])
    current_sum = max_sum
    
    for i in range(k, len(nums)):
        current_sum += nums[i] - nums[i-k]
        max_sum = max(max_sum, current_sum)
    
    return max_sum

Practical Tips

Time Allocation:

  • Week 1: Arrays, HashMap, Strings (basics)
  • Week 2: Two Pointers, Sliding Window, Stack/Queue
  • Week 3: DFS/BFS, DP (basic), Binary Search Platform Recommendations:
  • Baekjoon: Korean companies (Naver, Kakao)
  • LeetCode: Foreign companies (Google, Amazon)
  • Programmers: SMEs, Startups Daily Routine:
09:00-10:00  2 easy problems (warm-up)
10:00-11:30  1-2 medium difficulty
14:00-15:00  1 hard problem (just attempt)
Evening      Review wrong problems

Week 9-10: Technical Interview Preparation

Common Question Types

These are the question types that come up most often.

1. Project Experience

Question: “Explain the most difficult technical problem you faced and how you solved it.” Answer Structure (STAR):

  • Situation: Describe the situation
  • Task: Your role
  • Action: Specific solution method
  • Result: Results (with numbers) Example Answer:
[Situation]
As traffic increased, the payment API response time exceeded 500ms,
leading to increased customer complaints.
[Task]
As a backend developer, I was responsible for performance improvement.
[Action]
1. Identified bottleneck through profiling (DB queries took 80%)
2. Found N+1 query problem → Solved with JOIN
3. Cached frequently queried data in Redis (TTL 5 min)
4. Validated with load testing (Apache JMeter)
[Result]
- Response time: 500ms → 50ms (10x improvement)
- DB load: 70% reduction
- Stably processed 1 billion KRW daily transactions

2. Technical Depth Questions

Question: “Explain the difference between HTTP and HTTPS.” Bad Answer: “HTTPS has better security.” Good Answer:

HTTP is plaintext communication, vulnerable to man-in-the-middle attacks.
HTTPS encrypts with TLS/SSL and guarantees 3 things:
1. Confidentiality: Data encryption (AES-256, etc.)
2. Integrity: Prevents data tampering (HMAC)
3. Authentication: Server identity verification (certificates)
In practice, we get free certificates from Let's Encrypt,
configure SSL in Nginx, and set HSTS headers to force HTTPS redirection.

Tip: Explain in order: concept → how it works → practical experience.

3. Troubleshooting Questions

Question: “How do you respond when a production incident occurs?”

# Incident response process
def handle_production_incident():
    # 1. Immediate response (within 5 min)
    check_monitoring_dashboard()  # Grafana, Datadog
    check_error_logs()            # Sentry, CloudWatch
    check_recent_deployments()    # Check recent deploys
    
    # 2. Temporary measures (within 10 min)
    if is_critical():
        rollback_deployment()     # Rollback to previous version
        notify_team()             # Notify team
    
    # 3. Root cause analysis (within 1 hour)
    analyze_logs()
    reproduce_locally()
    identify_root_cause()
    
    # 4. Permanent fix (same day)
    fix_bug()
    add_tests()
    deploy_fix()
    
    # 5. Post-mortem (within 3 days)
    write_postmortem()
    improve_monitoring()
    prevent_recurrence()

Example answer:

"I got a call at 2 AM because the payment API was down.
Looking at monitoring, the DB connection pool was exhausted,
and I found a bug in recently deployed code that wasn't properly returning connections.
I immediately rolled back to the previous version and restored service in 5 minutes,
then fixed the bug the next day and added connection monitoring alerts.
The same problem hasn't occurred since."

Week 11-12: Interviews and Negotiation

Interview Day Tips

30 Minutes Before Interview:

  • Re-read company homepage, tech blog
  • Re-read your resume (anticipate questions)
  • Drink a glass of water (relax tension) During Interview:
  • For questions you don’t know, honestly say “I’m not sure” (don’t lie)
  • Understand the intent of questions (if stuck, confirm “Do you mean this?”)
  • For whiteboard coding, explain your thought process out loud After Interview:
  • Thank you email same evening (optional but good impression)
  • Record interview questions (prepare for next interview)

Salary Negotiation

Negotiation Timing: When you receive an offer after the final interview Pre-negotiation Preparation:

  1. Research market salary (Wanted, Rocketpunch, Blind)
  2. Your current salary + desired increase rate
  3. Minimum acceptable amount (reject if lower) Negotiation Script Examples:
[When offered amount is low]
"Thank you for the offer.
Considering my experience and tech stack,
I understand the market average is around X.
Would it be possible to adjust to around Y?"
[When you have another offer]
"I received an offer of X from another company,
but I prefer your company.
Could you match a similar level?"
[Salary instead of stock options]
"I prefer increasing base salary over stock options.
Would it be possible to adjust stock options to salary?"

Negotiation Cautions:

  • Don’t ask too high (within market rate +20%)
  • Not aggressive (cooperative attitude)
  • Suggest alternatives (if not salary, remote work, education budget, etc.)

Practical Tips

Interview Preparation Checklist

## Day Before Technical Interview

- [ ] Re-read my project code
- [ ] Skim official docs of frequently used tech stack
- [ ] Read company tech blog
- [ ] Check expected questions list
- [ ] Prepare clothes (business casual)
- [ ] Sleep early (at least 7 hours)
## Interview Day

- [ ] Arrive 30 minutes early
- [ ] Bring laptop, charger (for assignment interviews)
- [ ] 2 printed copies of resume
- [ ] Business cards (if you have)
- [ ] Questions list (for reverse questions)
## After Interview

- [ ] Thank you email (optional)
- [ ] Record interview questions
- [ ] Review weak areas

Common Mistakes

1. Lying on Resume

❌ "Proficient in React" (actually only watched tutorial)
✅ "React basics (TodoList project experience)"

2. Deciding Based Only on Salary

❌ Joined legacy company for 10M KRW more
   → Changed jobs again after 6 months (time wasted)
   
✅ Choose growth-enabling company even with slightly lower salary
   → Better opportunities after 1 year with improved skills

3. Pretending to Know in Interviews

❌ "Kubernetes? Yes, I know it well!" (actually don't know)
   → Can't answer deep questions → Loss of trust
   
✅ "I've used Docker but not Kubernetes yet.
    However, I'm very interested and studying it."

Handling Employment Gap

Under 3 months: No problem. Just say “job hunting preparation period.” 3-6 months: Need to explain what you did during this time

  • “Learning new tech stack (project link)”
  • “Open source contributions (PR link)”
  • “Personal project development (GitHub link)” Over 6 months: Explain honestly
  • “Needed rest due to burnout”
  • “Needed time for family matters”
  • “Attempted startup but closed it” Important: Show that you weren’t completely idle during the gap. GitHub commits, blog posts, online course certificates, etc.

When You Receive Multiple Offers

Create Comparison Table:

| Item | Company A | Company B | Company C | Weight |
|------|-----------|-----------|-----------|--------|
| Salary | 7000 | 8000 | 7500 | x2 |
| Tech Stack | Go, K8s | Java, Spring | Python, Django | x3 |
| Work-Life | 9-6 | 10-7 | 9-6 | x2 |
| Growth | High | Medium | High | x3 |
| Commute | 30min | 1hr | Remote | x1 |
| Team Culture | Good | Average | Good | x2 |
Total: A(85), B(72), C(91) → Choose C

Check Before Deciding:

  • Think about it for 3 days
  • Consult with trusted senior/mentor
  • Write pros and cons list
  • Intuition matters too (feeling during interview)

Truth About Job Changes from Experience

Good Job Change vs Bad Job Change

Good Job Change (My 2nd change):

  • Tech stack: Spring → Go + Kubernetes (desired tech)
  • Salary: 20% increase
  • Work-life: Improved (overtime 3x/week → almost none)
  • Growth: Promoted to senior in 1 year Bad Job Change (My 1st change):
  • Salary: 30% increase (good)
  • Tech stack: Legacy (PHP 5.6, jQuery)
  • Work-life: Worsened (increased overtime)
  • Result: Changed jobs again after 6 months Lesson: Prioritize growth opportunity over salary. When skills improve, salary naturally follows.

Adaptation Tips After Job Change

First 3 Months:

  • Ask many questions (it’s okay to not know)
  • Actively participate in code reviews
  • Understand team culture (lunch, meeting style)
  • Create small achievements (bug fixes, documentation) After 6 Months:
  • Proactively propose projects
  • Tech sharing (internal seminars)
  • Mentoring (help juniors)

Timeline Summary

| Week | Activity | Time Investment |
|------|----------|-----------------|
| 1 | Rest, direction setting | 1-2 hours/day |
| 2-3 | Portfolio refinement | 4-6 hours/day |
| 4-5 | Resume writing, applications | 3-4 hours/day |
| 6-8 | Coding test preparation | 2-3 hours/day |
| 9-10 | Technical interview prep | 3-4 hours/day |
| 11-12 | Interviews, negotiation | 2-3 interviews/week |

Coding Tests

Technical Interviews

Salary Information

What to do after each interview, including the rejections

Several rejections before an offer are normal, and the twelve-week plan above assumes some. What changes the outcome is what you do in the hour after each interview: write down every question you could not answer well, what you actually said, and what a good answer would have contained. Most people find the same two or three gaps repeating — a system design trade-off they cannot explain, a project they describe in terms of tasks instead of decisions and results — and fixing those before the next interview is worth more than another week of general coding-test practice.

If you reach the interview weeks with no interviews booked, the problem is upstream: go back to the resume and portfolio weeks rather than applying to more companies with the same materials.

Frequently Asked Questions (FAQ)

Q. If I have two offers, should I simply take the one with the higher salary?

A. Not automatically. In this guide, the job change with the bigger raise (30%) landed on a legacy PHP 5.6 and jQuery stack with more overtime and led to another move within six months, while the one with a smaller raise (20%) brought the desired tech stack, better work-life balance and a senior promotion. Compare the tech stack, workload and growth path along with the number, and if you prefer the lower offer, you can use the other offer to ask for a similar level.