The Content Production Workflow: Shipping 60 Videos a Month Without Chaos

Every piece of content that ships, from a fifteen-second Reel to a twelve-minute YouTube explainer, moves through five stages: Plan, Capture, Edit, Approve, Publish. Treat these as gates, not vibes. Each stage has an entry criterion — what must be true before work starts — and an exit criterion — what must be true before it moves on. Skip a gate and you get rework, and rework is the single biggest killer of monthly output, worse than any shortage of filming days or editor hours.

Plan is where the idea becomes a brief: hook, format, length, platform, deadline, and owner. Capture is where raw footage or assets get created and logged. Edit is where a first cut becomes a polished, on-brand asset. Approve is where a named decision owner signs off, with no more than one round of revisions as the default. Publish is where the asset goes live on the right platform, at the right time, with the right caption, and gets logged for reporting.

The reason this matters more than any tool choice: teams that treat production as one blob of work — someone films, someone edits, someone posts it whenever — cannot diagnose bottlenecks. If you cannot say which stage a piece of content is stuck in, you cannot fix your throughput, you can only feel stressed about it. Naming the five stages turns a vague feeling of being behind into a specific, fixable fact: 'we have eleven pieces stuck at Approve.'

Entry criteria matter as much as exit criteria and get ignored twice as often. An editor should never start cutting a video that does not have an approved brief, because half the rework in this industry is an editor guessing at intent. A filmer should never show up to a shoot without a shot list because that is how you end up back on location a second time, burning a day you did not budget for. Gate discipline at entry prevents 80 percent of the pain you would otherwise have to fix at exit.

Here is the failure mode we see in almost every team before they adopt this: work flows backwards. A video gets approved, then someone notices a typo, then it goes back to Edit, then it needs re-approval, then someone tweaks the caption after it is scheduled, then it needs re-approval again. Backwards flow is the enemy. The fix is not perfectionism at every stage, it is clear exit criteria that are actually checked before the asset moves, so it never has to go back.

Map your current pipeline honestly before you change anything. Pull your last twenty published pieces of content and trace how long each one spent in each stage, including the informal back-and-forth. Most teams discover Approve is eating 40 to 60 percent of total cycle time despite being the stage with the least actual work in it. That single measurement will tell you more about where to fix your system than any amount of debate in a planning meeting.

RACI — Responsible, Accountable, Consulted, Informed — sounds like corporate wallpaper until you have watched a video sit unpublished for four days because three people each assumed someone else would post it. In a content operation, the accountable role is the one job title that must never be ambiguous: for every piece of content, one named human is accountable for it going live on time, even if they did not shoot or edit a frame of it.

At one person, you are Responsible and Accountable for everything, which is fine as long as you still run the five stages in order and do not let Approve happen inside your own head with no checklist. Solo operators fail not from lack of skill but from skipping QA because 'I already know what is in it.' Force yourself through the QA checklist below even solo — it catches the caption typo and the wrong aspect ratio every single time.

At three people, split by stage rather than by client or platform: one person owns Plan and Capture, one owns Edit, one owns Approve and Publish, usually the founder or account lead. Rotate who is Consulted (usually the client or subject-matter expert) but never rotate who is Accountable for Publish, because that is the role that catches every dropped ball from the two stages before it. A three-person team without a fixed Publish owner will miss posting slots roughly once every two weeks.

At eight people, you can afford specialisation: a content strategist (Plan), one or two filmers (Capture), two to three editors (Edit), an account manager (Approve, liaising with the client), and a social media manager (Publish, plus community reply). At this size the RACI matrix needs to be a written document, not a shared understanding, because you now have enough people that two of them can each assume the other is Accountable and both be wrong.

The Consulted role deserves more respect than it gets. A subject-matter expert consulted at Plan stage, briefly, for ten minutes, prevents an editor from building an entire video around a claim that is technically wrong and has to be rebuilt from scratch. Consult early and briefly; do not consult late and extensively, which is what happens when the expert is looped in at Approve instead of Plan and asks for a structural change to a finished cut.

Informed is the role most teams forget to design for, and its absence causes the most political damage. When a client-facing account manager finds out a video went live from the client rather than from your own dashboard, trust erodes fast, even if the video was good. Build a habit — a single Slack post, a shared sheet update — that makes every relevant person Informed the moment something publishes. It costs thirty seconds and prevents a genuinely damaging category of surprise.

A content team without a weekly rhythm runs on adrenaline, which works for about six weeks before someone burns out or a deadline gets quietly dropped. The rhythm below is built for a team shipping 15 to 25 pieces a week, roughly the mid-point between a lean three-person operation and a full eight-person studio, and scales down by simply compressing days rather than removing steps.

