Automating Video Conversion for Amazon with a Custom Golang-based Tool

I recently built a video converter application for my wife, who works with Amazon and regularly needs to convert videos into various formats and resolutions for different placements on the platform. Manually adjusting video settings for each requirement was time-consuming and error-prone, so I decided to automate the entire process for her.

The Problem: Repetitive Video Conversions

Amazon’s platform has strict requirements for video formats, bitrates, framerates, and resolutions, depending on where the videos will be uploaded. My wife often had to handle multiple videos and manually convert them to meet these requirements. This process involved going through detailed video specifications, adjusting codecs and settings manually using external tools, and testing the results over and over.

The Solution: Automation and Streamlining with Golang

I wanted to simplify her workflow by automating as much of the process as possible. So, I developed a Golang-based application that wraps around ffmpeg and ffprobe to handle all the heavy lifting for video conversion. The application does more than just convert files—it validates each video against Amazon’s requirements, detects discrepancies, and automatically adjusts parameters like codecs, bitrate, framerate, and resolution to match the best possible quality without compromising the original content.

Here’s how it works:

Drag and Drop Simplicity: To make the process even more convenient, I added drag-and-drop support. She can now simply drag a video file and drop it onto the application icon. The app automatically starts validating and adjusting the video based on Amazon’s requirements—no need to manually set parameters or fiddle with options.
Validation and Adjustment: The app checks each video file against the specific requirements from Amazon. If there’s a mismatch—say, the bitrate is too high or the resolution isn’t ideal—the application computes the delta and automatically adjusts the settings to bring the video into compliance. This ensures that every video is ready to upload without requiring further manual steps.
Fast and Efficient: The app wraps around ffmpeg and ffprobe, both of which are packaged with the Golang application. This ensures that all the necessary video conversion tools are ready to go without requiring additional installation or setup.

The Outcome: Time Saved, Coffee Gained

What used to take multiple manual steps is now as simple as dragging a file, grabbing a cup of coffee, and coming back to find the video already converted and ready for Amazon. This automated process has saved my wife countless hours of manual video conversion, allowing her to focus on more important tasks. She no longer needs to worry about matching specifications or tweaking settings; the app handles all the details, ensuring the video quality remains high while complying with Amazon’s strict requirements.

Technical Overview

Backend: Written in Golang, the application wraps around ffmpeg and ffprobe for all video conversion and validation tasks.
Validation: It uses ffprobe to extract video metadata and compare it with predefined Amazon requirements.
Conversion: Based on the detected delta, ffmpeg handles all necessary adjustments, from resolution and bitrate down to the codec level, without sacrificing quality.
Drag & Drop: Built-in drag-and-drop functionality lets my wife initiate conversions simply by dropping a video file on the app icon.
Automation: Once a file is dropped, the app automates the entire process, including validation, adjustment, and conversion.

Final Thoughts

I built this application to reduce the manual, repetitive tasks my wife was handling when converting videos for Amazon. Now, she just drops the file and walks away—no more tweaking codecs or worrying about meeting platform specifications. The app handles it all, improving both the speed and accuracy of her work.

This project was a fun technical challenge, and it’s been great to see how much time it has saved her in her daily workflow. Plus, knowing I could leverage tools like ffmpeg and ffprobe in a seamless, user-friendly way made it all the more rewarding.