Study guide

Preparation

86 curated tips

Short, actionable reminders to use between timed quizzes. For longer study plans and topic overviews, see the guides.

All

Study plan
Study in blocks, not marathons
45–60 minute focused sessions with 10-minute breaks beat 6-hour cramming. Your brain consolidates during rest.
Study plan
Active recall beats re-reading
Close the notes and try to answer questions from memory. Quizzes in this app are built for exactly that.
Study plan
Review wrong answers twice
After each quiz, read every explanation — especially questions you guessed right. Luck does not scale.
Study plan
Rotate tracks daily
Mon HTML, Tue CSS, Wed React, Thu Frontend general. Mixing topics mirrors real tests and reduces fatigue.
Study plan
Start beginner, climb levels
Do not jump to Advanced until you score 80%+ on Intermediate. Gaps in basics will haunt you under time pressure.
Study plan
Timed practice weekly
Use the 4-minute quiz timer at least twice a week. Untimed study and timed performance are different skills.
Study plan
Build a cheat sheet by hand
One page: selectors, flex shorthand, array methods, React hooks rules. Writing it once = remembering it in the test.
Study plan
Explain out loud
Teach box model or useEffect to an imaginary junior. If you cannot explain it simply, you do not know it yet.
Study plan
Sleep before the test
7–8 hours. Sleep deprivation cuts recall by 20–40%. No all-nighter the night before.
Study plan
Two weeks minimum
Ideal prep: 2–4 weeks. Week 1 foundations, Week 2 timed quizzes + weak spots, final days light review only.
HTML
Semantic tags are high-value
Know <article>, <section>, <nav>, <main>, <aside>, <header>, <footer> and when each is appropriate.
HTML
One <h1> per page
Heading hierarchy matters for accessibility and SEO. Never skip levels (h1 → h3) without reason.
HTML
Form attributes save JavaScript
required, type="email", minlength, pattern, autocomplete — know what the browser validates natively.
HTML
alt is not optional
Decorative images: alt="". Informative images: descriptive alt. Tests love this distinction.
HTML
Block vs inline vs inline-block
Block takes full width. Inline flows with text. Inline-block combines both — common in UI patterns.
HTML
data-* attributes
Use data-id="123" for JS hooks without polluting classes. Accessible via dataset.id in JavaScript.
HTML
defer vs async on scripts
defer: runs after HTML parse, order preserved. async: runs when ready, order not guaranteed.
HTML
label + input pairing
Wrap input in <label> or use for/id. Clicking label focuses input — required for accessible forms.
HTML
Void elements
<img>, <br>, <input>, <meta> have no closing tag. Do not write <img></img> in HTML5.
HTML
picture vs img
Use <picture> with <source> for art direction or format switching (WebP fallback). img alone is simpler.
CSS
Box model: content-box vs border-box
border-box includes padding and border in width. Most resets set * { box-sizing: border-box } for a reason.
CSS
Specificity order
Inline > IDs > classes/attributes/pseudo-classes > elements. !important overrides everything (avoid in real code).
CSS
Flexbox main vs cross axis
flex-direction sets main axis. justify-content aligns main, align-items aligns cross. Draw it once — never forget.
CSS
Grid fr unit
grid-template-columns: 1fr 2fr means second column is twice the first. fr splits remaining space.
CSS
Position sticky needs a threshold
top: 0 plus a scrollable ancestor. Without top/bottom/left/right, sticky does nothing.
CSS
rem vs em vs px
rem = root font size (scalable). em = parent font size (compounds). px = fixed. Prefer rem for spacing.
CSS
CSS variables cascade
Define on :root, override on [data-theme="dark"]. Components use var(--accent) — never hardcode colors.
CSS
Mobile-first media queries
min-width: 768px means styles apply from 768px up. Start small, enhance for larger screens.
CSS
Pseudo-classes vs pseudo-elements
:hover is a class on state. ::before creates a virtual element. Double colon for elements is modern standard.
CSS
z-index stacking contexts
z-index only compares within the same stacking context. position + z-index on parent creates a new one.
CSS
Centering cheat code
Flex: display flex + justify-content center + align-items center. Grid: place-items center. Know both.
CSS
transition vs animation
transition reacts to property changes (hover). @keyframes animation runs a timeline independently.
JavaScript
=== over ==
Strict equality avoids coercion surprises. null == undefined is true; null === undefined is false.
JavaScript
const does not mean immutable
const blocks rebinding, not mutation. const arr = []; arr.push(1) is valid.
JavaScript
map vs forEach vs filter
map returns new array. forEach returns undefined. filter returns subset matching condition.
JavaScript
Async: promises then vs async/await
await pauses inside async function until promise resolves. Always handle rejections with try/catch or .catch().
JavaScript
Closures in one sentence
Inner function remembers variables from outer scope even after outer function finished executing.
JavaScript
Event bubbling vs capturing
Bubbling: child → parent. Capturing: parent → child. addEventListener third arg true enables capture phase.
JavaScript
JSON.parse vs eval
Never eval user input. JSON.parse is safe for JSON strings only — throws on invalid JSON.
JavaScript
Spread vs rest
Spread expands: [...arr]. Rest collects: function fn(...args). Same syntax, opposite direction.
JavaScript
Truthy and falsy list
Falsy: false, 0, "", null, undefined, NaN. Everything else is truthy — including [] and {}.
JavaScript
fetch does not reject on 404
fetch only rejects on network failure. Check response.ok or response.status manually.
JavaScript
localStorage vs sessionStorage
localStorage persists until cleared. sessionStorage clears when tab closes. Both store strings only.
JavaScript
Hoisting basics
function declarations hoist fully. let/const hoist but stay in temporal dead zone until declared.
React
Props flow down, events flow up
Parent passes data via props. Child notifies parent via callback props like onSubmit.
React
Keys in lists
Use stable unique ids, not array index when list can reorder. Keys help React match items correctly.
React
State updates are async
setCount(count + 1) twice in same tick may not add 2. Use functional form: setCount(c => c + 1).
React
useEffect dependency array
[] = run once on mount. [value] = run when value changes. No array = every render (usually a bug).
React
Do not mutate state
Always create new object/array when updating. state.items.push(x) then setState(state) will not re-render reliably.
React
Conditional render patterns
condition && <Component />, ternary for either/or, early return for loading states.
React
Controlled vs uncontrolled inputs
Controlled: value + onChange tied to state. Uncontrolled: ref reads DOM directly. Forms usually controlled.
React
Context is not a state manager
Good for theme, locale, auth. Bad for every piece of data — causes unnecessary re-renders.
React
Fragments avoid extra DOM
<></> or <Fragment> wrap siblings without adding a div. Useful for table rows or strict layouts.
React
Lifting state up
When two siblings need same data, move state to closest common parent and pass props down.
React
Rules of Hooks
Only call hooks at top level of function components. Never inside loops, conditions, or nested functions.
React
useRef vs useState
useRef persists without re-render. useState triggers re-render on change. Refs for DOM access and timers.
Test day
Read the full question first
MCQ traps hide in words like "NOT", "always", "except". Underline negations before looking at options.
Test day
Eliminate wrong answers
Cross out two obviously wrong options. Your odds jump from 25% to 50% even when guessing.
Test day
Flag and move on
Stuck more than 30 seconds? Pick best guess, mark mentally, return if time remains. Momentum matters.
Test day
Watch the global timer
20 questions in 4 minutes = ~12 seconds each average. Do not spend 2 minutes on one hard question early.
Test day
First instinct is often right
Unless you have a clear reason to change, trust your initial answer. Second-guessing causes more errors.
Test day
Check browser and environment
Before starting: stable internet, quiet room, charged device, notifications off. Reduce avoidable stress.
Test day
Answer every question
No penalty for wrong answers? Never leave blanks. An educated guess beats an empty slot.
Test day
Code snippets: trace line by line
For "what prints?" questions, write values on paper step by step. Do not simulate in your head.
Test day
Arrive 10 minutes early
Login issues, platform quirks, ID checks — buffer time prevents panic before the clock starts.
Test day
Hydrate, light snack
Water and a banana or nuts. Blood sugar crashes mid-test destroy focus faster than hard questions.
Mindset
Progress over perfection
60% today beats 0% waiting until you feel ready. Consistency compounds over two weeks.
Mindset
Failure is data
A wrong quiz answer tells you exactly what to study next. Treat mistakes as a free study guide.
Mindset
Compare to yesterday you
Someone always knows more. Your only competition is your score from last Tuesday.
Mindset
Imposter feelings are normal
Most candidates feel underprepared. Preparation reduces anxiety — action reduces imposter syndrome.
Mindset
Breathe before you begin
Three slow breaths before clicking start. Calm nervous system = clearer recall under pressure.
Mindset
You do not need 100%
Many hiring tests pass at 70–80%. Aim for solid pass, not flawless. Perfectionism wastes energy.
Mindset
Celebrate small wins
First 80% quiz? That deserves acknowledgment. Positive reinforcement keeps you studying.
Mindset
Take breaks guilt-free
Rest is part of preparation, not laziness. Walk, stretch, look away from screens between blocks.
Mindset
One bad quiz ≠ failure
Variance is normal. Look at trend over 5 quizzes, not a single bad run after a long day.
Mindset
Show your work in practice
When practicing coding questions, write pseudocode even for MCQ. Builds the habit for live coding rounds.
Study plan
DevTools is your friend
Inspect element, Console, Network tab — know them before the test. Many frontend roles expect fluency.
JavaScript
CORS in one line
Browser blocks JS from reading cross-origin responses unless server sends Access-Control-Allow-Origin.
HTML
Accessibility: focus states
Keyboard users need visible :focus-visible outlines. Never remove focus styles without a replacement.
CSS
BEM naming optional but useful
block__element--modifier clarifies structure. Tests may ask about naming conventions and specificity.
React
Virtual DOM concept
React diffs new virtual tree vs old, updates only changed real DOM nodes. Explains why keys matter.
Test day
Similar options = trap
When two answers look almost identical, compare them word by word. The difference is usually the point.
Study plan
MDN over random blogs
When in doubt, verify on developer.mozilla.org. Official docs beat outdated tutorial sites.
JavaScript
Event loop mental model
Call stack runs sync code. Web APIs handle async. Callback queue feeds stack when empty. Know micro vs macrotask basics.
CSS
Cascade layers (@layer)
Modern CSS lets you control cascade order explicitly. Useful in large codebases — may appear in senior tests.
Mindset
Visualize success briefly
30 seconds imagining finishing calmly. Sports psychology works for exams too — reduces cortisol spike.

