We Built a Custom Video Management System That Eliminated 20+ Hours of Manual Work a Week
Karan Kashyap
April 10, 2026
The Problem No One Talks About (Until It's Too Late)
There's a myth in business tech that content distribution is a solved problem. You've got Google Drive. You've got Notion. You've got Telegram, WhatsApp, whatever. Surely you can just stitch these together and it works?
It works — until it doesn't.
For our client, an e-learning platform distributing thousands of educational videos to students and staff through private Telegram channels, the "stitch it together" approach had slowly become a 20-hour-a-week liability. Their content workflow looked like this:
- Open Windows Explorer, locate the video file
- Rename the file manually with relevant keywords
- Switch to a separate, outdated content dashboard — search, wait, find the file
- Add tags individually through a slow, clunky interface
- Drag the file into Telegram Desktop, wait for it to upload
- Type the caption by hand, try to remember what hashtags to use
- Double-check it went to the right channel — and hope for the best
Repeat that for every video, multiple times a day, with a library growing by dozens of files per week.
The result? Wrong videos reaching wrong audiences. Inconsistent tagging that made their own search useless. Captions that were missing or malformed. No audit trail. No accountability. And a team that was spending more time managing files than doing the actual work they were hired for.
They came to us with one ask: make this stop.
Our Approach: Build for the Exact Problem, Not the Nearest Generic Tool
Before writing a single line of code, we mapped the full workflow. Not the ideal workflow — the actual one, with all its manual steps, workarounds, and failure points. We interviewed the content team, watched them work, and documented every friction point.
From that mapping, a clear picture emerged: this wasn't a problem that a SaaS subscription was going to solve. The workflow was too specific, the file types too varied, the distribution logic too custom. What they needed was a purpose-built internal tool that replaced every manual step with automation — and did it in a way that non-technical staff could actually use.
We chose a Python + Flask stack for the backend, SQLite with WAL mode for the database, and Tailwind CSS + Alpine.js for a lightweight, responsive frontend. The system would run locally on their Windows machine — no cloud dependency, no data leaving the building, no new infrastructure to manage.
What We Built: A Self-Hosted Video Library Management Platform
1. Automatic Library Scanning and Indexing
The first thing the platform does is watch. Using recursive directory traversal, it scans the client's entire video library and detects new files, changed files, and files that have been moved or deleted — automatically, on demand.
Every video is indexed into a SQLite database with its full technical metadata: duration, resolution, codec, bitrate, file size, creation date. This is extracted via FFprobe (part of the FFmpeg ecosystem) without any manual input. The team opens the dashboard and their entire library is already there, up to date, ready to work with.
The incremental update logic means re-scans are fast even on libraries with thousands of files — only changed or new entries are processed.
2. Fuzzy Search, Smart Tagging, and Bulk Operations
Search was a major focus. The previous system required exact filename matches, which meant content was effectively invisible unless you already knew what to look for.
Our search engine normalises strings before matching — so la noire, LA_Noire, and LANoir all resolve to the same result. It searches simultaneously across filenames, tags, and categories, ranked by relevance. Finding a specific video in a library of thousands takes seconds.
Tagging happens inline, directly on the video card. Team members type comma-separated tags, see autocomplete suggestions drawn from the existing tag library and the video's own filename, and save with a single keystroke. No separate page. No save button. No page reload.
Bulk operations allow tag and category assignment across entire filtered result sets — critical for an initial migration of thousands of files.
3. The Telegram Upload Pipeline: From Manual to Fully Automated
This is where the biggest time savings came from.
The upload queue is a persistent FIFO system backed by SQLite. Videos are added to the queue with a single click. The system then takes over completely:
- Caption generation: Tags and category are pulled from the database, formatted as hashtags, and assembled into a properly structured Telegram message. No typing required. No inconsistency.
- Channel routing: The correct channel is determined by the video's category assignment.
- Retry logic: Failed uploads retry automatically with exponential backoff — 5 seconds, 15 seconds, 45 seconds — before marking as failed and alerting the team.
- Large file support: Standard Telegram bots are capped at 50 MB. Our integration with the Telegram Local Bot API Server lifts that to 2 GB, handling full-quality educational videos without compression or splitting.
- Queue persistence: If the machine shuts down mid-session, the queue survives the restart. Processing resumes exactly where it left off.
The entire upload workflow — previously 5–7 manual steps per video — is now one click.
4. Background Video Conversion and Compression
The client's recording software outputs raw .ts files. These need to be converted to .mp4 before they can be uploaded or played in a browser.
We built a serial conversion queue powered by FileConverter CLI with an FFmpeg fallback. Conversions run in a daemon thread, completely in the background, while the web interface stays responsive. Large files are automatically compressed using a preset to meet upload size requirements.
The conversion status is shown live on the video card via polling — the team can see exactly where each file is in the pipeline without refreshing the page.
5. Duplicate Detection and Cleanup
One of the more specific (and time-consuming) problems the team faced was .ts / .mp4 duplicate pairs — original recording files sitting alongside their converted counterparts, taking up storage and creating confusion.
The platform detects these pairs automatically and surfaces them in a dedicated cleanup view. Each pair is shown side by side with hover video previews. The team can verify visually, then delete, move, or batch-convert originals in one operation. A task that previously took hours of manual comparison now takes minutes.
6. HTML5 Video Player with Keyboard Shortcuts
The built-in video player isn't an afterthought. It supports full keyboard navigation — Space to pause/play, N/P for next/previous, ←/→ for 10-second seek, F to favourite, U to queue for upload, E to edit metadata — all designed for a team that's reviewing and processing dozens of videos a day.
A "Shorts mode" enables random video playback with a history stack, useful for content audits and quality checks.
7. Audit Log and Accountability
Every upload, conversion, deletion, tag change, and category assignment is logged. The client now has a complete, timestamped record of everything that's happened to every file in their library. For an organisation distributing content to specific audiences, this isn't just useful — it's essential.
The Tech Stack (For the Developers in the Room)
For teams evaluating similar builds, here's the full stack:
| Layer | Technology |
|---|---|
| Backend | Python 3.12, Flask 3.0, Flask-SQLAlchemy, Flask-Migrate |
| Database | SQLite (WAL mode), Alembic migrations |
| Background Processing | Python threading, daemon threads |
| Video Metadata | FFprobe via subprocess |
| Video Conversion | FileConverter CLI + FFmpeg fallback |
| Telegram Integration | python-telegram-bot 21.4, Local Bot API Server |
| Frontend | Jinja2, Tailwind CSS, Alpine.js, Vanilla JS |
| Auth | Session-based PIN gate (constant-time comparison) |
The architecture is deliberately simple: a single Flask process with threaded=True, two daemon threads for uploads and conversions, and SQLite WAL mode to handle concurrent reads during writes. No Redis, no Celery, no Docker — just Python running on Windows, doing exactly what's needed.
The Results
| Metric | Before | After |
|---|---|---|
| Time spent on content management | 20+ hours/week | Under 2 hours/week |
| Wrong-channel distribution incidents | Multiple per month | Zero since launch |
| Caption consistency | Manual, inconsistent | 100% automated |
| Upload failure recovery | Manual restart | Auto-retry with backoff |
| Conversion workflow | Blocking, manual | Background, non-blocking |
| Duplicate cleanup | Hours of manual comparison | Minutes, automated |
The platform has processed thousands of videos since launch without a single critical failure.
What This Means for Your Business
If your team is managing digital content at scale — whether that's video, documents, media assets, or data files — and relying on a manual workflow to keep it moving, you are paying a tax every single day. That tax is measured in hours, in errors, and in the opportunity cost of skilled people doing work that a well-built system could handle automatically.
Custom software isn't always the answer. Off-the-shelf tools, SaaS platforms, and no-code solutions solve the majority of problems for the majority of businesses. But when your workflow is specific enough, complex enough, and painful enough, a purpose-built internal tool doesn't just save time — it changes what's possible.
We've built systems like this for clients across EdTech, media, logistics, professional services, and finance. The tools vary. The pattern doesn't: map the real workflow, eliminate the manual steps, build for the people who will actually use it.
If you're dealing with a workflow that feels like it should be automated but isn't — or if you're looking for a team that's built exactly this kind of system before — let's talk.
Frequently Asked Questions
Can this system be adapted for content types other than video? Absolutely. The core architecture — file scanning, metadata indexing, tagging, distribution queue, background processing — is applicable to any file-based workflow. We've adapted similar systems for document libraries, image archives, and data pipelines.
Does it require cloud infrastructure? No. This system runs entirely on-premises. All data stays on the client's machine. There's no cloud dependency, no subscription, and no ongoing infrastructure cost beyond the hardware it runs on.
What's the typical project timeline for a build like this? Scoping to delivery on a project of this complexity typically runs 6–10 weeks, depending on the number of integrations and the complexity of the existing workflow.
Do you build on other stacks? Yes. While this project used Python/Flask/SQLite, we build across Next.js, Node.js, React, React Native, FastAPI, Django, PostgreSQL, MongoDB, and more. The stack is chosen to fit the problem, not the other way around.
We are a software development agency specialising in custom automation systems, internal tooling, AI-powered workflows, and full-stack web and mobile applications. We work with businesses that have outgrown off-the-shelf solutions and need software built precisely for how they actually work.
Based in India. Working globally.
