Careers · Interview questions · Junior developers

Junior developer interviews: the eight questions that decide them.

Strip any junior interview to its skeleton and the same eight questions appear - some technical, some behavioural, one entirely new to this era. Here is each one, why it is really being asked, the answer shape that scores, and the mistake that quietly ends rounds. The stack-specific layers get their own guides - JavaScript, React, and SQL - this page is the round that wraps them.

Deric Yee Updated 25 August 2026 11 min read

An interview conversation across laptops

What the whole round is really measuring

Hold one frame through every question below: the junior interview is not measuring how much you know - it is measuring slope and trust. Slope: does the evidence say you learn fast and improve visibly? Trust: can work be handed to you and considered handled - including, now, AI-assisted work you personally stand behind? Every question maps to one of the two. The technical spot-checks sample whether your knowledge has a floor; the project walkthrough tests whether your evidence survives contact; the behavioural stories probe how you behave when stuck, wrong, or reviewed; the AI question tests supervision. Read this way, preparation stops being memorisation and becomes evidence-arrangement - which is why candidates with real built work and real review experience interview so far above their nominal experience level, a dynamic the full 2026 interview guide explores round by round.

The eight questions

1. Tell me about yourself. (The opener that shapes everything after it)

Not an invitation for biography - a 90-second positioning exercise. The structure that works: present (what you build now and the stack), turn (why you moved into development - career-switch stories are an asset when told as decision, not accident), proof (your strongest project in one sentence, with its real user), and direction (what you want to build next, ideally overlapping with their company). Rehearse it aloud until it is smooth but not scripted. The classic failure is chronological life history; interviewers report deciding within this answer whether the rest of the hour feels promising.

2. Walk me through a project you built. (The portfolio deep-dive)

The centrepiece of junior interviews, and the round your projects were built for. Structure the walkthrough as: the problem and who had it, the shape of the solution, one or two technical decisions and their trade-offs ("I chose Postgres over a document store because bookings are relational"), the hardest bug and how you diagnosed it, and what you would improve now. That last part matters: self-critique reads as maturity. Expect interruptions probing whether the work is really yours - naming the exact line where something broke and how you found it is the authenticity signal no AI-generated portfolio can fake.

3. How much of your code does AI write, and how do you make sure it is right?

The 2026 question, asked in some form at nearly every round. The losing answers: "none" (implausible and old-fashioned) and "most of it, it usually works" (vibe-coder confession). The winning shape is a precise workflow: "AI drafts a lot of my first passes; I review everything against the requirement, test edge cases, and nothing ships that I cannot explain line by line - here is a bug it introduced in my project and how I caught it." Employers pay the premium band specifically for this supervision capability, so treat the question as your best scoring opportunity rather than a trap.

4. Tell me about a time you were stuck. What did you do?

A judgement probe wearing behavioural clothes: the interviewer wants your debugging temperament and help-seeking calibration. The strong story has phases: what you tried alone (reading the error properly, isolating the failing piece, checking assumptions), when and how you escalated (timeboxed - "after an hour I asked, with what I had tried written out"), and what you extracted (the pattern you now check first). Avoid both failure modes: the hero story where you never needed anyone (reads as a future silent-struggler) and the instant-escalation story (reads as a future dependency). Teams are hiring your worst afternoon, not your best demo.

5. Why do you want to work here? (And its twin: why should we hire you?)

The preparation question - fifteen minutes of research separates the two candidate types. Reference something real: their product (use it beforehand if humanly possible), their stack (and where yours overlaps), something they published. Then connect it to your direction honestly. For "why you": juniors over-claim skill here, but the winning claim is trajectory plus evidence - "I learn fast and can prove it: three months ago this project didn’t exist" - because hiring managers evaluating juniors are buying slope, not intercept. Never answer either question with salary, commute convenience, or visible indifference; all three end rounds quietly.

6. What happens when you type a URL into a browser? (And other fundamentals spot-checks)

Junior rounds sprinkle quick fundamentals probes - this classic, plus "what is an API", "GET vs POST", "what is Git actually doing" - not for trivia’s sake but to sample whether your knowledge has a floor under it. The URL answer at junior depth: DNS resolves the name to a server, the browser makes an HTTP request, the server responds with HTML, the browser parses it, fetches assets, builds the DOM, runs JavaScript, renders. Practise saying each of these in three calm sentences. The pattern across all spot-checks: confident, brief, and honest about depth limits ("beyond that I’d be guessing") beats bluffing every time - interviewers push exactly one level past wherever you claim to be.