Monday morning, 9:00 to 10:30: content planning meeting. Review the content calendar for the coming two weeks, confirm briefs are written for everything due to film this week, and flag any brief that is missing information the filmer or editor will need. This meeting has one output: a list of approved briefs with owners and deadlines, not a discussion. If the discussion runs long, that is a sign briefs are being written in the meeting instead of before it.

Monday 10:30 to 1:00 and Tuesday all day: batch capture days. Filming happens in blocks, not scattered across the week — see the next section for why. Wednesday morning: footage logging and ingest, all raw files renamed, backed up, and proxies generated before any editor opens a project file. Wednesday afternoon through Friday midday: editing block, with editors working from a shared queue ordered by publish deadline, not by whichever brief looks most interesting.

Friday 1:00 to 3:00: batch review and approval window. This is the only scheduled slot in the week for the Approve stage, and it is deliberately time-boxed. Everything due for feedback goes through in this window using timecoded comments, one round, decision owner signs off by end of day. Content approved by Friday close gets scheduled Monday morning for the following week — never approved and published in the same rushed hour, which is how QA gets skipped.

The following Monday, before the planning meeting, 8:00 to 9:00: publishing and scheduling block. Everything approved the previous Friday gets its final QA pass, captions finalised, and gets loaded into the scheduler for the week ahead. This means content is never being edited, approved and published on the same day it needs to go live — there is always at least a weekend of buffer, which absorbs the inevitable one urgent revision without blowing the deadline.

This rhythm only works if batching is respected. The single most common way teams break it is letting 'quick' ad hoc requests interrupt the editing block — a client wants one urgent video Wednesday afternoon. Build a small reserved capacity, roughly 10 to 15 percent of weekly editor hours, specifically for these interruptions so they do not cannibalise the scheduled queue. Unplanned urgent work that eats planned capacity is the single most common reason a monthly volume target gets missed two weeks running.

Filming one video on Monday, one on Wednesday and one on Friday feels efficient because each shoot is 'quick,' but it is one of the most expensive habits in a content operation. Every individual shoot carries fixed overhead — setting lights, checking audio, briefing talent, tearing down — that does not shrink because the shoot is short. Three scattered 90-minute shoots across a week cost roughly the same total setup time as filming eight videos in a single half-day block.

Batch filming means grouping everything that needs the same location, talent, or setup into one session and shooting multiple pieces of content back to back. A single half-day batch shoot with one presenter in one location can realistically produce raw footage for 6 to 10 short-form videos if the briefs are written in advance and the shot list is ordered to minimise wardrobe or lighting changes. That is a week's worth of short-form output from one afternoon.

The prerequisite for batch filming is that every brief exists before the camera turns on. Trying to batch-film with briefs half-written on the day is how you end up with eight minutes of unusable rambling per video instead of a clean 45-second piece. Send briefs 48 hours before the shoot, confirm talent has read them, and build a running order that groups similar setups — all sit-down interview segments together, all b-roll together, all product-in-hand segments together.

Log footage the same day you shoot it, not the day before the edit is due. A same-day ingest habit — renaming files, generating proxies, writing a one-line description of what is in each clip — takes 20 to 30 minutes per hour of raw footage but saves an editor two to three hours of scrubbing through unlabelled clips later. Teams that skip same-day logging accumulate what we call footage debt, covered in detail later in this piece, and it compounds fast.

Plan for one batch shoot to generate a fixed multiple of raw footage relative to finished output, and use that multiple in your capacity planning rather than guessing per shoot. For talking-head short form, expect 8 to 15 minutes of raw footage per finished 45-second video once you include false starts, alternate takes and safety shots. For longer-form interview or documentary style content the ratio climbs to 20 to 40 minutes of raw per finished minute. Know your ratio; it is the single most useful number in this entire post for predicting editor workload.

Build a repeatable pre-shoot checklist and use it every single time, including the tenth time you have filmed with the same presenter in the same room. Batteries charged and spares packed, memory cards formatted and spares packed, audio recorder tested with a slate clap for sync, lighting checked against last session's reference photo for consistency, shot list printed or on a tablet, briefs confirmed read by talent. A five-minute checklist prevents the single worst outcome in content production: unusable footage that cannot be recovered without reshooting.

Vague folder structures are a tax you pay every single day, forever, until you fix them once. The cost of a bad structure is not obvious in week one; it shows up in month three when an editor spends forty minutes hunting for 'the good b-roll from that shoot with the founder' because nobody wrote down which shoot that was or where its footage lives. Fix this once, in writing, and enforce it — do not let it evolve organically per project, because organic evolution always drifts toward chaos.

Top-level structure, one folder per client or brand, then one folder per month, then one folder per project within that month. Literally: 01_Clients / ClientName / 2026-07_July / Project_ProductLaunch_ShortForm. Inside each project folder, five fixed subfolders every time, no exceptions: 01_Raw, 02_Proxies, 03_Project_Files, 04_Exports, 05_Assets. Anyone on the team should be able to find any file within fifteen seconds without asking a colleague, and that fifteen-second test is the actual bar you are building to.

