If a sidechain pump sounds late rather than just long, check latency first: lookahead, plug-in delay compensation and a key signal that arrives behind the kick will all shift the duck, whatever the release is. Once the timing lines up, work the release from the tempo: one beat is 60,000 ÷ BPM milliseconds (428.6 ms at 140 BPM), the bass should be fully back before the next kick, and in our test that took a release of roughly a quarter to a third of a beat.

You key the bass off the kick, set a few dB of gain reduction, and the groove should start breathing. Instead it does something strange. The bass seems smaller overall, the pump feels smeared, and on some beats it feels like the duck is happening a little behind the kick instead of with it.

Nine times out of ten that’s the release. Attack decides how fast the bass gets out of the way. Release decides when it comes back. If it comes back too slowly, the next kick shows up while the bass is still on its way up, and the compressor ducks it again from wherever it was.

The beat sets the deadline

A beat lasts 60,000 divided by the BPM, in milliseconds. At 140 BPM that’s 428.6 ms. At 90 BPM it’s 666.7 ms. On a four-on-the-floor kick, that’s the whole window the bass has to duck and come all the way back. Same math as setting a delay from the tempo in your delay sounds off the beat, just pointed at a compressor. There is a table of starting release times from 80 to 160 BPM further down.

To see what different release times leave behind, we wrote duck_check.py. It keys a plain compressor from a kick on every beat, ducks 6 dB at the hit with a 1 ms attack, and tries a range of release times. For each one it prints how much the bass is still ducked right before the next kick, and how much of each beat the bass spends back within 1 dB of full level:

#!/usr/bin/env python3
"""How much is the bass still ducked when the next kick lands? Sidechain release vs tempo.
  python3 duck_check.py [bpm] [depth_db]
Keys a simple log-domain compressor (1 ms attack) from a four-on-the-floor kick and reports, for each
release time: gain reduction left at the next hit, and how much of each beat the bass spends within 1 dB
of full level. Release here is the one-pole time constant (to ~63% recovered); plugins label it differently."""
import sys, numpy as np

SR = 48000
def kick_pattern(bpm, beats=16):
    beat = int(SR * 60 / bpm); n = beat * beats; t = np.arange(int(0.12 * SR)) / SR
    hit = np.exp(-t / 0.03)                                # key signal: a 120 ms kick envelope
    x = np.zeros(n)
    for b in range(beats): x[b * beat:b * beat + len(hit)] += hit
    return x, beat

def duck(key, depth_db, att_ms, rel_ms):
    target = -depth_db * key / key.max()                   # full depth at the kick's peak
    a, r = np.exp(-1 / (SR * att_ms / 1000)), np.exp(-1 / (SR * rel_ms / 1000))
    g, out = 0.0, np.empty_like(target)
    for i, tg in enumerate(target):
        c = a if tg < g else r                             # falling = attack, rising = release
        g = c * g + (1 - c) * tg; out[i] = g
    return out

def main():
    bpm = float(sys.argv[1]) if len(sys.argv) > 1 else 140
    depth = float(sys.argv[2]) if len(sys.argv) > 2 else 6
    key, beat = kick_pattern(bpm)
    print(f"{bpm:g} BPM, one beat = {beat / SR * 1000:.1f} ms, duck depth {depth:g} dB, attack 1 ms")
    print(f"{'release':>9}  {'still ducked at next kick':>25}  {'beat back within 1 dB':>21}")
    for rel in (25, 50, 100, 150, 250, 400, 800):
        g = duck(key, depth, 1, rel)
        last = g[-2 * beat:-beat]                          # a settled beat, late in the loop
        left = g[-beat - 1]                                # just before the next kick
        free = (last > -1).mean() * 100
        print(f"{rel:>6} ms  {left:>22.2f} dB  {free:>20.0f} %")

if __name__ == "__main__":
    main()

$ python3 duck_check.py 140
140 BPM, one beat = 428.6 ms, duck depth 6 dB, attack 1 ms
  release  still ducked at next kick  beat back within 1 dB
    25 ms                   -0.00 dB                    79 %
    50 ms                   -0.00 dB                    71 %
   100 ms                   -0.11 dB                    52 %
   150 ms                   -0.39 dB                    33 %
   250 ms                   -1.11 dB                     0 %
   400 ms                   -2.02 dB                     0 %
   800 ms                   -3.34 dB                     0 %

Read the middle column first. With a 100 ms release, the bass is 0.11 dB down when the next kick hits. That’s fully back for any ear. At 150 ms it’s 0.39 dB down, still fine. At 250 ms it’s 1.11 dB down, and the right-hand column drops to zero: the bass never gets back within 1 dB of its real level during the whole beat. At 800 ms it sits 3.34 dB down permanently.

That last case is the one that fools people. With a release that long, there’s barely any pump at all. The compressor just holds the bass a few dB lower all the time, so it sounds like the bass got quieter, and the natural move is to turn it up. Then the master gets louder and the groove still doesn’t breathe.

Same settings, slower song

Here’s the same check at 90 BPM:

$ python3 duck_check.py 90
90 BPM, one beat = 666.7 ms, duck depth 6 dB, attack 1 ms
  release  still ducked at next kick  beat back within 1 dB
    25 ms                   -0.00 dB                    87 %
    50 ms                   -0.00 dB                    81 %
   100 ms                   -0.01 dB                    69 %
   150 ms                   -0.08 dB                    57 %
   250 ms                   -0.43 dB                    32 %
   400 ms                   -1.10 dB                     0 %
   800 ms                   -2.46 dB                     0 %

At 90 BPM, a 250 ms release leaves 0.43 dB and gives the bass about a third of each beat at full level. That’s usable. Take the same preset to a 140 BPM track and it’s the 1.11 dB row with no recovery at all. A sidechain preset doesn’t know your tempo. If it sounded right on the last beat and wrong on this one, that’s probably why.

Too fast is a problem too

At 25 to 50 ms, the bass is back for 71 to 79% of the beat at 140 BPM. That sounds like the answer, but the duck is so short it feels more like a gap than a pump. On low notes it can also get grainy. A 55 Hz bass cycle takes about 18 ms, so a release that short moves the gain within a cycle or two, and that bends the waveform. If the bass gets a little fuzzy when the sidechain is on, try a longer release before you blame the bass sound.

Release time by BPM: a starting table

One beat is 60,000 ÷ BPM in milliseconds, and an eighth note is half of that. The last two columns are where we would start: a quarter to a third of the gap between kicks, which is where the bass came back in time in the 140 and 90 BPM runs above. They are starting points to check against the gain reduction meter, not rules.

Plugins label release differently, so the same number can behave differently in two compressors. Loop a bar and watch the meter reach zero just before each kick, then adjust by ear.

How to set it in your session

1. Work out the beat. 60,000 ÷ BPM. If the kick plays every half beat, halve it. That’s the deadline.
2. Start around a quarter to a third of the beat. In our model that was the range where the bass came back right before the next hit: about 100 to 150 ms at 140 BPM, 150 to 250 ms at 90.
3. Watch the gain reduction meter, not the number. Plugins measure release differently, so the same 150 ms can behave differently in two compressors. Loop a bar and check that the meter touches zero just before each kick. If it never gets there, shorten the release.
4. Listen in context, then shape. Lengthen it until you hear the bass swell back in time with the groove, and stop before it misses the next hit. If your compressor has a hold control, a few ms of hold can keep the duck clean on long kicks.
5. Check the irregular parts. In trap and drill the kick pattern isn’t even. Set the release for the shortest gap between kicks that matter, then check the busy bars.

If the compressor is ducking more than it should on the 808 because the key signal is full of low end, that’s a related problem with its own fix in your bus compressor is pumping on the 808. And if you’re still deciding whether to sidechain at all, your kick and 808 are arguing in the same chair lays out the other options.

When the kick is baked into a sample

Sometimes the kick you want to duck from is inside a loop or a flipped record, not on its own track. Keying from the whole loop doesn’t work well, because the snare and hats trigger the compressor too. One way around it is to split the drums out first, with something like NoDAW StemSplit, and key the sidechain from the drum stem. Low-pass the key around 150 Hz so mostly the kick drives it. The original drummer wasn’t on your grid, so the duck follows the record’s real kicks instead of where the grid thinks they are. There’s more on working with split drums in sampling from separated stems.

Tempo-synced volume shapers do the same job with a drawn curve instead of a compressor. The same rule holds there: the curve should be back at full level before the next hit.

What release time should I use for sidechain compression?

Long enough that the bass swells back in time with the groove, short enough that it’s fully back before the next kick. In our 140 BPM test that was about 100 to 150 ms. At 250 ms the bass was still 1.11 dB ducked when the next kick hit.

Why does my sidechain make the bass quieter instead of pumping?

The release is too long for the tempo. The bass never fully recovers between kicks, so the compressor keeps it a few dB down the whole time. In our test an 800 ms release at 140 BPM held it 3.34 dB down permanently.

How do I calculate the beat length from BPM?

Divide 60,000 by the BPM to get one beat in milliseconds. 140 BPM is 428.6 ms and 90 BPM is 666.7 ms. Halve it if the kick plays on every eighth note.

Can a sidechain release be too fast?

Yes. A very short release makes the duck feel like a gap instead of a pump, and on low notes it can add distortion because the gain moves within a cycle or two of the bass.

What sidechain release time should I use at 120 BPM?

One beat at 120 BPM is 500 ms, so start with a release of about 125 to 167 ms if the kick plays on every beat, and about 62 to 83 ms if it plays on every eighth note. Then watch the gain reduction meter and shorten the release if it does not reach zero before the next kick.

Why does my sidechain feel late even with a short release?

Check latency first. Lookahead, plug-in delay compensation and the way the key signal is routed can all shift the duck behind the kick, and a release time cannot fix that. Once the duck lands on the kick, set the release from the tempo: 60,000 ÷ BPM is the length of one beat in milliseconds.