Motion designers rarely have a rendering problem. They have a delivery problem. The comp looks perfect on the timeline, the preview plays smoothly, and then the export lands on disk at 800 MB for a clip that will be watched on a five-inch screen for twenty seconds. Understanding how to bring that number down without losing the look is a skill worth building once and reusing forever.
Why After Effects Exports Balloon in Size
Compositing software is built to preserve quality, not to ship small files. When you add a composition to the render queue and pick a lossless or near-lossless output module, you are asking After Effects to write every pixel as cleanly as it can. That is exactly the right choice for a master file and exactly the wrong choice for anything you intend to upload.
The problem gets worse as the comp gets more interesting. Grain, glows, particle systems, motion blur, and camera moves all produce high-frequency detail that compressors cannot describe cheaply. A flat talking-head clip at 1080x1920 might encode at 3 Mbps with no visible damage. The same frame with animated film grain and a volumetric light can need three or four times that bitrate before the encoder stops smearing the texture.
Duration adds up quietly. Short-form vertical video lives in the 15-90 second range, but a 90-second file at a generous bitrate crosses 100 MB quickly, and some upload paths, messaging apps, and client review tools start misbehaving well before that. The fix is not a single magic setting. It is a pipeline: export one clean master, then compress that master deliberately for each destination.
The Four Levers That Actually Control File Size
Almost every compression decision maps back to four variables. Learn how they interact and you can hit any size target without guessing.
Resolution
1080x1920 is the delivery standard for vertical video. Rendering at 2160x3840 quadruples the pixel count for a result that most platforms will downscale anyway, and the larger upload can even pick up extra re-compression artifacts. Only render above 1080 wide when you plan to crop, reframe, or zoom in post, or when a specific destination genuinely rewards a high-resolution upload. If your comp is built at 4K for flexibility, that is fine — just scale down on the delivery encode rather than uploading the 4K file.
Codec
H.264 is the universal option. It plays everywhere, encodes fast, and every editing tool and platform accepts it. HEVC (H.265) delivers roughly 30-50% better efficiency at the same perceived quality, but support is uneven on older Android devices and some browser contexts. AV1 is the most efficient of the three and is increasingly common on modern hardware, though encoding is slower and legacy devices may struggle to decode it.
A practical ladder: H.264 when playback must never fail, HEVC when your audience is on current devices and you want meaningfully smaller files, AV1 for web embeds and archive copies where a longer encode is acceptable. For a client deliverable, H.264 is still the safe default.
Bitrate and quality targeting
For 1080x1920 H.264 at 30 fps, 8-12 Mbps is a comfortable range. At 60 fps, budget 12-16 Mbps. HEVC can usually achieve the same look at roughly 60% of those numbers, and AV1 lower still. Below those ranges, fast motion turns blocky and gradients band. Above them, you are paying for pixels the platform will discard.
For short clips, constant quality encoding (CRF in FFmpeg, constant quality in other tools) almost always beats a hard average bitrate, because the encoder spends data where the image actually needs it. Use average bitrate targeting only when an upload path has a hard file size limit.
Frame rate, keyframes, and audio
30 fps is the norm for Reels and Shorts. 60 fps nearly doubles the data for footage that is often watched on a phone at arm's length. Keyframe interval matters more than most people realize: one keyframe every two seconds (60 frames at 30 fps) gives platforms enough anchors to seek and re-encode without thrashing. Audio is usually a small slice of the file, but it is not free. AAC-LC at 128 kbps stereo is transparent enough for phone speakers, and 96 kbps mono is plenty for voice-driven content. A 320 kbps track in a file destined for earbuds is pure waste.
Building a Clean Master Export in After Effects
Render Queue versus Media Encoder
After Effects' built-in H.264 output module is convenient but basic. For anything you will reuse, export a master in an intermediate codec and compress separately. If you prefer Media Encoder for convenience, use its H.264 or HEVC presets, but expect slightly less efficiency than a dedicated pass with a tuned encoder.
Choosing the master format
ProRes 422 is the workhorse if your comp has no transparency. ProRes 4444 keeps 4:4:4 chroma and an alpha channel, which can double or triple file size for no benefit on a vertical social clip. DNxHR SQ or HQ are solid cross-platform alternatives, and DNxHR is the safer default on Windows-only pipelines where ProRes support is inconsistent. Whichever you choose, keep the master at your working resolution — not upscaled "just in case."
Do sharpening and color work before compression
Apply sharpening, color correction, and any detail work in the master, never after a lossy encode. Sharpening a compressed file amplifies blocking and ringing. Equally important: if your comp has heavy synthetic noise, a gentle denoise before the delivery encode can cut file size dramatically. The compressor treats noise as real detail and spends bits trying to preserve it.
Handle alpha deliberately
Standard H.264 has no alpha channel. If you need transparency for overlays or lower-thirds, export ProRes 4444 or a PNG sequence and deliver through a format that supports alpha, such as VP9 or AV1 in WebM. Trying to force transparency through H.264 produces either a black background or a mangled edge.
Compressing With FFmpeg: The Commands Worth Memorizing
CRF versus two-pass
CRF is quality-targeted and single-pass, which makes it the right default for short clips. Two-pass targets an average bitrate and gives predictable file sizes, which matters when an uploader enforces a hard cap. For a 30-second vertical clip, CRF is faster and generally looks better per byte.
A reliable vertical preset
ffmpeg -i master.mov \
-c:v libx264 -preset slow -crf 20 -pix_fmt yuv420p \
-vf "scale=1080:1920:flags=lanczos" -r 30 \
-g 60 -keyint_min 60 -sc_threshold 0 \
-c:a aac -b:a 128k \
-movflags +faststart reel-1080.mp4
Each flag earns its place. -preset slow buys real efficiency for a small time cost on a short clip. -crf 20 is a quality-first target; move to 22 or 23 if you need a smaller file. -pix_fmt yuv420p guarantees compatibility with players that reject 4:2:2 or 4:4:4. -g 60 -keyint_min 60 -sc_threshold 0 pins a keyframe every two seconds and stops the encoder from inserting random ones. +faststart moves the metadata to the front of the file so playback starts immediately instead of buffering.
HEVC and AV1 variants
For HEVC, swap the video encoder for libx265 -crf 24 -preset medium and add -tag:v hvc1 so Apple platforms recognize the file correctly. For AV1, use libsvtav1 -crf 30 -preset 6, which is dramatically faster than the older AV1 encoders while producing comparable results. Keep +faststart in every MP4 you ship.
Squeezing further without wrecking quality
-tune animation helps flat color and hard-edged motion graphics. For noisy sources, a light temporal denoise such as hqdn3d=1.5:1.5:6:6 can cut the file size noticeably before the encoder ever sees it. The most reliable habit is to encode three versions at CRF 20, 23, and 26, then compare them at actual phone viewing size rather than zoomed to 400% on a monitor. Many "quality differences" only exist at magnification nobody will ever use.
GUI Options When You Do Not Want a Terminal
HandBrake is the fastest way to compress a single file. Its quality slider maps to a constant quality value, and a setting in the low twenties on the x264 encoder is a good starting point for vertical video. Two things to watch: the "Web Optimized" checkbox is what gives you faststart, and the Dimensions tab sometimes applies a crop or resize you did not intend. Check the summary panel before you hit start.
Shutter Encoder wraps FFmpeg with far more codec control, a batch queue, and an AV1 path. It sits comfortably between a one-click tool and a command line.
Hardware encoders deserve a specific warning. NVENC, Quick Sync, and VideoToolbox are extremely fast, and at high bitrates they look fine. At low bitrates on dark gradients they smear noticeably compared with a software encoder. For a 1080x1920 clip where quality per byte is the goal, software x264 or x265 at a slow preset still wins.
Advanced Techniques for Effect-Heavy Compositions
Separate grain from the rest of the comp
Grain is the single largest file size tax in motion design. Fine film grain that changes every frame forces the encoder to describe a new noisy pattern for every single frame, which destroys temporal compression. Two practical fixes: reduce the grain layer's opacity so it reads as texture rather than noise, and slow the grain's update rate. Updating grain at 12 fps or even 8 fps looks nearly identical to the eye but lets the encoder reuse far more data between frames.
Pre-render heavy layers
Particle systems, 3D layers, and complex simulated effects are expensive to render and produce chaotic detail that compresses poorly. Pre-render those layers to ProRes, then composite the flattened result into the final comp. You get faster renders, cleaner output, and a more predictable encode.
Glows, gradients, and banding
Large radial glows are moderately expensive. Wide flat gradients are worse than they look, because 8-bit encoding quantizes them into visible bands. Adding a very subtle dither or a 1-2% noise layer over a gradient actually reduces banding and can compress more efficiently than a perfectly smooth gradient that the encoder must approximate with limited steps.
Know what 10-bit and 4:4:4 cost you
If you are delivering HDR, use HEVC Main10 or AV1. For SDR short-form, 8-bit 4:2:0 is the correct target and is dramatically smaller than 4:4:4. Many editors export 4:4:4 because it "sounds more professional," then wonder why the file is enormous. Match the delivery format to the destination.
Scaling the Workflow: Batching a Feed, Not a File
If you publish several Reels a week, a shell loop pays for itself quickly.
for f in masters/*.mov; do
base=$(basename "$f" .mov)
ffmpeg -i "$f" -c:v libx264 -preset slow -crf 21 -pix_fmt yuv420p \
-vf "scale=1080:1920:flags=lanczos" -r 30 -g 60 -keyint_min 60 \
-sc_threshold 0 -c:a aac -b:a 128k -movflags +faststart \
"out/${base}_1080x1920_h264.mp4"
done
Naming the output with the codec and resolution means you never have to open a file to remember what it is. Keep masters on external storage, keep delivery files local and small, and normalize loudness to a consistent target so you never have to re-encode audio later and re-run the video encode with it.
It helps to know your size budget before you start. Bitrate times duration divided by eight gives megabytes: a 30-second clip at 10 Mbps is about 37 MB, at 6 Mbps about 22 MB, and a 60-second clip at 12 Mbps is roughly 90 MB. If a destination rejects the file, you now know exactly which lever to pull.
Delivery Notes by Destination
Instagram Reels accepts 1080x1920, H.264 with AAC audio, and up to 60 fps. Because the platform re-encodes aggressively, pushing a very high bitrate mostly produces a slower upload without a better-looking result. Around 8-12 Mbps is more than enough.
YouTube Shorts keeps more of your upload quality in its top rendition, so a slightly higher bitrate in the 12-16 Mbps range is a reasonable investment, especially for motion graphics with fine detail.
TikTok behaves similarly to Reels: clean faststart, consistent audio, and no unnecessary resolution. Web embeds and email signatures need a different approach entirely — consider a lightweight looping clip or a still sequence rather than forcing a video file into a context that will never play it well. For sites you control, serving multiple renditions rather than one large MP4 is the professional answer.
Common Mistakes That Waste Time and Quality
Re-encoding an already compressed file two or three times is the most common one. Every lossy generation compounds artifacts. Encode once, from the master, at the final target.
Other frequent traps: rendering 4K vertical and uploading it unchanged; judging quality at 400% zoom instead of on an actual phone; ignoring keyframe interval so the platform's encoder thrashes on your file; over-compressing dark scenes until banding appears instead of fixing the source with subtle dither; shipping a 320 kbps audio track to phone speakers; forgetting faststart and losing the first seconds to buffering; sharpening after compression; blaming the codec when a hardware encoder was running at 3 Mbps; and never checking the finished file inside the app it was made for.
FAQ
How small should a vertical video actually be?
Aim for the platform's preferred bitrate rather than an arbitrary file size. For 1080x1920 H.264 at 30 fps, 8-12 Mbps is a healthy range, which works out to roughly 37 MB for 30 seconds at 10 Mbps. Smaller is not automatically better; below the platform's comfort zone, motion turns mushy.
Does compressing a second time hurt quality?
Yes, noticeably. Each lossy pass builds on the artifacts of the previous one. Keep one high-quality master and encode from it every time you need a new version.
Should I use HEVC or H.264 for Reels?
H.264 for maximum compatibility and predictable uploads. HEVC if you need meaningfully smaller files and your audience is on current devices. Test on an older Android phone before committing an entire series to HEVC.
Why is my file still huge after I compressed it?
Look at four suspects: grain or noise the encoder is faithfully preserving, a 60 fps timeline, an alpha channel you did not remove, and a source in 10-bit 4:4:4. Any of them can double or triple an otherwise efficient encode.
Can I just export H.264 straight from After Effects?
Yes, for quick turnarounds. Use a two-pass VBR around 10-12 Mbps at 1080x1920 and enable maximum render quality only where it matters. For anything you will reuse or revise, export a ProRes master and compress from that instead.
Where do AI-generated clips fit in this pipeline?
Generated footage often arrives at unusual resolutions, frame rates, and bitrates. Normalize it to 1080x1920, 30 fps, and a consistent color space in the same encode that produces your delivery file, rather than adding an extra generation of compression. Adding an AI-generated B-roll insert into an effect-heavy comp is fine — just remember that the same grain, resolution, and bitrate rules apply to it as to everything else.