File naming for raw footage: YYYYMMDD_ClientCode_ShootType_CameraID_TakeNumber. As a literal example: 20260714_MSL_Interview_CamA_003.mp4. This tells anyone, at a glance and without opening the file, when it was shot, for which client, what kind of shoot it was, which camera captured it, and which take it is. Never name raw files 'IMG_4821' or 'final_take_good_v2' — those names carry zero information and force someone to open the file to learn anything about it.

File naming for edited exports: ClientCode_ProjectName_Platform_Version_Date. Literal example: MSL_ProductLaunch_Instagram_v3_20260722. Version numbers increment only on substantive changes that were requested through the approval process, never on trivial fiddling — an editor should not create v14 because they nudged a caption two pixels. If you find yourselves at v9 or higher on a single short-form video, that is not a naming problem, that is a sign your approval process from the next section has broken down.

Project files themselves — your editing software's native project files — live in 03_Project_Files and are never, under any circumstances, the only copy of anything important. The project file references the proxies and raw media by path; if someone renames a folder outside the editing software, every project file referencing it breaks. This is why the folder structure has to be locked in before editing starts, not adjusted mid-project — a mid-project folder rename is one of the most common causes of a lost afternoon in any editing team.

Archive completed months rather than deleting them. Move a full month's folder to a Cold_Archive location once every asset in it has published and been logged, keeping your active working drives lean and fast, while the archive preserves everything for repurposing later — old b-roll is often the fastest source of content for a slow week. Never delete raw footage within the first twelve months; the cost of storage is far lower than the cost of a client asking for a reshoot of something you already have.

Editing directly off raw 4K or higher footage on a shared network drive is one of the most common causes of a slow, laggy editing experience that makes editors dread opening the project file. Proxies — lower-resolution copies of the same footage used for the actual editing process, then swapped back to full resolution only at export — solve this, and generating them should be a mandatory ingest step, not an optional one for when a machine feels slow.

Generate proxies at ingest, same day as the shoot, using a consistent codec and resolution across the whole team — we use ProRes Proxy or a comparable low-bitrate codec at half resolution for most social content, stepping up to quarter resolution for large multi-camera shoots. Store proxies separately from raw media in the 02_Proxies folder from the structure above, and make sure every editor's software is configured to default to proxy mode so nobody accidentally edits against a 4K file over a slow connection.

Now the storage maths, because 'we'll figure out storage later' is how teams end up with a full drive on a Friday afternoon. A single hour of raw 4K footage at a typical social-content bitrate runs roughly 25 to 40GB depending on codec and frame rate; a typical batch shoot day generating 4 to 6 hours of raw footage therefore produces 100 to 240GB of raw media per shoot day. At two shoot days a week, that is 800GB to 1.9TB of raw footage per month, before proxies, project files or exports.

Add proxies at roughly 10 to 15 percent of raw file size, project files and cache at another 5 to 10 percent, and exports at a modest but non-trivial addition depending on how many versions you keep. A realistic total monthly storage footprint for a team producing 40 to 60 finished short-form videos a month, from two batch shoot days a week, lands between 1.2TB and 2.6TB per month. Plan drive purchases and cloud storage budgets against that range, not against last month's actual usage, because volume grows.

Backup discipline follows the 3-2-1 rule without exception: three copies of every piece of raw footage, on two different types of storage media, with one copy stored off-site. In practice this means raw footage lands on a local fast working drive, gets mirrored to a network-attached storage device same day, and syncs to a cloud backup service overnight. Never let 'we'll back it up this weekend' become the plan — footage that exists in only one place is footage that does not exist, as far as risk management is concerned.

Set a retention and rotation policy rather than buying storage forever. Raw footage older than twelve months moves to cheaper cold archive storage, ideally an off-site or cloud-cold-tier option, rather than sitting on expensive fast drives. Proxies and project files for anything published and archived can be deleted after six months since they can be regenerated from raw if ever needed. This single policy typically cuts active working-drive storage costs by 30 to 40 percent without any risk to your ability to recover footage.

A shared media library is the single highest-leverage asset a content team can build and the one most commonly left unbuilt because it feels like overhead rather than output. It is a centrally located, well-tagged collection of reusable elements: brand b-roll, licensed music tracks cleared for use, motion graphics templates, lower-thirds, intro and outro stingers, sound effects, and stock footage the team has already vetted for quality and licensing. Every editor pulls from the same library instead of re-sourcing or re-creating the same assets project after project.

Structure the library by asset type first, then by client or brand: 01_Music, 02_SFX, 03_Motion_Templates, 04_Stock_BRoll, 05_Brand_Assets. Tag every asset with searchable keywords in the filename or a lightweight spreadsheet index — mood, tempo, and use case for music; subject and setting for b-roll — because a library nobody can search is functionally the same as no library, just with extra steps and false hope.