7. How do you handle feedback on your code?

A culture-fit question with a technical face, increasingly common because code review is the daily social ritual of development. The credible answer includes an actual experience: a mentor or reviewer red-lining your work, what it felt like (honesty scores), and what changed in your code afterwards. If your learning path included real code review - a structured programme, an open-source contribution, a collaborator - say so specifically; "I have never had my code reviewed" is among the most common silent gaps in self-taught candidates, and one of the quiet reasons mentor-reviewed learning routes interview better.

8. Do you have any questions for us? (The closer that is also a test)

Always have three, because "no questions" reads as indifference. The ones that serve you doubly - genuine diligence plus quiet signalling: "How does the team use AI tools day to day?" (their answer also tells you whether the engineering culture is current), "What does the first 90 days look like for this role?" (reveals whether onboarding exists), and "What separates juniors who grow fast here?" (the answer is a free roadmap, and asking it signals you intend to be one). Save leave policy and remote-day questions for after the offer exists - legitimate topics, wrong moment.

Putting it together: the two-week run-up

Week one - script and stories:write and rehearse the 90-second opener; prepare the full project walkthrough with its decision points and bug story; collect three behavioural stories (stuck, feedback, shipped under pressure) in the situation-action-outcome shape; and draft your precise AI-workflow answer, because winging question three wastes the round’s best scoring opportunity. Week two - reps: two or three mock interviews (mentor, study partner, community - the first is always rough by design), the stack drills from the JavaScript, React, and SQL guides as your targets require, and company research for each booked round. Then book more interviews than feels comfortable and treat the early ones as reconnaissance.

And the honest foundation note, because interview technique has a ceiling: every answer shape above assumes there is real work underneath - a defensible project, genuine fundamentals, an actual AI workflow. If that layer is the gap, close it first; it is months, not years (the full path), it starts free at the free trial, and the market pays the RM 6,000–9,000 band documented in the hiring report to the juniors who did. Our graduates rehearse this exact round in defence interviews before they ever face a real one - because the market tests it, we train it.

FAQ

What should I expect in a junior developer interview in Malaysia?
The common shape at startups and SMEs (most of the market): a screening call testing communication and motivation, a technical round (increasingly live building or code walkthrough rather than whiteboard algorithms), a portfolio deep-dive (the centrepiece for juniors), and an offer conversation - with AI-collaboration probes now woven through the technical stages. Larger companies and banks add aptitude tests and panel layers. The eight questions on this page cover the recurring content across all of them; the stack-specific layers (JavaScript, React, SQL) have their own dedicated question guides linked throughout.
How do I prepare when I have no interview experience at all?
Treat interviewing as a skill with reps, not a judgement day. The sequence: rehearse the tell-me-about-yourself and project walkthrough aloud until smooth (they are the two highest-frequency questions and fully preparable); do 2-3 mock interviews with a mentor, study partner, or community member - the first mock is always rough, which is exactly why it should not be a real company; then book real interviews expecting the first few to be calibration, logging every question asked and patching gaps between rounds. Most people convert somewhere between interview three and ten - a normal curve, not a verdict.
What are the most common mistakes juniors make in interviews?
Five dominate, all avoidable: rambling openers (fix: the rehearsed 90-second structure); portfolio answers that collapse under one follow-up (fix: only show work you can defend line by line); bluffing past knowledge limits (interviewers probe one level past your claim - honest boundaries score better); zero questions for the interviewer (reads as indifference); and hiding or mishandling the AI question - either denying use or revealing dependence. A quieter sixth: applying only through job boards and treating each interview as pass/fail rather than as reconnaissance for the next one.
Do junior interviews in 2026 still include algorithm/LeetCode rounds?
A shrinking minority in the Malaysian startup/SME market - most have shifted to practical rounds (build a small feature, review this code, walk through your project) because those predict job performance better and are harder to game with AI. But some larger companies, banks, and international employers still run algorithm screens, so check per company (Glassdoor reports, community intel) and calibrate: if your targets include those, drill the basic patterns (arrays, strings, maps, simple recursion) for two weeks; if not, that time compounds better in your portfolio - which every interviewer weighs.

Back to all posts After the offer: your first 90 days →

Interviews measure slope. Build yours.
Defence interviews are part of the training here.

Real projects, mentor review, and rehearsed defence of your own decisions - because that is what the market tests. The free first week: six projects, a live instructor session, one signup, no card.

Start the free trial The no-experience playbook