N030-E2 Tier 3 · Intermediate · easy hr · Helix Systems

Return the number of active employees in each department

Part of Common Table Expressions (CTEs) in SQL

The problem

The HR team at Helix Systems monitors staffing levels across departments.

Write a query to return the number of active employees in each department.

Assumptions:

  • The employees table has one row per employee with a department_id and an is_active flag.
  • Only active employees (where is_active is TRUE) count toward the headcount.
  • Each department_id with at least one active employee should appear once in the report.

Output:

  • One row per department, with columns department_id and headcount.
Schema · hr 4 tables
departments
id integer
name text
location text
budget numeric
salaries
id integer
employee_id integer
amount numeric
effective_date date
end_date? date
employees
id integer
name text
email text
department_id integer
manager_id? integer
hire_date date
title text
is_active boolean
job_history
id integer
employee_id integer
title text
department_id integer
start_date date
end_date? date

Run previews · Check grades

Write a query, then run it to see results here.

Worked solution Try it yourself first
Solution query
WITH
  dept_headcount AS (
    SELECT
      department_id,
      COUNT(*) AS headcount
    FROM
      employees
    WHERE
      is_active = TRUE
    GROUP BY
      department_id
  )
SELECT
  department_id,
  headcount
FROM
  dept_headcount

The shape

The WHERE lives inside the WITH layer, so the filter runs before the grouping. Only active employees ever reach the COUNT(*), and the main query reads the already-filtered headcount per department straight out of the named layer.

Clause by clause

  • The WITH clause defines dept_headcount:
WITH dept_headcount AS (
  SELECT department_id, COUNT(*) AS headcount
  FROM employees
  WHERE is_active = TRUE
  GROUP BY department_id
)

The WHERE is_active = TRUE keeps only the rows that should count toward staffing; GROUP BY department_id then partitions those surviving rows by department, and COUNT(*) counts each partition. Department 1 ends up with 16 active employees, department 3 with 9, and so on.

  • SELECT department_id, headcount FROM dept_headcount is the main query. It reads the named layer by name and returns both of its columns. No additional filtering is needed because the active-only restriction already happened inside the layer.

The trap

The order of the clauses inside the layer matters. WHERE runs before GROUP BY, so WHERE is_active = TRUE restricts the input rows before any grouping occurs. Moving the same condition to the main query, where the layer has already aggregated, would have nothing to filter on; the is_active column does not exist in dept_headcount's output. The filter belongs where the column it references is still in scope, which is inside the layer.

You practiced applying a WHERE condition inside a WITH layer so the breakdown computes only over the qualifying records.

How you actually get good at SQL

Reading explains SQL. Writing it, over and over with instant feedback, is what makes you fluent.

That's the whole SQLMaxx loop: 600+ real problems, instant AI feedback, mastery you can actually see, and spaced review that won't let you forget.

A stack of SQL practice problem cards, the top card showing an employees table.
615 problems · 66 concepts

Real problems. Not toy examples.

615 hand-built problems spanning all 66 concepts, from basic SELECTs to window functions, built on real schemas and real business questions, the kind you'll actually get asked on the job. Enough reps to make SQL automatic.

A retro computer showing a SQL query marked correct with a green checkmark.
Instant AI feedback

Write a query. Know if it's right in one second.

No copying an answer and hoping it clicked. The AI grader checks your real query against real data, catches exactly what's wrong, and explains the fix in plain English, like a senior analyst reading over your shoulder on every problem.

A circular mastery progress dial filling from blue to green, the SQLMaxx diamond at its center.
Mastery tracking

Stop guessing whether you actually know it.

SQLMaxx tracks every concept and shows you what you've mastered and what's still shaky. Your skills fill in one concept at a time, so 'I think I get joins' becomes something you can prove.

A SQL query editor circled by a blue return arrow with a clock, scheduled to come back for review.
Spaced review

Learn it once. Keep it for good.

Most of what you learn this week fades by next week. So when a concept comes due for review, SQLMaxx hands you a fresh problem to solve from a blank editor, not a flashcard to re-read. A research-backed spaced-repetition algorithm (FSRS) times each return for right before you'd forget, so your SQL is still there months later, when the interview or the job actually needs it.

Practice, feedback, mastery, review. That's the loop that turns reading into real skill.

Start free

No account, no credit card. Start solving in under a minute.