A brand kit is the non-negotiable reference document every editor opens before touching a new client's footage: exact hex codes for brand colours, the specific font files (not just font names, since licensing and version differences cause rendering mismatches), logo files in every format needed, a locked-down colour grade LUT if the brand has one, and 8 to 10 example frames showing correct brand application. Without a written brand kit, style drift — covered later — starts on day one, not month three.

Caption styles need the same rigour as visual branding, and get less of it. Define, in writing, the font, size, colour, position, animation style (if any), and maximum line length for captions on each platform the brand uses, because a caption style that works at 1080p landscape on YouTube often looks wrong cropped to 9:16 for Reels. Keep a caption style guide as a one-page reference sheet, not a memory every editor is expected to carry around.

Templates are where the real time savings live. Build a locked editing project template for each recurring content format — a talking-head short, a listicle-style carousel-to-video, a testimonial edit — with the sequence settings, brand elements, lower-thirds, intro and outro already placed and locked, so an editor drops raw footage in and starts cutting rather than rebuilding brand elements from scratch every single time. A well-built template can cut edit time on a recurring format by 30 to 50 percent.

Assign one person as the librarian, even part-time, whose job is reviewing new assets before they enter the shared library and rejecting anything mislabelled or duplicated. Without an owner, shared libraries decay within about two months into a dumping ground with fourteen versions of the same intro stinger and no way to tell which one is current. The librarian role takes perhaps two hours a week and saves the whole team far more than that in avoided searching and re-creating.

Every content team has lived through the fourteen-message feedback thread: 'can we make the text bigger,' followed by 'actually maybe smaller,' followed by 'what did we land on,' followed by someone approving a version that was three versions old. This is not a communication problem you fix with a nicer tone. It is a structural problem — feedback with no format, no limit, and no named decision-maker — and it needs a structural fix, not a plea for people to 'just be clearer.'

Rule one: all feedback is timecoded and specific, given inside a review tool that supports frame-accurate comments — not in a chat app, not as a voice note, not as a bullet list emailed after the fact. 'The pacing feels off around the middle' is not actionable; '0:14 to 0:19, cut two frames off this clip, it drags' is. If your current tool cannot do timecoded comments on video, that is worth fixing before almost anything else in this list, because it removes the single biggest source of ambiguity in the whole approval stage.

Rule two: one round of revisions is the default for every piece of content, agreed with the client or stakeholder in advance, not negotiated in the moment when the feedback arrives. This does not mean quality suffers — it means all feedback for a given cut gets consolidated into a single batch before it goes back to the editor, rather than trickling in as five separate messages across three days, each one bouncing the editor out of focused work and back into the same three-minute cut.

Rule three: exactly one named decision owner per piece of content, whose sign-off is final. Committees do not approve videos; people do. When multiple stakeholders want input, collect their feedback and have the decision owner reconcile conflicting notes before it reaches the editor — an editor should never receive two contradictory instructions from two different people on the same cut and be left to guess which one wins. Naming the decision owner in the brief at Plan stage, not at Approve stage, prevents this entirely.

Rule four: silence is not approval, but a deadline is. Build a default sign-off window — 24 or 48 hours is typical — after which, if no feedback arrives, the content is treated as approved and moves to Publish. This single rule eliminates the most common cause of missed posting slots we see in client accounts: content sitting in someone's inbox, technically 'awaiting feedback,' for six days, with nobody willing to escalate because escalating feels awkward.

Rule five: track every piece of content's approval status in one visible place — a shared sheet or board column, not a scattered set of email threads — so anyone can see at a glance what is Awaiting Feedback, In Revision, or Approved, and how long it has sat in that state. A simple visible ageing indicator — flag anything in Awaiting Feedback for more than 48 hours in red — turns a passive bottleneck into an active, visible problem someone will actually chase.

Publishing is the stage most likely to be treated as an afterthought — 'just post it' — and it is exactly the wrong stage to wing, because a single wrong setting can quietly cap a video's reach with no visible error message. Build a standard operating procedure for publishing and follow it every single time, for every platform, even the tenth time this week, because the tenth time is exactly when someone gets complacent and skips the caption check.

Instagram: Reels should be exported at 9:16, 1080x1920, with captions burned in or added via native captions rather than relying on auto-generated ones, since Instagram's auto-captions still make embarrassing errors on brand names and jargon. Post covers matter more than most teams treat them — set a custom cover frame rather than letting the platform grab a random frame that might catch someone mid-blink. Hashtags belong in the caption or first comment, capped at 3 to 5 relevant ones; the twenty-hashtag spray approach is outdated and does nothing for reach on current algorithms.

