If the vocal keeps getting lost in the beat, turning it up usually isn’t the fix. The beat is louder than the voice in the same range the words live in, roughly 2 to 4 kHz. In our test a 3 dB cut on the beat at 3 kHz got the vocal back 1.8 dB at 2 kHz and 2.1 dB at 4 kHz, while the beat only dropped 0.38 LU. Turning the vocal up 3 dB instead made the whole mix 0.66 LU louder and pushed up the mud along with the words.

You can hear the vocal. You just can’t understand it. So you push the fader up a dB, then another, and now the vocal is too loud in the verse but the hook still gets swallowed when the synths come in.

That usually means it isn’t a level problem. It’s a masking problem. Something in the beat is sitting right on top of the part of the voice that carries the words.

Where the words live

The low part of a voice, around 200 to 500 Hz, is body and warmth. The part that makes words readable, the consonants and the bite of the vowels, sits higher, roughly 2 to 4 kHz. That’s also where a lot of beats are busiest: bright synth chords, snare crack, hats, the click of the kick. If the beat is louder than the voice in that range, the voice turns into a shape you can hear but not follow.

To show this, we wrote mask_check.py. It builds a synthetic eight-second beat with a kick, an 808, a snare, hats and a saw-wave chord, plus a synthetic vocal with formants at 700, 1,200 and 3,000 Hz. The vocal sings for two seconds, rests for two, and sits 4 LU under the beat while singing. For each octave band, it prints how loud the vocal is compared with the beat while the vocal sings. Negative means the beat is louder there. Then it puts a 3 dB, Q 1 cut on the beat at 3 kHz and measures again:

#!/usr/bin/env python3
"""Is the beat masking the vocal? Vocal-to-beat level per band, and what a small cut in the beat buys.
  python3 mask_check.py [cut_db] [freq_hz]
Synthetic 8 s beat (kick, 808, snare, hats, a bright saw chord) and a sung line (220-330 Hz voice with
formants near 700 Hz, 1.2 kHz and 3 kHz) that sings for 2 s, rests for 2 s. Band levels are octave-wide,
measured only while the vocal sings. Loudness is BS.1770 K-weighted, no gating (steady material)."""
import sys, numpy as np
from scipy.signal import lfilter

SR = 48000; N = SR * 8; t = np.arange(N) / SR; rng = np.random.default_rng(11)
def peq(x, f0, gain_db, q=1.0):                              # RBJ peaking EQ
    A = 10 ** (gain_db / 40); w = 2 * np.pi * f0 / SR; al = np.sin(w) / (2 * q)
    b = [1 + al * A, -2 * np.cos(w), 1 - al * A]; a = [1 + al / A, -2 * np.cos(w), 1 - al / A]
    return lfilter(np.array(b) / a[0], np.array(a) / a[0], x)
def lufs(x):
    y = lfilter([1.53512485958697, -2.69169618940638, 1.19839281085285], [1, -1.69065929318241, 0.73248077421585], x)
    y = lfilter([1, -2, 1], [1, -1.99004745483398, 0.99007225036621], y)
    return -0.691 + 10 * np.log10(np.mean(y ** 2))