Preparation

Study in blocks, not marathons

Active recall beats re-reading

Review wrong answers twice

Rotate tracks daily

Start beginner, climb levels

Timed practice weekly

Build a cheat sheet by hand

Explain out loud

Sleep before the test

Two weeks minimum

Semantic tags are high-value

One <h1> per page

Form attributes save JavaScript

alt is not optional

Block vs inline vs inline-block

data-* attributes

defer vs async on scripts

label + input pairing

Void elements

picture vs img

Box model: content-box vs border-box

Specificity order

Flexbox main vs cross axis

Grid fr unit

Position sticky needs a threshold

rem vs em vs px

CSS variables cascade

Mobile-first media queries

Pseudo-classes vs pseudo-elements

z-index stacking contexts

Centering cheat code

transition vs animation

=== over ==

const does not mean immutable

map vs forEach vs filter

Async: promises then vs async/await

Closures in one sentence

Event bubbling vs capturing

JSON.parse vs eval

Spread vs rest

Truthy and falsy list

fetch does not reject on 404

localStorage vs sessionStorage

Hoisting basics

Props flow down, events flow up

Keys in lists

State updates are async

useEffect dependency array

Do not mutate state

Conditional render patterns

Controlled vs uncontrolled inputs

Context is not a state manager

Fragments avoid extra DOM

Lifting state up

Rules of Hooks

useRef vs useState

Read the full question first

Eliminate wrong answers

Flag and move on

Watch the global timer

First instinct is often right

Check browser and environment

Answer every question

Code snippets: trace line by line

Arrive 10 minutes early

Hydrate, light snack

Progress over perfection

Failure is data

Compare to yesterday you

Imposter feelings are normal

Breathe before you begin

You do not need 100%

Celebrate small wins

Take breaks guilt-free

One bad quiz ≠ failure

Show your work in practice

DevTools is your friend

CORS in one line

Accessibility: focus states