TikTok: native upload beats cross-posting from other platforms almost every time, because the platform's algorithm appears to deprioritise content carrying watermarks or metadata from competing apps. Keep text overlays inside the safe zone, roughly the middle 80 percent of the frame, since the caption bar, profile icons and engagement buttons cover the outer edges. Post timing matters less than consistency of posting; a fixed daily or near-daily cadence outperforms sporadic bursts even when the sporadic bursts include objectively better content.

YouTube, including Shorts: write a real title and description with the primary keyword phrase in the first sentence of the description, not just the title, since search visibility on YouTube still weights described content heavily. For long-form, set a custom thumbnail every time — never use the auto-selected frame — because thumbnail click-through is one of the few metrics that still directly influences how much distribution a video gets in the following 48 hours. For Shorts, treat the first frame as the thumbnail since Shorts do not support custom thumbnails.

LinkedIn: native video uploads dramatically outperform shared YouTube links in reach, because the platform suppresses posts that route traffic off-platform. Keep captions professional but specific — a genuine number or result in the first two lines outperforms generic framing. LinkedIn's algorithm rewards early engagement heavily in the first 60 to 90 minutes after posting, so schedule for a time when your actual audience, not a generic 'best time to post' chart, is demonstrably online, based on your own account's historical engagement data.

Build a publishing checklist that must be physically ticked off, not just remembered, before anything goes live: correct aspect ratio confirmed, captions checked for accuracy including brand names and numbers, cover or thumbnail set deliberately, caption copy proofread for typos and correct links, hashtags or keywords added per platform convention, and the piece logged in the tracking sheet with its live URL. Every single skipped checklist item we have seen traced back to a real, avoidable mistake going live in front of an audience.

Quality assurance is not a vibe check where someone watches the video once and says 'looks good.' It is a specific, repeatable checklist run against every single piece of content before it goes live, ideally by someone other than the editor who cut it, because editors who have watched their own cut fifteen times stop seeing its problems. Fresh eyes catch what familiar eyes miss, every time, without exception.

Technical checks first: correct resolution and aspect ratio for the destination platform, audio levels consistent throughout with no jarring jumps between clips, no black frames or flash frames left in from editing mistakes, text and captions fully legible on a small phone screen — check on an actual phone, not just a desktop monitor, since text sized correctly on a 27-inch screen frequently disappears on a 6-inch one. Export settings matched to platform specification, not just 'whatever the default was.'

Brand checks second: colours match the approved brand kit, logo placement and sizing consistent with previous content, fonts are the actual approved brand fonts and not a substitute the software swapped in silently when a font file was missing, lower-thirds and any recurring graphic templates used correctly and consistently with the rest of the content library. Brand drift catches teams off guard because each individual instance looks fine in isolation; it is only visible when you compare ten pieces side by side.

Content accuracy checks third, and this is the one most often skipped under deadline pressure: every name, statistic, date, and claim spoken or shown in the video is factually correct and matches the approved brief, every on-screen text overlay is spelled correctly, and any pricing, offer, or call-to-action mentioned is current and has not been superseded since the brief was written. A wrong statistic in a published video is far more damaging to credibility than a slightly late post, and far more expensive to walk back publicly.

Platform-specific checks fourth: captions or subtitles present and accurate where required, link-in-bio or swipe-up destination confirmed live and correct before the post goes up rather than after, hashtags and tags appropriate and not accidentally including a competitor's brand handle, cover image or thumbnail set deliberately rather than defaulted. Test any clickable element yourself, in the actual app, before publishing, because a broken link discovered by a customer is a worse outcome than a five-minute delay discovered by you.

Assign QA as a distinct task on the tracking sheet with its own owner and its own tick-box, separate from editing and separate from approval. Do not let 'approved by the client' substitute for QA — clients approve creative direction and messaging, not export settings or aspect ratios, and expecting them to catch a technical error is asking them to do a job that is not theirs. A five-minute QA pass, done consistently, prevents the overwhelming majority of embarrassing post-publish corrections.

A content tracking sheet is not a nice-to-have dashboard for a monthly report; it is the operational nervous system that tells everyone, at any moment, what is happening across every piece of content in flight. Build it as a single source of truth that every role checks daily, and resist the temptation to fragment it across multiple tools — a tracking system split between a project management app, a spreadsheet and a shared drive is a tracking system nobody fully trusts.

Core fields every row needs: content ID (a short unique code, not just a title, so it survives renaming), title or working name, format and platform, brief link, status (Planned, Filming, Editing, Awaiting Feedback, In Revision, Approved, Scheduled, Published), owner at current stage, deadline date, and date it actually entered the current status. That last field is what lets you calculate time-in-stage, which is the single most useful metric in this entire operation for spotting a developing bottleneck before it becomes a crisis.

Add a raw footage location field and an edited file location field directly in the tracking sheet, linking to the actual folder from the structure defined earlier, so nobody has to ask 'where is this' in a separate message. Add a revision count field that increments each time content goes back for another round — if you see a 4 or 5 appear here regularly, that is a direct, measurable signal that your approval rules from earlier in this piece are not being followed.

