DevPath
Tracks

Succeeding in Your First Engineering Job

How to ramp up in your first months: a 30-60-90 day plan, asking good questions, working with code review, communicating status, and growing steadily.

beginner35 min#onboarding#career-growth#code-review#communication#mentorship

Prerequisites: Behavioral Interviews and the STAR Method, Git: The Commit Graph, Branches, Merge, and Rebase

Why it matters

Getting the offer is only the start. The first months set your reputation, your learning speed, and your relationships. Most new engineers are not judged on how much they already know; they are judged on how quickly they learn, how well they communicate, and whether they can be trusted with progressively larger work. Knowing what is expected, which is rarely written down, takes much of the stress out.

Intuition

Joining a team is like joining a river already in motion. The codebase has history, the team has habits, and nobody can hand you all of it on day one. The fastest way to become useful is not to prove yourself with a heroic rewrite; it is to understand how things flow, deliver small real contributions early, and make it easy for others to help you. Trust is built from many small reliable interactions.

How it works

The first weeks: orient and ship something small

  • Set up your environment and write down every step that was missing or wrong. Fix the onboarding document: it is a valuable first contribution and shows initiative.
  • Learn the shape of the system. Ask for an architecture overview, read the README and recent pull requests, and trace one request from entry to database.
  • Get a first small change merged quickly: a typo, a small bug, a test. It teaches the whole path from branch to review to deploy, which is half of the job.
  • Meet people. Have short one-on-one conversations with teammates and neighbors on adjacent teams. Ask what they work on and what they wish new people knew.
  • Clarify expectations with your manager: what does success look like in 30, 60, and 90 days? How often will you have one-on-ones? How do they prefer to receive updates?

A 30-60-90 day plan

Treat this as a template to agree with your manager, not a fixed rule.

 Days 1-30   LEARN        environment working, first small PR merged,
                          understand team goals, meet the team
 Days 31-60  CONTRIBUTE   own a small feature or bug area end to end,
                          write tests and docs, give and take review
 Days 61-90  OWN          deliver a medium task with less guidance,
                          share what you learned, propose one improvement
Days 1-30: Learnenvironment, first small PR, meet the team
Days 31-60: Contributeown a small feature or bug area
Days 61-90: Ownmedium task, one improvement
The plan as a timeline. Each phase ends with something concrete that exists, and the next phase builds on it, so independence grows in steps rather than all at once.
OwnDays 61-90: deliver a medium task with less guidance, share what you learned
ContributeDays 31-60: tests, docs, review given and received
LearnDays 1-30: environment, how the system flows, who does what
What you learn builds upward like a stack: you can only own work in a system you first understood and then contributed to. The bottom layer comes first.

At each checkpoint ask your manager for feedback: "What should I do more of? What should I change?"

Asking good questions

Asking for help is expected; asking badly wastes everyone's time and asking never wastes yours.

  1. Try first for a bounded time. Something like 30 to 60 minutes, adjusted to the urgency of the task.
  2. Write the question so it can be answered without a call. State the goal, what you tried, what you expected, what happened (include the error), and your best guess at the cause.
  3. Ask in the right place. Team channels build shared knowledge; direct messages hide it. Search first.
  4. Write down the answer and add it to docs if it was missing.

Example: "I'm trying to run the integration tests locally (goal). I followed the README steps and got a connection refused error on port 5432 (what happened). I think the database container is not running, but docker lists it as healthy (guess). Could you point me to where the test database is configured?"

Code review, both directions

Code review is how teams share knowledge and keep quality up. It is not a verdict on you.

  • As an author: keep changes small, write a description explaining what and why, self-review before requesting, and respond to every comment. If you disagree, explain your reasoning politely; if you agree, make the change. Thank reviewers.
  • As a reviewer: review early and kindly. Ask questions instead of issuing orders, separate required changes from suggestions, and praise good work. New engineers can review too; fresh eyes catch confusing code.
  • Do not take comments personally. The code is being critiqued, not you. A pile of comments on early pull requests is normal.

