What Interviewers Actually Look for in a Fresher Full Stack Developer

console.log('A');

setTimeout(() => console.log('B'), 0);

Promise.resolve().then(() => console.log('C'));

(async () => {
  console.log('D');
  await null;
  console.log('E');
})();

console.log('F');

// Output: A D F C E B
// A, D, F run synchronously on the call stack.
// C and E are microtasks (promise callbacks),
// so they run before B, which is a timer task.

const orders = [
  { id: 1, status: 'PAID',    total: 450 },
  { id: 2, status: 'PENDING', total: 120 },
  { id: 3, status: 'PAID',    total: 900 }
];

// Total revenue from paid orders
const revenue = orders
  .filter(o => o.status === 'PAID')
  .reduce((sum, o) => sum + o.total, 0);

console.log(revenue); // 1350

// IDs of pending orders
const pendingIds = orders
  .filter(o => o.status === 'PENDING')
  .map(o => o.id);

console.log(pendingIds); // [2]

-- Tables: users(id, name), notes(id, user_id, title, created_at)

-- Every user with their note count,
-- including users who have no notes yet
SELECT u.id, u.name, COUNT(n.id) AS note_count
FROM users u
LEFT JOIN notes n ON n.user_id = u.id
GROUP BY u.id, u.name
ORDER BY note_count DESC;

-- Why COUNT(n.id) and not COUNT(*)?
-- With LEFT JOIN, a user with no notes still gets
-- one row with NULL note columns. COUNT(*) would
-- count that row as 1. COUNT(n.id) ignores NULLs
-- and correctly gives 0.

router.post('/api/notes', requireAuth, async (req, res, next) => {
  try {
    const title = (req.body.title || '').trim();
    if (!title) {
      return res.status(400).json({ error: 'Title is required' });
    }
    const { rows } = await pool.query(
      'INSERT INTO notes (user_id, title) VALUES ($1, $2) RETURNING id, title, created_at',
      [req.user.id, title]
    );
    res.status(201).json(rows[0]);
  } catch (err) {
    next(err);
  }
});

// $1 and $2 are parameters, so user input is
// never pasted into the SQL string. That is what
// prevents SQL injection.

// Interviewer: this crashes with
// 'TypeError: res.json is not a function'. Find the bug.
async function showUser(id) {
  const res = fetch(`/api/users/${id}`);
  const user = res.json();
  console.log(user.name);
}

// Step 1: read the error aloud. res.json is missing.
// Step 2: fetch returns a Promise, not a Response,
//         and nothing awaits it, so res is a Promise.
// Step 3: res.json() would also return a Promise,
//         so user.name would be undefined next.
// Step 4: fix by awaiting both calls.

async function showUser(id) {
  const res = await fetch(`/api/users/${id}`);
  if (!res.ok) {
    throw new Error(`Request failed: ${res.status}`);
  }
  const user = await res.json();
  console.log(user.name);
  return user;
}

// What I say while fixing:
// "Both fetch and res.json return promises,
//  so I need await on each. I also check res.ok,
//  because fetch does not throw on 404 or 500,
//  only on network errors."

CAN I DO THIS WITHOUT NOTES?

[ ] Explain closures with my own example
[ ] Predict setTimeout vs promise output order
[ ] Explain let, const and var differences
[ ] Use map, filter and reduce on objects
[ ] Write async/await with try/catch
[ ] Explain == vs === with an example
[ ] Explain what 'this' is in an arrow function
[ ] Destructure objects and use spread

CAN I DO THIS WITHOUT NOTES?

[ ] Choose methods and status codes for CRUD
[ ] Explain what CORS is and why it blocks requests
[ ] Write INNER and LEFT JOIN queries
[ ] Use GROUP BY with COUNT or SUM
[ ] Explain primary and foreign keys
[ ] Say why indexes speed up reads
[ ] Explain how passwords should be stored
[ ] Use parameterised queries

CAN I DO THIS WITHOUT NOTES?

[ ] Trace one feature from click to database
[ ] Tell two real bug stories with causes
[ ] Name one thing I would change and why
[ ] Run my project from a fresh clone
[ ] Use the Network tab to inspect a request
[ ] Read a Node stack trace and find the line
[ ] Explain my folder structure
[ ] Show one test, even a simple one