Add performance fields for after publish: platform, publish date, and a simple set of metrics pulled a week and a month after going live — views, engagement rate, saves or shares, and any conversion metric relevant to the client's goals. This turns the tracking sheet from a pure production tool into a feedback loop that informs the next Plan stage: formats and hooks that performed well get more of the same treatment, formats that underperformed get retired or reworked rather than repeated on habit.

Colour-code status visually — reserve red specifically for anything past its deadline or sitting in Awaiting Feedback beyond the 48-hour window from the approval rules — so a glance at the sheet tells a manager where to intervene without reading every row. A sheet where everything is colour-neutral text forces someone to read fifty rows to find the two that need attention; a sheet with visual urgency coding surfaces the two that matter in about three seconds.

Review the tracking sheet as a standing five-minute agenda item in your Monday planning meeting, specifically scanning for anything red, anything with a revision count above two, and anything that has sat in the same status for more than five working days. This five-minute habit, done every single week without fail, catches the vast majority of developing problems while they are still small and cheap to fix, rather than after they have become a missed deadline the client is asking about.

Capacity planning in content production comes down to two numbers most teams have never actually calculated: minutes of raw footage per finished minute, and finished minutes an editor can produce per week at sustainable pace. Guess at either number and your monthly targets are fiction. Measure both from your own last month of actual output, not from an industry benchmark someone quoted in a blog post, because your ratios depend heavily on your format, your presenter, and your editor's speed.

To calculate raw-to-finished ratio: take your last ten published pieces, log the total raw footage duration used as source for each one against its finished duration, and average it. For most short-form talking-head content the ratio lands between 10:1 and 20:1 — ten to twenty minutes of raw footage for every finished minute. Heavily scripted content with tight delivery can be as low as 5:1; loosely structured interview content can run 30:1 or higher. Know your actual number; it is the input for everything else in this section.

To calculate editor throughput, track actual hours spent per finished minute of output across a representative sample of recent work, separating simple cuts (a single talking head, minimal graphics) from complex ones (multi-camera, heavy motion graphics, sourced b-roll). A realistic sustainable pace for a mid-level editor on simple short-form content is 2 to 4 finished minutes per eight-hour day; for complex long-form work with heavy graphics, that can drop to 20 to 40 finished minutes per week, not per day.

Multiply through to get monthly capacity: an editor working a standard week at 2 to 4 finished minutes of simple short-form content per day, five days a week, four weeks a month, produces roughly 40 to 80 finished minutes of content monthly, which at typical 45 to 60 second short-form lengths translates to somewhere between 40 and 100 finished short videos per editor per month, assuming templates and a shared library are in place to remove repetitive setup work.

This is the calculation that tells you honestly whether 'we need to hit sixty videos a month' is a staffing problem or a process problem. If your current team's measured throughput comes to 35 videos a month at full capacity and the target is sixty, no amount of hustle closes that gap — you need another editor, better templates to lift per-editor throughput, or a lower per-video complexity target. Teams that skip this maths default to asking existing staff to simply work faster, which produces burnout and declining quality, not sustainable volume.

Build in a buffer of 15 to 20 percent below theoretical maximum capacity when setting monthly targets, to absorb revisions, urgent ad hoc requests, sick days, and the inevitable reality that not every week runs at textbook efficiency. A team that plans to exactly its calculated maximum capacity will miss its target most months, not because the maths was wrong but because maths describes an average and reality includes variance that a buffer is specifically there to absorb.

A new editor's first two weeks determine whether they become a reliable throughput contributor in month one or a drag on the whole team's output for the first quarter while everyone repeatedly explains the same conventions informally. A structured five-day onboarding, run the same way every time a new editor joins, converts a vague 'get settled in' period into a measured, predictable ramp with a clear point at which they start contributing real output.

Day one: access and orientation. Set up all software licenses, shared drive and library access, and the tracking sheet permissions before the editor's first hour, not scrambled together as they wait. Walk through the folder structure and naming conventions from this document literally, file by file, on a real example project, not in the abstract. End day one with the editor able to locate any asset in the shared library and correctly name a test export without help.

Day two: brand and style immersion. Work through the brand kit and caption style guide in detail, then have the new editor build a full test edit using a locked project template and existing approved footage from the library, purely as a training exercise that will not be published. Review this test edit together against the brand and technical QA checklists, treating every miss as a teaching moment rather than a mark against them — this is a rehearsal, not a real deadline.

Day three: process immersion. Walk through the five-stage pipeline, the RACI for their specific role, the approval rules including timecoded feedback and the one-round default, and the weekly operating rhythm they will be joining. Have them shadow a real approval session this week, watching how feedback gets given and consolidated, so the abstract rules from a document become a concrete, observed reality before they are relying on it themselves.

