
I’ve gone through a lot of frontend loops myself, and through FrontendLead I’ve talked to hundreds of engineers about how their interviews went, including interviewers. One pattern keeps coming up: most candidates who don’t pass aren’t failing because they didn’t know an answer.
They fail because of a handful of repeat mistakes that have nothing to do with how smart they are. Here are the ones I see most, round by round, and how to avoid them.

JavaScript coding rounds
1. Coding before clarifying
The candidate reads “implement debounce” and starts typing immediately. Ten minutes later, the interviewer asks “should it support a leading-edge call?” and half the code needs to change.
Do this instead: spend 2-3 minutes asking about inputs, outputs, and edge cases. Write a couple of example calls with expected results. It feels slow, but it saves time, and interviewers explicitly look for it.
2. Only handling the happy path
The code works for the example and breaks on an empty array, a rejected promise, or a function called with a different this.
Do this instead: once your solution works, say “let me check some edge cases” and run through them out loud. Empty input, a single item, errors, and repeated calls.
3. Going silent
Ten minutes of silent typing makes interviewers nervous, even if your code is perfect. They can’t give you credit for reasoning they can’t hear, and they can’t nudge you if you’re heading the wrong way.
Do this instead: narrate at a high level. “I’m going to store the timer in a closure so each call can clear the previous one.” You don’t need to read your code out loud, just your decisions.
4. Not testing at the end
Do this instead: when you’re done, ask if you can call your function with a few inputs. Even without a test runner, walking through a quick example often catches a bug before the interviewer does.
UI / app building rounds
5. Ignoring accessibility
Using div with an onClick instead of a button, no labels, no keyboard support. Many interviewers consider this a real signal, especially at larger companies.
Do this instead: use semantic HTML by default, and spend two minutes at the end on the accessibility checklist. Even mentioning what you’d add if you had more time helps.
6. One giant component
Everything in a 200-line App component. It works, but it doesn’t show how you’d build something maintainable.
Do this instead: split out components and logic where it’s natural, like a custom hook for fetching. Don’t over-engineer either; a couple of clean pieces is plenty.
7. Forgetting loading, error, and empty states
The happy path renders. But what does the user see while it loads, if the request fails, or if there are no results?
Do this instead: handle all three, even with simple text. It shows you’ve shipped real products.
8. Fighting CSS for 15 minutes
Spending a third of the round making something pixel-perfect when the interviewer cared about the logic.
Do this instead: ask how much styling matters. Usually “make it functional, basic layout is fine” is the answer. Get it working first, then polish.
System design rounds
9. Jumping straight to boxes
Drawing a component tree in minute one without agreeing on requirements. Half the design ends up solving the wrong problem.
Do this instead: start with functional requirements, non-functional requirements, and what’s out of scope. My full approach is in my frontend system design framework.
10. Turning it into a backend interview
Twenty minutes on database sharding and load balancers in a frontend round. That’s time not spent on what’s actually being graded.
Do this instead: define the API contract you need from the server and move on. Spend your time on components, state, data model, performance, and accessibility.
11. Making choices without trade-offs
“I’ll use server-side rendering.” Why? What does it cost? What are the alternatives?
Do this instead: every significant decision should come with a short “because” and a “the downside is”. That’s the core signal for seniority.
Behavioral rounds
12. Saying “we” the whole time
The interviewer finishes the story without knowing what the candidate actually did.
Do this instead: use “I” for your actions, and end with a concrete result. I explain how to prepare stories in building a behavioral story bank.
Mistakes before the interview even starts
- Interviewing at your dream company first. Do a few warm-up interviews at companies you care less about. The first loop is always the roughest.
- Memorizing solutions instead of understanding them. Interviewers almost always change the question slightly. If you memorized it, you’re stuck.
- Not asking what the rounds are. Preparing for algorithms when the loop is all UI building (or the other way around) wastes weeks.
- Burning out. Cramming 10 hours a day for two weeks usually performs worse than 2 focused hours a day for two months.
A quick summary
| Round | The one habit that fixes most mistakes |
|---|---|
| JavaScript coding | Clarify first, test at the end, talk throughout |
| UI build | Working first, then states, then accessibility |
| System design | Requirements first, trade-offs for every choice |
| Behavioral | “I” plus a measurable result |
The best way to catch these habits is practice under realistic conditions. Use a timer, talk out loud, and practice in an editor with real tests, like the FrontendLead coding questions. Doing a mock with a friend is even better.
And that’s it, folks. None of these mistakes are about intelligence. They’re habits, and habits can be practiced. Fix them before your interview and you’ll show what you actually know.
