How I Automate Multi-Target Mix Renders and Validation Before Mastering (2026)

Horia Stan is music producer and sound engineer at The One Records, Bucharest.

Why I built a mix-validation suite

I stopped sending single WAVs to mastering years ago. One file leaves too much guessing. Mastering engineers end up doing fixes that should have been solved in the mix. That costs time and money. I automate a battery of tests and renders that prove my mix behaves across platforms. It gets me faster turnarounds and fewer revision cycles.

I run this on every single single and every stem pack I send out. It runs on my Mac Studio or my 2026 laptop when I’m on the road. The tools are Logic Pro 11, FabFilter Pro-Q 3, FabFilter Pro-L 2, Youlean Loudness Meter 3, ffmpeg 6, Node 20 and a small set of shell scripts. I use Audient iD14 MkII for tracking and Keyscape for keys, but those are irrelevant to the validation suite itself.

What the suite actually does

I only care about what affects the master or streaming render. The suite runs these checks automatically and renders multiple targets:

• LUFS and True Peak compliance checks (Youlean + ffmpeg loudnorm)
• Stereo width and phase correlation scans
• Per-section crest factor and dynamic range snapshot
• Codec transcodes and short-listening tests for AAC and Opus at platform bitrates
• A rendered "intent" print with my mastering-bus chain engaged, and a clean print with no master processing
• A JSON manifest that lists the exact renders, LUFS, TP, and timestamps for every file

These are not optional. They are explicit. I ship them with every mastering job.

Exact render targets I export

I export four main stereo renders for the mastering engineer and three quick-codec checks I keep for myself. All WAVs are 48 kHz 24-bit unless I’m sending session stems requested at 96 kHz.

1. mix_CLEAN_48k_24b.wav — No master-bus processing, global fader at -3.0 dBTP headroom. This is the neutral file. I use it when the mastering engineer wants to start from scratch.
2. mix_INTENT_48k_24b.wav — My mastering bus chain printed. This shows my artistic intent. I keep the file in case the mastering engineer prefers it as a reference.
3. stems_48k_24b.zip — All stems printed dry with no submix processing. Named and numbered. Interleaved stems only if the engineer asked.
4. mix_STREAM_CHECKS.zip — Short renders for LUFS presets: -14 LUFS I (integrated), -9 LUFS I, and an unmetered loudness print. Each file is measured and logged.

I also export quick compressed previews to check codec behavior:

• mp3_320.mp3 via ffmpeg libmp3lame
• aac_192.m4a via ffmpeg aac
• opus_96.opus via ffmpeg libopus

Why these? Because Opus at 96 kbps approximates social app codecs and AAC/MP3 catch different artifact classes.

The checks I run (and how I fix the failures)

1) LUFS and True Peak

I target three LUFS points. I render a proof at -14 LUFS I with True Peak -1 dBTP. I also render a louder reference at -9 LUFS I with TP -1 dBTP for pop contexts. I never bake a limiter that changes the mix into the clean file.

Toolchain and command example I run on macOS terminal with ffmpeg 6:

• Measure: ffmpeg -i mix_CLEAN_48k_24b.wav -af ebur128 -f null -
• Normalize check: ffmpeg -i mix_CLEAN_48k_24b.wav -af loudnorm=I=-14:TP=-1:LRA=7 -ar 48000 -ac 2 out_norm.wav

If a mix needs more headroom for the -14 target I turn down the vocal bus or attenuate the 2-6 kHz area with a surgical Pro-Q 3 dynamic notch. My standard Pro-Q 3 settings for a quick surgical cut: band at 3.5 kHz, Q 3.5, make it dynamic with -1.5 to -4 dB reduction depending on the singer.

2) Codec artifacts

I transcode to AAC and Opus and listen through cheap earbuds and my studio monitors. I focus on consonant sibilance, gated synth tails and stereo reverb smearing.

ffmpeg examples:

• AAC: ffmpeg -i mix_CLEAN_48k_24b.wav -c:a aac -b:a 192k out_192.m4a
• Opus: ffmpeg -i mix_CLEAN_48k_24b.wav -c:a libopus -b:a 96k out_96.opus

If I hear pumping or pre-ringing, I check the master bus limiter settings and any linear-phase EQ I used. I swap linear for minimum-phase where transient clarity matters. I also reprint problematic reverbs at lower wetness or use gating on tails.

3) Stereo width and phase

I use a free scan via ffmpeg + mid-side split and Youlean’s correlation. I look for negative correlation and excessive side-energy below 200 Hz.

If side energy is too high under 200 Hz I apply a mid-side highpass on the side channel with FabFilter Pro-Q 3 set to 180 Hz, slope 24 dB, mid untouched. If the correlation dips below -0.1 I reduce stereo delays and narrow the synths.

4) Transient and crest checks

I generate a per-section crest factor snapshot. A track with a 6 dB crest factor in the chorus and 12 dB in the verse will behave badly in mastering. I want consistent crest factors across sections.

I measure with ffmpeg and my Node script that outputs RMS vs peak per 3-second window. If a section looks too squashed I back off bus compression or automate gain to restore the transient.

What I send to the mastering engineer

Every delivery includes:

• 48k/24b mix_CLEAN_48k_24b.wav
• 48k/24b mix_INTENT_48k_24b.wav
• stems_48k_24b.zip (labeled and numbered)
• codec previews (mp3_320, aac_192, opus_96)
• validation.json (manifest with LUFS, TP, file hashes and ffmpeg logs)
• a short notes.txt with timings of any fixes applied and the intended loudness target

Why the manifest matters

Mastering engineers receive dozens of mixes. A manifest gives them the facts fast. It also documents the exact render settings so nobody argues about mastering work being "unnecessary".

My rules you can steal

• Never send only one file. Send clean and intent.
• Always include codec previews. Mastering without them is guesswork.
• Use 48 kHz 24-bit as default unless asked for 96 kHz.
• Keep True Peak at -1 dBTP for streaming safety.
• Ship a manifest with numbers. Numbers avoid opinions.

Final note

This workflow shaves revision time and gets consistent masters faster. I cut two rounds on average from mastering jobs I work on. The scripts and exact ffmpeg commands are simple and repeatable. If you want, I can share a starter Node script that runs the ebur128 checks and writes the manifest.

Concrete takeaway: export a clean file at -3 dBTP headroom, add an intent print with your mastering bus printed, run automated LUFS and codec checks (ffmpeg + Youlean), and always ship a manifest so the mastering engineer can trust your renders.