Day four: first real assignment, on a low-stakes piece with generous deadline buffer, ideally a format they have already practised in the day-two test edit. Pair them with a senior editor available for questions throughout the day rather than leaving them to struggle silently and miss the deadline out of reluctance to ask. The goal of day four is a real, published piece of content, however small, that carries their name as the editor of record.

Day five: review and calibration. Walk through the day-four piece from brief to publish, comparing actual time spent against the throughput benchmarks from the capacity planning section, and set explicit, written expectations for the coming month: target throughput ramping from roughly 50 percent of full pace in week two to full expected pace by week four. Schedule a 30-day formal check-in now, on the calendar, rather than leaving it to happen informally or not at all.

Automation gets pitched as a universal good in content operations, but half the automations teams build save five minutes a week while costing five hours a month in maintenance when the underlying tool changes its interface. Build automations only where a task is genuinely repetitive, high-frequency, and low-judgment — the automation candidate should be something a competent junior could do correctly with zero context, because that is exactly what the automation is going to do.

Worth building: automatic proxy generation triggered the moment raw footage lands in the ingest folder, removing the manual step entirely rather than relying on someone remembering to run it. Worth building: automatic status updates in the tracking sheet when a file moves folders — from 02_Proxies to 04_Exports, for instance — flipping the status field without anyone manually editing the sheet, which also removes a common source of the sheet silently going stale.

Worth building: automatic Slack or Teams notification when a piece of content sits in Awaiting Feedback past the 48-hour window from the approval rules, pinging the decision owner directly rather than relying on someone noticing the red flag on the tracking sheet during the weekly review. This single automation, on its own, often recovers several missed posting slots a month for teams that previously relied purely on someone remembering to check.

Worth building: a templated brief generator, a simple form that produces a correctly formatted brief document with all required fields present, removing the common failure where a brief gets sent missing the platform, the deadline, or the decision owner because it was typed freehand under time pressure. This is a low-effort build, often just a spreadsheet template or a basic form tool, and it directly prevents the entry-criteria failures discussed in the pipeline section.

Not worth building, in most cases: fully automated cross-posting that publishes the identical asset, identically formatted, to every platform simultaneously. Platform quirks covered earlier — safe zones, caption styles, native upload preferences — mean identical cross-posting produces a mediocre result everywhere rather than a good result anywhere, and the time saved rarely offsets the measurable drop in performance per platform. A human five-minute platform-specific pass beats full cross-post automation almost every time we have tested it against a client's own data.

Not worth building, for most teams under about 40 videos a month: complex AI-driven auto-editing pipelines that attempt to fully assemble a rough cut without human input. The technology exists and improves constantly, but at moderate volume the time spent configuring, correcting and re-training these systems typically exceeds the time a competent junior editor would spend doing the same rough cut manually. Revisit this calculation as your volume grows past the point where the setup cost amortises across enough output to be worth it.

Three failure modes account for the overwhelming majority of content operations that stall out despite having capable people and reasonable tools. Approval bottlenecks, footage debt, and style drift each look like a different problem on the surface — a slow client, a messy drive, an inconsistent editor — but all three trace back to a missing structural rule, and all three have a specific, known fix rather than requiring a vague call to 'communicate better.'

Approval bottleneck: content piling up at the Approve stage while Edit and Capture keep producing more, because feedback has no deadline and no single decision owner. The visible symptom is a tracking sheet with a growing column of items stuck in Awaiting Feedback, sometimes for weeks, while editors either sit idle waiting for direction or, worse, keep producing new work that will hit the same jam. The fix is everything in the approval section above, applied without exception: named owner, timecoded feedback, one round, a hard sign-off deadline with silence defaulting to approval.

Footage debt: raw footage accumulating unlogged, unnamed and unindexed because same-day ingest got skipped under deadline pressure, until nobody can find or remember what footage exists without scrubbing through hours of unlabelled clips. The symptom is editors repeatedly saying 'I think we filmed something like this before but I cannot find it,' followed by an expensive reshoot of something the team already owns. The fix is enforcing same-day ingest as a hard entry-criterion gate at the Edit stage — an editor should not be allowed to start cutting from unlogged footage, ever.

Style drift: individual pieces of content each look acceptable in isolation but the brand's overall visual identity slowly diverges across the library, usually because the written brand kit is thin, out of date, or simply not consulted before each project. The symptom shows up specifically when someone puts ten recent pieces side by side and notices three different caption fonts, two slightly different colour treatments, and inconsistent logo placement, none of which any single editor did wrong in isolation.

The fix for style drift is a living brand kit reviewed and updated at least quarterly, plus a mandatory brand-check step in the QA checklist that specifically compares new output against a recent reference piece, not just against the written brand kit document in the abstract. Written documents drift out of sync with reality faster than most teams expect; a side-by-side visual comparison against actual recent output catches divergence a document alone will miss.