def beat():
    b = SR // 2; x = np.zeros(N); k = np.arange(int(.3 * SR)) / SR
    for s in range(0, N - len(k), b):
        x[s:s + len(k)] += np.sin(2 * np.pi * (45 + 100 * np.exp(-k / .015)) * k) * np.exp(-k / .12)
    for s in range(b, N - SR // 5, 2 * b):
        n = rng.standard_normal(SR // 5) * np.exp(-np.arange(SR // 5) / SR / .05); x[s:s + len(n)] += 0.5 * peq(n, 2500, 6, .7)
    hat = np.diff(rng.standard_normal(N), prepend=0) * 0.04 * (np.sin(2 * np.pi * 4 * t) > 0)
    saw = sum(np.sin(2 * np.pi * k * f * t) / k for f in (261.6, 329.6, 392.0) for k in range(1, 40) if k * f < 12000)
    return x + hat + 0.12 * saw

def vocal():
    f0 = np.where((t % 4) < 1, 220, 330) * 2 ** (20 * np.sin(2 * np.pi * 5.5 * t) / 1200)
    ph = 2 * np.pi * np.cumsum(f0) / SR; v = sum(np.sin(k * ph) / k for k in range(1, 50))
    for f, g in ((700, 8), (1200, 6), (3000, 9)): v = peq(v, f, g, 2.5)
    on = ((t % 4) < 2).astype(float); return v * on, on > 0

def bands(x, m):
    X = np.abs(np.fft.rfft(x * m)) ** 2; f = np.fft.rfftfreq(N, 1 / SR)
    c = [250 * 2 ** i for i in range(6)]                   # octave bands, 250 Hz .. 8 kHz
    return c, np.array([10 * np.log10(X[(f >= fc / 2 ** .5) & (f < fc * 2 ** .5)].sum() + 1e-12) for fc in c])

def main():
    cut = float(sys.argv[1]) if len(sys.argv) > 1 else -3; fq = float(sys.argv[2]) if len(sys.argv) > 2 else 3000
    bt, (v, sing) = beat(), vocal()
    v *= 10 ** ((lufs(bt) - 4 - lufs(v[sing])) / 20)       # vocal sits 4 LU under the beat while singing (a dense mix)
    bt2 = peq(bt, fq, cut, 1.0)
    c, B = bands(bt, sing); _, V = bands(v, sing); _, B2 = bands(bt2, sing)
    print(f"Vocal minus beat, per octave band, while the vocal sings. Cut on the beat: {cut:g} dB at {fq:g} Hz, Q 1")
    print(f"{'band':>8}{'before':>9}{'after':>9}")
    for fc, b1, vv, b2 in zip(c, B, V, B2):
        print(f"{fc:>6.0f} Hz{vv - b1:>8.1f}{vv - b2:>9.1f}" + ("   <- beat louder here" if vv - b1 < -0.5 else ""))
    print(f"\nBeat loudness: {lufs(bt):.2f} LUFS before, {lufs(bt2):.2f} after ({lufs(bt2) - lufs(bt):+.2f} LU)")
    print(f"Full mix:      {lufs(bt + v):.2f} LUFS before, {lufs(bt2 + v):.2f} after ({lufs(bt2 + v) - lufs(bt + v):+.2f} LU)")
    dyn = np.where(sing, bt2, bt); gap = ~sing
    print(f"Cut only while the vocal sings (sidechained dynamic EQ): beat between phrases {lufs(dyn[gap]) - lufs(bt[gap]):+.2f} LU")
    print(f"Turning the whole vocal up 3 dB instead: full mix {lufs(bt + v * 10 ** (3/20)) - lufs(bt + v):+.2f} LU, and the vocal gains 3.0 dB in every band, mud included")

if __name__ == "__main__": main()

$ python3 mask_check.py
Vocal minus beat, per octave band, while the vocal sings. Cut on the beat: -3 dB at 3000 Hz, Q 1
    band   before    after
   250 Hz    -2.0     -2.0   <- beat louder here
   500 Hz    -0.0      0.1
  1000 Hz    -0.6     -0.2   <- beat louder here
  2000 Hz    -3.3     -1.5   <- beat louder here
  4000 Hz    -2.7     -0.6   <- beat louder here
  8000 Hz   -10.9    -10.5   <- beat louder here

Beat loudness: -11.35 LUFS before, -11.72 after (-0.38 LU)
Full mix:      -10.59 LUFS before, -10.91 after (-0.31 LU)
Cut only while the vocal sings (sidechained dynamic EQ): beat between phrases +0.00 LU
Turning the whole vocal up 3 dB instead: full mix +0.66 LU, and the vocal gains 3.0 dB in every band, mud included

What the numbers say

Before the cut, the beat is 3.3 dB louder than the vocal at 2 kHz and 2.7 dB louder at 4 kHz. That’s the range the words need. After a 3 dB cut on the beat, the vocal is only 1.5 and 0.6 dB under it there. It got back 1.8 and 2.1 dB right where it matters, and nothing changed at 250 Hz.

Look at what the cut cost the beat. Its loudness dropped from −11.35 to −11.72 LUFS, just 0.38 LU, and the full mix only moved 0.31 LU. Most of a beat’s loudness sits in the low end, so a cut up at 3 kHz barely shows on a loudness meter. It does show in how clearly you can follow the words.

Now the other way. Turning the whole vocal up 3 dB makes the full mix 0.66 LU louder. Every band of the vocal goes up 3 dB, including the low mids where vocals and beats tend to build up mud. That’s more level on the master and more for the limiter to work with, and the words still aren’t much easier to follow than with the cut.

These are synthetic signals, so treat the exact numbers as a model. On a real song the busiest range might sit at 2.5 kHz or 4 kHz. The idea is the same.

Only cut while the vocal sings

The last line of the output is the trick that makes this almost free. Put the cut on a dynamic EQ and key it from the vocal, so the band only dips while someone is singing. Between phrases the beat is back to full level, +0.00 LU in our test. The drop and the instrumental breaks keep all their sparkle, and the vocal still gets its space when it needs it.

How to do it in your session

1. Find the clash. Put an analyzer on the beat bus and one on the vocal, or one that overlays both. Look at 1 to 5 kHz while the vocal sings. Where the beat sits above the voice is where to cut.
2. Cut on the beat bus, not on every track. Start with 2 to 3 dB, Q around 1, at the center of the clash. Wider and gentler usually sounds more natural than a narrow notch.
3. Make it dynamic if you can. Sidechain the band from the vocal, aiming for 2 to 3 dB of reduction on sung parts and none between them.
4. Compare at matched loudness. The cut makes the beat a hair quieter, and quieter often sounds worse at first. Match levels before you decide, the same trap as in your mix sounding better loud.
5. Then set the vocal level. Once the words come through, you may find the vocal can come down a dB. How loud the vocal should sit has a way to measure it.

If the vocal still sounds lost after this, check the vocal’s own effects. A wide, dark reverb return is often what’s smearing it, which filtering the reverb return deals with. And if your fix ends up being a brighter vocal, keep an ear on the esses, since harsh S’s get louder after mastering.

For the A/B, one easy way is to bounce the mix both ways and drop them into CoProducer’s A/B, which plays them at matched loudness so the quieter version doesn’t lose just for being quieter. You can also run each one through the analyzer to check the integrated LUFS before and after.

Why can I hear my vocal but not understand the words?

Usually the beat is louder than the voice around 2 to 4 kHz, where consonants and vowel detail live. In our test the beat was 3.3 dB over the vocal at 2 kHz and 2.7 dB over it at 4 kHz.

Should I boost the vocal or cut the beat?

Cut the beat first. In our test a 3 dB cut on the beat at 3 kHz got the vocal back about 2 dB where the words live and only dropped the beat 0.38 LU. Turning the vocal up 3 dB made the whole mix 0.66 LU louder and raised the mud too.

What frequency should I cut to make room for vocals?

Look for where the beat sits above the vocal between about 1 and 5 kHz while the vocal sings. 2 to 4 kHz is a common range. Start with a 2 to 3 dB cut with a Q of about 1.

What is a sidechained dynamic EQ for vocals?

An EQ band on the beat that only cuts when the vocal is playing, triggered by the vocal track. The beat keeps its full brightness between phrases.