Junior developer first week: onboarding and what to do
Your junior developer first week: map the 60-day probation, check your machine, run the project, send a first small change and keep an end-of-day log.
The goal of a junior developer's first week is not to impress people. It is to get the project running, understand how the team works, send one small first change and write down what you do not understand yet. Have you ever pictured your first day at work? Let's walk through the first week of Minh.
First day at work: what do I need to achieve?
In the previous episode of this series, Minh negotiated the offer from company A and then signed an adjusted letter: 11 million Vietnamese đồng per month (roughly US$420), a probation at 90% of the salary, ending on 29 January 2027. Minh is an illustrative character of this series, so every name, date and number in the post is illustrative. The first day of work is Tuesday, 1 December 2026, with a mentor for the first two months (Phúc, also an illustrative character).
The first thing I suggested Minh do, even before opening the laptop, is to look at the probation period as a map. Sixty days sounds long, but calendar days and working days are two different things. The script below works out which date is day N of the probation, which weekday it falls on, and how many real working days there are (not counting Saturdays, Sundays and public holidays). In this range there is only one public holiday, New Year's Day on 1 January. You need Node.js 22.18 or newer (Node runs .ts files directly from that version) and nothing else to install.
// A map of the probation period: which date is which day, which weekday, and how many real working days there are.
// Run: node time-map.ts
// The start and end dates come from the adjusted offer letter of the previous episode (illustrative): 01/12/2026 to 29/01/2027 (60 days).
// Holidays: only the public holidays that fall inside this probation period are listed (New Year's Day, 01/01).
export const HOLIDAYS = new Set(["2027-01-01"]);
const WEEKDAY = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
const ONE_DAY = 86_400_000;
// Use UTC for every date calculation, so the result does not change with the time zone of the machine.
const addDays = (date: string, days: number) => new Date(Date.parse(`${date}T00:00:00Z`) + days * ONE_DAY).toISOString().slice(0, 10);
const weekdayOf = (date: string) => new Date(`${date}T00:00:00Z`).getUTCDay();
const format = (date: string) => `${date.slice(8)}/${date.slice(5, 7)}/${date.slice(0, 4)}`;
// Day number N of the probation period (N = 1 is the start date).
export function dayN(start: string, n: number): string {
return addDays(start, n - 1);
}
export function isWorkingDay(date: string): boolean {
const weekday = weekdayOf(date);
return weekday !== 0 && weekday !== 6 && !HOLIDAYS.has(date);
}
// Number of working days (not counting Saturday, Sunday and holidays) from the start date to the end date, both ends included.
export function countWorkingDays(start: string, end: string): number {
const total = Math.round((Date.parse(end) - Date.parse(start)) / ONE_DAY) + 1;
return Array.from({ length: total }, (_, i) => addDays(start, i)).filter(isWorkingDay).length;
}
export type Milestone = { dayNumber: number; what: string };
export function printMap(start: string, end: string, milestones: Milestone[]): string[] {
const lines = milestones.map((milestone) => {
const date = dayN(start, milestone.dayNumber);
const note = isWorkingDay(date) ? "" : " <- not a working day, move it to the next working day";
return `Day ${String(milestone.dayNumber).padStart(2)}: ${format(date)} (${WEEKDAY[weekdayOf(date)]}) — ${milestone.what}${note}`;
});
const totalDays = Math.round((Date.parse(end) - Date.parse(start)) / ONE_DAY) + 1;
lines.push(`Total: ${totalDays} calendar days, of which ${countWorkingDays(start, end)} are working days (without Saturdays, Sundays and the 01/01 holiday).`);
return lines;
}
if (import.meta.main) {
const milestones: Milestone[] = [
{ dayNumber: 1, what: "first day: laptop, accounts, meet the mentor" },
{ dayNumber: 3, what: "goal: the project runs on my machine" },
{ dayNumber: 8, what: "goal: first small pull request" },
{ dayNumber: 30, what: "ask the mentor for mid-term feedback" },
{ dayNumber: 60, what: "end of probation" },
];
for (const line of printMap("2026-12-01", "2027-01-29", milestones)) console.log(line);
}I use UTC for every date calculation so the result does not change with the time zone of the machine (a lesson from the story of the expense at 6:30 a.m. on 1 December being counted in November when a server ran in UTC, in the interview preparation post). You run:
node time-map.tsDay 1: 01/12/2026 (Tuesday) — first day: laptop, accounts, meet the mentor
Day 3: 03/12/2026 (Thursday) — goal: the project runs on my machine
Day 8: 08/12/2026 (Tuesday) — goal: first small pull request
Day 30: 30/12/2026 (Wednesday) — ask the mentor for mid-term feedback
Day 60: 29/01/2027 (Friday) — end of probation
Total: 60 calendar days, of which 43 are working days (without Saturdays, Sundays and the 01/01 holiday).The number worth remembering is on the last line: sixty calendar days but only forty-three working days. When Minh thinks "I have two months to prove myself", the reality is less than nine working weeks, and one of them is a week at the end of the year. This is not meant to scare, but to help Minh set goals of the right size. The three milestones I suggest are: day 3 for a working environment, day 8 for the first small pull request, and day 30 for a mid-term feedback meeting with Phúc. All three are my suggestions, not the rules of any company, and you should ask your own mentor which milestones they expect.
There is one more line in the new letter of Minh: the salary will be reviewed on 1 March 2027, a little over a month after probation ends. That date is outside the map above, but it gives Minh a reason to write down what they achieve from the very first day: by that date, Minh needs to be able to say what they contributed with concrete facts, not with feelings.
Is the machine ready to work?
Most of the first days are lost to setup. The company may have prepared a laptop, or you may need to install the tools yourself, and the guides usually exist but are often missing a step the first time you run them. Before you start, you can check a few very common things: is it the right Node.js version, is Git installed, does Git know who you are (a name and an email, because every commit carries both), and is there an SSH key to connect to the code repository. This script runs those checks and prints only ✓ or ✗. I deliberately do not print the name or email on the screen, because it is easy to paste the result into a chat asking for help without noticing that it contains personal information:
// Check whether the machine is ready for work: the tools, the Git identity, the SSH key. It only prints ✓ or ✗, never personal values.
// Run: node check-machine.ts
import { execFileSync } from "node:child_process";
import { existsSync, readdirSync } from "node:fs";
import { homedir } from "node:os";
import { join } from "node:path";
export type Check = { name: string; run: () => boolean; hint: string };
const exec = (command: string, args: string[]): string => execFileSync(command, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
const attempt = (f: () => boolean) => () => {
try {
return f();
} catch {
return false;
}
};
export const CHECKS: Check[] = [
{ name: "Node.js 22.18 or newer", run: attempt(() => { const [major, minor] = process.versions.node.split(".").map(Number); return major > 22 || (major === 22 && minor >= 18); }), hint: "Install the Node.js version the project asks for (see the README or .nvmrc)" },
{ name: "Git is installed", run: attempt(() => exec("git", ["--version"]).startsWith("git version")), hint: "Install Git, then reopen the terminal" },
{ name: "Git has a user name", run: attempt(() => exec("git", ["config", "user.name"]).length > 0), hint: 'git config --global user.name "Your Name"' },
{ name: "Git has an email", run: attempt(() => exec("git", ["config", "user.email"]).includes("@")), hint: 'git config --global user.email "your-work-email"' },
{ name: "An SSH key exists", run: attempt(() => { const folder = join(homedir(), ".ssh"); return existsSync(folder) && readdirSync(folder).some((name) => /^id_(ed25519|rsa|ecdsa)$/.test(name)); }), hint: "Create a key with ssh-keygen, then send the public key (.pub) to whoever manages the accounts" },
];
export function runChecks(checks: Check[]): { mark: string; name: string; hint?: string }[] {
return checks.map((check) => (check.run() ? { mark: "✓", name: check.name } : { mark: "✗", name: check.name, hint: check.hint }));
}
if (import.meta.main) {
const results = runChecks(CHECKS);
for (const item of results) console.log(`${item.mark} ${item.name}${item.hint ? `\n hint: ${item.hint}` : ""}`);
console.log(`\n${results.filter((r) => r.mark === "✓").length}/${results.length} items ready`);
}node check-machine.ts✓ Node.js 22.18 or newer
✓ Git is installed
✓ Git has a user name
✓ Git has an email
✓ An SSH key exists
5/5 items readyOn my machine all five items pass, so you do not see the hint part. When an item fails, the script prints one more "hint" line under it. That part is covered by a test in which I replace the real checks with two fake ones, one that passes and one that fails, and then assert that the result has a ✗ with its hint. This list is a starting point, not a complete one. A company project has its own things too: a database version, a network port that must be free, an environment variable file. For those, do not guess: ask your mentor, or read the README and write down every place where the README does not match reality. That is a gift to the whole team, and in the next section I explain why it is also a very good first task.
Three jobs for the first week
"First week" articles that I have read (one on DEV Community is an example) usually mention the same few ideas: get to know your teammates, understand the code and the tools, understand the working process of the team, and do not be afraid to ask questions. I boil them down to three jobs, and for each one I say why.
The first job is to get the project running on your machine and write down every place where you stumble. You do not need to understand all the code yet. You only need to get it running, and to have a list of the places where the README is wrong or incomplete. I put this first for a reason: if you get stuck at the installation step, nobody can judge you on anything else, and the stumbling points of a newcomer are something that old hands can no longer see.
The second job is to understand how the team works before you understand the code. How does the team name branches, how many people must approve a pull request, which automated checks (CI) must be green before merging, and when is merging allowed. For Minh this is not completely new knowledge, because Minh went through it in the posts on branches and pull requests and on receiving a code review. But every team has its own variant, and the fastest way to learn that variant is to read the recently closed pull requests: see who reviews, which comments repeat, and what a good pull request looks like here.
The third job is to send one small change within the first few days. I think the first task should be small to the point of boring: fix a typo in the docs, update a README step that Minh just found to be wrong, or a small bug that the mentor has picked in advance. The reason: the first task teaches you the process, not the code. You learn how to create a branch, write the pull request description, wait for the automated checks, receive a review and merge. If the first task is big and hard, you learn the process under the pressure of a hard problem, and every small mistake in the process gets mixed with the mistakes of the problem. For Minh, a README fix coming from the list of stumbling points of the first job is a good candidate: it is small, it has real value, and Minh is the person who understands it best.
An end-of-day log
This is the small habit that I find most worthwhile. At the end of each day, Minh spends five minutes writing down four things: what I got done today, what I did not understand, what I tried for each thing I did not understand, and what I will do tomorrow. Here is the template, with an illustrative day (Minh's day 2):
# Work log (template)
One page per day, written in the last 5 minutes of the day.
## 02/12/2026 (day 2)
**Done today**
- Finished setting up the project, got `npm run dev` working after fixing a missing environment variable.
**Not understood yet (not asked yet)**
- Why do the `features/` and `components/` folders both have a button file?
- What is the branch naming convention of the team?
**Tried before asking** (fill in when you turn an item above into a question)
- Read the README and searched `docs/`; searched for "branch" in the history of pull requests.
**Tomorrow**
- Ask Phúc the two questions above at 10:00; take the first small task.There are two details in the template that I want you to notice. The heading "not understood yet (not asked yet)" means you write the question down but do not ask right away, because many questions answer themselves after an afternoon of reading on, and the rest become clearer when you put them in writing. The section "tried before asking" is there so that when you go to Phúc, you can say "I read the README and searched the docs, and I still do not understand this part", instead of "I do not understand this". The second sentence costs the listener far less effort, and shows that you respect their time. How to ask so you get answered quickly without being a bother is the topic of the next post, but this log is the preparation.
I will also be direct: I have no data that proves a log makes you learn faster. It is a habit that I find reasonable, and it is cheap: five minutes a day. If after two weeks it feels useless, drop it.
Tests for the small tools
I wrote six tests for the two scripts: day N is right (day 1 is the start date, day 60 is 29 January 2027), Saturday, Sunday and 1 January are not working days, these 60 calendar days contain exactly 43 working days, a full week has 5 working days, a milestone that falls on a weekend is marked, and the result part of the machine check. They run with the test runner that ships with Node, so there is nothing to install:
node --test tools.test.ts# tests 6
# pass 6
# fail 0Of the six tests, the most valuable is the one that counts working days, because 43 is an easy number to get wrong by hand, especially if you forget a holiday in the middle of the period. You can write the tests yourself from the rules above, because every function is small.
You are stuck, but too shy to ask
At the end of the first week, Minh has the project running, has sent a small pull request about the README, and has a three-page log. But on the fifth day a strange error appears when Minh runs the automated checks, and Minh loses almost a whole afternoon digging alone without asking anyone, because Minh does not want to bother Phúc and is afraid of looking not good enough. When to ask, how to ask so you get answered quickly, and why losing a whole afternoon is not diligence are the subjects of the next posts.
You can follow the whole journey in the series A junior's journey. If you want more practice, the question tell me about yourself in one minute and the others are in the interview question bank.