All three failure modes share a root cause worth naming explicitly: a missing or unenforced gate at one of the five pipeline stages. Every fix in this section is, underneath the specific language, the same instruction — define the entry and exit criteria for the stage where the failure occurs, and refuse to let work pass through without meeting them. Teams that internalise this one idea can usually self-diagnose and fix a new failure mode they have not seen before, without needing a new rule invented for every new problem.

Scaling from 8 to 60 finished videos a month is not a matter of hiring seven times the editors and hoping the existing process holds; the process itself has to change shape at several points along the way, and trying to scale headcount without scaling process is the most reliable way we have seen teams hit a wall at around 20 to 25 videos a month and stay stuck there for months.

At 8 videos a month, a single generalist can plausibly run the whole pipeline solo or with light support, filming, editing and publishing everything themselves with the five-stage discipline from this document but without much formal structure beyond a simple tracking sheet. The main risk at this volume is inconsistency creeping in from lack of written standards, since one person can hold everything in their head, right up until they cannot.

At around 15 to 20 videos a month, the volume typically outpaces one person's editing throughput even at strong per-editor pace, and this is the point to bring in a second editor and formalise the folder structure, naming conventions and brand kit in writing rather than relying on shared memory. This is also the point where a proper tracking sheet, not a mental list, becomes non-negotiable, because two people coordinating informally lose track of handoffs that one person never had to hand off at all.

At around 25 to 35 videos a month, batch filming days become mandatory rather than optional, because scattered ad hoc shoots cannot generate footage fast enough to feed two or more editors' throughput. This is also typically the point to introduce a dedicated Approve and Publish owner separate from the editors, since editors context-switching into scheduling and platform QA between edits measurably drags down their editing throughput, the exact opposite of what you need at rising volume.

At around 40 to 50 videos a month, template maturity stops being a nice-to-have and becomes the difference between hitting target and missing it, because at this volume the cumulative time saved by locked templates and a well-maintained shared media library is the single largest lever available, larger than adding another editor. This is also the point where the automations covered earlier — proxy generation, status flips, escalation pings — start paying for their setup cost many times over each month.

At 60 videos a month and beyond, the operation needs the full eight-person structure from the roles section, a formally documented RACI, and a genuinely enforced weekly rhythm with reserved buffer capacity for urgent requests, because at this scale informal coordination fails constantly and expensively — a single missed handoff at this volume can cascade into a dozen late pieces of content in a single week, whereas the same missed handoff at 8 videos a month would cost a single delayed post.

Do not try to install every rule in this document simultaneously; teams that attempt a full rebuild in one week burn out on process before it produces any benefit and abandon the whole system by week three. The plan below spreads implementation across four weeks, each with a specific, checkable milestone, front-loading the changes with the highest immediate payoff and lowest disruption cost, and saving the more disruptive structural changes for once the team has some early wins under its belt.

Week one: measurement and foundations. Audit your last twenty published pieces to measure actual time-in-stage across the five pipeline stages and calculate your real raw-to-finished ratio and editor throughput from the capacity planning section. In parallel, build the folder structure and naming conventions and migrate your active projects into it — do not attempt to migrate your entire historical archive in week one, that can happen gradually over the following months. Milestone: a written baseline report and a clean, enforced folder structure for all new work going forward.

Week two: approval and tracking. Install the approval rules in full — named decision owner on every brief, timecoded comments only, one revision round, a hard sign-off deadline with silence defaulting to approval — and build or overhaul your tracking sheet with the core fields from the tracking section, including status, time-in-stage, and revision count. Run your first Friday time-boxed approval window this week. Milestone: every piece of content currently in flight has a named owner and a visible status in one shared sheet.

Week three: rhythm and capacity. Install the weekly operating rhythm from this document, including the Monday planning meeting, batch capture days, and the Wednesday ingest block with mandatory same-day logging and proxy generation. Compare your measured capacity from week one against your monthly volume target and adjust the target, add capacity, or both, rather than proceeding on hope. Milestone: one full week run entirely on the new rhythm, with real batch filming days in place of scattered shoots.

Week four: quality, templates and review. Roll out the full QA checklist as a mandatory, tracked step separate from editing and approval, and build or update your brand kit and at least two locked project templates for your most common recurring formats. Hold a full retrospective against the four weeks: which rules held, which broke down under real conditions, and which specific numbers from week one's baseline have measurably improved. Milestone: a documented, working system your team can describe accurately to a new hire without you in the room.

Beyond day 30, revisit the whole system quarterly rather than assuming it is finished. Re-run the time-in-stage audit from week one every quarter to catch drift back toward old habits, review the brand kit for staleness, and re-calculate capacity and throughput as your team and tools change. A production system is a living document that needs the same discipline applied to maintaining it that you applied to building it, or it degrades quietly back toward the chaos it was built to replace.