Cost and Trial-and-Error Log Sheet: Spend the Least Money on Your First Trial Run
This page tackles the last hurdle before shooting: getting the AI short drama cost accounting straight. The topic scope statement and route choice statement are done, and one last paper document remains—a cost and trial-and-error log sheet that starts recording from the very first shot, plus a stop-loss line that blocks the "one more pull" urge. This page spends no money and generates no shots; the deliverables are just these two. Once they are written, your pre-production paperwork is complete.
What You Will Be Able to Do After This Lesson
- List the cost items of an AI short drama, labeling each stage as one of three tiers: "points", "time", or "free"
- Calculate the generation count range for the first trial run with "shot count × retry count" (6–60 runs)
- For the local route, convert counts into a time budget (official reference: a 5-second 720P video within 9 minutes on a single GPU); for the cloud route, convert into a point cost budget formula
- Build a cost and trial-and-error log sheet that works for both cloud and local, recording failed attempts as rows too
- Write down a three-line stop-loss rule, knowing the maximum of 3 attempts per shot and when the first run must stop
Your Current Difficulties
- "Cloud AI video platforms charge by points, and I don't know how many points a shot costs, so my finger hovers over the generate button, afraid to press it"
- "Running models locally costs no money, but a shot takes several minutes to wait for, and a few retries eat up a whole evening—does that count as a cost?"
- "Failed shots get deleted on the spot; when the film is done, I can't say how many retries there were or where the money and time went"
When to Use This Technique
You need to:
- Know roughly how many points or how much time the first trial run will cost before generating the first shot
- Make every failure leave a record that becomes experience for your next film
And you don't want to:
- Only remember you never kept accounts after the points are burned up
- Retry the same shot endlessly, still pulling gacha after a whole evening
🎒 Preparation Before Starting
- Have read Cloud Tools or Local Deployment: How to Choose Between the Two Production Routes, with the three-line route choice statement written (cloud or local already decided)
- Know your practice film specs: total length 30–60 seconds (see Original Story Minimum Scope); each shot cut to 3–5 seconds (course design value, expanded in the storyboard lesson)
- Prepare a sheet of paper for drawing tables, Excel/online spreadsheets, or any document you can record things in
- This page only builds sheets and spends no money: no account registration needed, and no shots need to be generated
Core Idea
An AI short drama has only one major cost: the number of shot generations.
Total cost = generation count × per-run cost
Generation count = shot count × attempts per shot (including failed retries)- Cloud route: per-run cost = platform points. Platform prices are unverified; check the official pricing page before registering, and verify against the billing page after generating your first shot
- Local route: per-run cost = time. Official reference: Wan2.2 TI2V-5B without dedicated optimization can generate a 5-second 720P video on a single consumer-grade GPU within 9 minutes (Wan2.2 official repository)
The other stages are either free or one-time investments. The cost list for the entire practice film (this course's teaching template):
| Stage | What to Use | Cloud Route | Local Route |
|---|---|---|---|
| Shot generation (the big cost) | Wan2.2 5B video generation | Points (unverified) | Time: reference within 9 minutes/run (5 seconds 720P) |
| Character images, scene images | Image generation toolchain (expanded in the Assets section) | Points (unverified) | Time (no official reference; record from actual tests) |
| Voiceover | edge-tts: free, calls Microsoft Edge's online service | Free | Free |
| Subtitles | edge-tts directly outputs SRT + FFmpeg burning | Free | Free |
| Editing, volume, export | FFmpeg (local command-line tool) | No per-run fee | No per-run fee |
| Environment (one-time) | ComfyUI installation, model download | None, works in the browser | One-time time investment, not billed per shot |
💡 Free does not mean there are no caveats
edge-tts is free, but its commercial-use terms are not stated in the project documentation; verify them yourself before official release. Detailed steps for voiceover and editing are in the Finish section: Voiceover and Licensing, Editing and Volume Check.
Follow Along
Step 1: List Your AI Short Drama Cost Items
Why: If you don't know which stages cost money, there's no way to prevent overspending. An AI short drama's cost structure is simple—lay it all out first.
Copy the table from the Core Idea section, delete the columns you won't use based on your route statement, then label each row with one of three cost tiers: points / time / free.
You should see: a six-row cost list with the shot generation row circled—it's the only major cost.
- Quick check: you can say "shot generation and reference images cost per run, while the other stages are free or not billed per run"
Step 2: Estimate Generation Counts with "Shot Count × Retry Count"
Why: Per-run cost is either unverified (cloud) or machine-dependent (local), but the generation count can be calculated right now. Work out the upper and lower bounds of the count, and the budget has its skeleton.
First-run generation count estimate (this course's teaching template)
Lower bound of shot count: 30 seconds ÷ 5 seconds/shot = 6 shots
Shot count cap: 60 seconds ÷ 3 seconds/shot = 20 shots
Attempts per shot: 1 (smooth run) to 3 (course retry cap)
─────────────────────────────
Lower bound of generation count: 6 × 1 = 6 times
Upper bound of generation count: 20 × 3 = 60 times
My estimate: ____ shots × ____ times per shot = ____ timesYou should see: a range of counts falling between 6–60, plus an estimated number that belongs to your own story.
- Quick check: the estimated number is written into the document, not just "probably not that many"
Step 3: Convert the generation count into budget units
Why: Cloud and local use different accounting units. Only by converting to each one's per-run cost can your stop-loss line be backed by actual numbers.
Local route (track time):
Local time budget (estimated from official reference upper bound)
Single-run reference: within 9 minutes / 5 seconds 720P (single consumer-grade GPU, no special optimization)
Time budget = generation count × 9 minutes
Example: 12 shots × 2 times on average = 24 times → 24 × 9 = 216 minutes ≈ 3.6 hours
My time budget: ____ times × 9 minutes = ____ minutes9 minutes is the official statement for the scenario of "5 seconds 720P, single consumer-grade GPU, no special optimization"; your actual time spent should be based on the measured record from your first pass.
Cloud route (track credits):
Cloud credit budget
Credits per shot: ____ (check the platform pricing page before signing up; verify on the billing page after your first shot is generated)
Credit budget = generation count × credits per shot
My credit budget: ____ times × ____ credits = ____ creditsYou should see: the local route has a time budget of "____ minutes"; the cloud route has a budget formula of "____ credits", with the unit price left for you to verify with the platform.
- Quick check: the budget numbers match your route declaration — a cloud declaration goes with a credit budget, a local declaration goes with a time budget
Step 4: Build a cost and trial-and-error log table
Why: A budget is an estimate; the log is the truth. Start recording from the very first shot, and once shooting is done you can answer "how much did it actually cost, and where did it go wrong".
Table template (this course's teaching template; columns can be added or removed as needed):
| Date | Shot number | Attempt number | Result | Failure reason / issue | What was changed | Cost (number + unit) | Asset file name |
|---|---|---|---|---|---|---|---|
| 11-05 | shot01 | 1 | Failed | Face inconsistent with character reference image | Added clothing and scene descriptions to the prompt | 9 minutes | shot01_v1.mp4 |
| 11-05 | shot01 | 2 | Usable | — | — | 9 minutes | shot01_v2.mp4 |
Three rules for recording:
- In the cost column, record "number + unit": for local, write "9 minutes"; for cloud, write "12 credits". The unit follows your route declaration — this is how cloud credits and local time can be recorded in one unified table.
- Record failures as a row too: write "Failed" in the result column, and fill in the reason and the change as usual. Asset files can be deleted; records cannot.
- Align file names with the storyboard: the naming convention of shot number_version number is described in Asset Naming and Version Management; retry versions map one-to-one to shot numbers.
Add three summary rows at the end of the table, filled in once per shooting day:
End-of-table summary
Total generation count: ____ times
Total cost: ____ credits or ____ minutes
Usable shots: ____ / ____You should see: an empty table with two teaching example rows, saved into your work folder alongside the topic scope declaration and the route declaration.
- Quick check: you can explain what every column is for, especially the "failure reason" and "what was changed" columns
Step 5: Write down three stop-loss lines
Why: A budget table without stop-loss lines cannot hold back the hand that wants "just one more try". The goal of the first trial run is to get the full pipeline working, not to produce a masterpiece.
My stop-loss lines (this course's teaching template)
Per shot: try at most 3 times; if 3 attempts don't work, go into failure diagnosis to find the cause, or downgrade per the substitution strategy
Whole film: cap the first-pass generation count at ____ times (the upper bound computed in Step 2)
Wallet: for cloud, top up the minimum amount first and only consider adding more after the first shot runs through; for local, record the actual time of each run into the table3 attempts per shot is this course's retry cap. Why 3 times, and how to downgrade after hitting the cap, will be covered in the shot lesson: Shot Retry and Substitution Strategy: At Most 3 Times Per Shot.
You should see: three stop-loss lines written into the document, with numbers matching the estimates from Steps 2 and 3.
- Quick check: read the stop-loss lines out loud — "how many attempts is the cap, what to do when the cap is hit, how much to top up on cloud" — you can say all three sentences
Checkpoint ✅
- The cost list is written out; you can name shot generation and reference images as the per-run costs, with shot generation being the biggest one
- You computed your own generation count range using "shot count × retry count" (between 6–60 times)
- The local route has a time budget (count × 9 minutes reference value); the cloud route has a credit budget formula, with the unit price pending verification with the platform
- The cost and trial-and-error log table is built, and the rule of recording failures as rows is established
- Three stop-loss lines are locked in: at most 3 times per shot, a first-pass cap, and starting with the minimum cloud top-up
Pitfall reminders
❌ Only record successful shots and casually delete failed ones
Symptom: only usable assets remain on your drive; the film is finished, but you can't say how many retries it took.
Reason: The core value of a trial-and-error log lies in those few lines about failure — "why it failed" and "what was changed" are direct experience for your next film; deleting them is like throwing away your tuition.
Correct approach: Fill in one line for every generation, including failures; you may delete asset files, but never the spreadsheet records.
❌ Using other people's price numbers as your budget
Symptom: "Someone online said generating once on a certain platform only costs XX points," so you top up based on that number, and the actual charges don't match.
Reason: This column has not verified the pricing and point rules of cloud platforms; each platform bills differently and may change at any time, so secondhand numbers are unreliable.
Correct approach: Before registering, rely on the platform's official pricing page; after generating your first shot, record the actual consumption from the billing page into your spreadsheet, and budget the rest using your own real-world numbers.
❌ Local and free = no need to keep accounts
Symptom: Running models locally costs nothing, so you simply never build a cost spreadsheet.
Reason: Time is a real cost. Using the official reference upper bound, one generation takes 9 minutes, and a film with 20 shots may take up to 60 attempts in the worst case — that's 9 hours. Without tracking time, you can't judge whether to downgrade or switch to the cloud.
Correct approach: On the local route, treat "minutes" as your accounting unit, just as seriously as tracking points on the cloud.
❌ Trying to burn money for a masterpiece on the first pass
Symptom: No stop-loss line was set, one shot was rolled a dozen-plus times, points and time burned out, and the film is still a half-finished product.
Reason: The goal of the first trial run is to get the full "story → storyboard → assets → shots → final film" pipeline working; until the pipeline works, a polished individual shot is meaningless.
Correct approach: Follow the stop-loss line — at most 3 attempts per shot; once you hit the cap, go to Shot Failure Diagnosis to find the cause or downgrade; cut your first film to completion with the assets you have, and only talk about quality improvement after Graduation Review.
Advanced Tips (Optional)
- Reusing the spreadsheet twice: In the shots course this spreadsheet is the basis for retry decisions (Shot Retry and Replacement Strategy), and in the graduation review it is raw data (Graduation Exercise). The failure records of your first film are the budget basis for your second.
- Mixing the two routes: When your main route is local but individual shots go to the cloud, add a "route" column to the spreadsheet and tally points and time separately, so the review shows clearly which route is more cost-effective.
- Limits of the time reference value: The 9 minutes only corresponds to one specific scenario — "5 seconds 720P, a single consumer-grade GPU, no special optimization"; resolution, length parameters, and GPU model all change the actual time, so for your second film, budget using the measured average from your first film instead.
Lesson Summary
✅ At this point, you have:
- Listed the cost inventory for an AI short drama: shot generation is the biggest per-run cost (reference images come second), while voiceover (edge-tts), subtitles, and editing (FFmpeg) incur no per-run fees
- Calculated the first-pass generation count range using "number of shots × number of retries": 6–60 times
- Converted the counts into a budget: track time locally (official reference: a 5-second 720P video within 9 minutes on a single GPU), track points on the cloud (verify unit prices via the platform's pricing and billing pages)
- Built a cost and trial-and-error log spreadsheet that works for both cloud and local, recording failures too
- Written down a three-line stop-loss rule — with the three pre-production paper documents complete (topic scope statement, route selection statement, and this spreadsheet), you can move on to the story course and start shooting
Quick reference for key numbers:
| Field | Recommended Value | Notes |
|---|---|---|
| Number of shots | 6–20 | 30–60 seconds ÷ 3–5 seconds/shot (course design value) |
| Retry cap per shot | 3 times | Course stop-loss rule, elaborated in the shots course |
| Reference time per generation | Within 9 minutes (5 seconds 720P) | Official repository notes on TI2V-5B |
| Generation count range | 6–60 times | Lower and upper bounds of shots × attempts |
| Cloud point unit price | To be verified | Price not verified; check the official site before registering, reconcile against the bill after the first shot |
| Output of this page | Cost and trial-and-error log spreadsheet + three-line stop-loss rule | This course's teaching template |
Next Lesson Preview
With the paper documents complete, production officially begins. The next lesson moves into the Story and Storyboard section: Story and Storyboard: The Three Documents You Must Deliver Before Shooting.
You will learn:
- How to write the story synopsis, short script, and shot list — and what each one is responsible for
- How to break a 60-second story into individual 3–5-second generatable shots
- How to check continuity between shots before shooting to reduce later retries