Communication habits

  • Give regular, short updates. What you did, what is next, what is blocking you. Surface problems early, when they are cheap.
  • Estimate honestly. Break work into pieces, say what you do not know, and give ranges. When it slips, say so as soon as you know, with a revised plan.
  • Write things down. Clear pull request descriptions, design notes, and decision logs help others and your future self.
  • Disagree constructively and then commit to the team's decision.

Growing over time

  • Understand the why behind tasks. Ask how a task connects to users or business goals; it will improve your judgment.
  • Keep a work log of what you shipped, what you learned, and feedback received. It makes performance reviews and future resumes easy.
  • Find a mentor and be specific when asking: "Could we meet monthly for 30 minutes so I can ask about career growth?"
  • Learn the tools deeply: debugger, profiler, the command line, version control, the deployment pipeline. Tool fluency compounds.
  • Take care of yourself. It is normal to feel like you do not know enough, sometimes called impostor syndrome. Most new engineers feel it. Steady learning and honest questions are the cure; burnout is not.

When things go wrong

If you break something, tell your team immediately, help fix it, and follow the team's postmortem process. Healthy teams focus on how the system allowed the mistake, not on blame. How you handle a mistake builds more trust than never making one.

Common pitfalls

  • Staying silent when stuck. Hours of struggle that a five-minute question would solve.
  • Asking without trying, or trying forever. Find the balance with a time limit.
  • Big-bang rewrites. Large unreviewed changes in unfamiliar code are risky. Prefer small steps.
  • Hiding mistakes. Problems found late cost more and cost trust.
  • Not clarifying what done means. Confirm requirements and acceptance criteria before building.
  • Ignoring tests and docs. They are part of the work and often what reviewers check first.
  • Comparing yourself to senior engineers. Compare yourself to your own progress last month.
  • Neglecting relationships. Technical skill alone rarely gets you the interesting projects.

Practice

Draft your 30-60-90 plan medium

Hint

Make each phase concrete: what will exist at the end of it?

Show solution

Write three to four measurable items per phase. For example, by day 30: environment documented, one merged pull request, and a diagram of the main services drawn from memory. By day 60: owned a small bug area including tests. By day 90: delivered a medium feature and proposed one improvement to a team process. Share it with your manager and adjust.

Rewrite a bad help request easy

Hint

Add goal, what you tried, what happened, and your guess.

Show solution

Bad: "The build is broken, can someone help?" Better: "I'm trying to build the web app locally (goal). After pulling main I run the build command and get a missing module error for the config package (what happened). I reinstalled dependencies and cleared the cache (tried). I suspect a version mismatch with my Node setup; which version do we use? (guess)."

Respond to a harsh review comment medium

Hint

Separate tone from content and assume good intent.

Show solution

Comment: "This function is too long, split it." Reply along the lines of: "Good point. I'll extract the validation step into its own function and add a test for it. Is there anything else you'd like separated?" If the comment is unclear, ask a question. If the tone bothers you, raise it privately and calmly after finishing the technical work.

Report a slipping task medium

Hint

Say it early, say why, and bring a plan.

Show solution

Message: "Heads up: the export feature will take about two more days than I estimated. The data format has edge cases I didn't know about. I can deliver the main path by Thursday and the edge cases by Monday, or cut the edge cases from this release. Which do you prefer?" It names the issue, the cause, options, and asks for a decision.

Interview questions

  1. How do you approach joining a new team or codebase? Set up and document the environment, ship a small change early, trace a request through the system, and meet teammates.
  2. How do you ask for help? Try for a bounded time, then ask with context: goal, what you tried, what happened, and a hypothesis.
  3. How do you handle critical feedback in code review? Assume good intent, focus on the content, ask clarifying questions, and make or discuss changes without defensiveness.
  4. Tell me about a time you missed a deadline or made a mistake. Own it, describe how you communicated early and fixed it, and name what you changed afterward.
  5. Where do you want to grow in your first year? Pick specific areas such as testing, system understanding, or design skills, and describe how you would practice them.

Interviewers look for: self-awareness, willingness to learn, communication under uncertainty, and evidence that you take ownership without needing constant direction.

Quick check

You have been stuck on a bug for two hours and the task is due tomorrow. What is the best move?

Finished this lesson?

Further resources

Related lessons