Crehana: automating an e-learning content operation

A lot of operational problems look like people problems until you can see the system.

When I arrived at Crehana, nobody could tell me how many courses were in production without asking several people, opening several spreadsheets, and piecing the answer together. When I left, a dashboard could tell you in real time, and so could everyone else.

That became the pattern for almost everything I worked on: see it, centralize it, automate it, then cut what’s left over. Rather than adding people to a process that was difficult to understand, I wanted to understand the system first, then make the system do more of the work.

Crehana is an online education company in Latin America. I spent about three years there, first from the outside and then running production, turning a content operation that ran on memory into one that ran on a system.

$ python production_plan.py
reading the board from Jira...
✓ 214 courses tracked · 0 stuck over 48h · plan posted

Two launches that ran on heroics

I didn’t start inside Crehana. In 2021 I came in from the outside, contracted through BueHub to launch their dubbing division. That meant hiring and running a remote team of more than 25 people across Argentina and Brazil, working in Spanish, Portuguese, and English.

It worked, so it turned into the next thing. In 2022 I led the Brazil launch, this time from inside the company: more than 200 courses produced in Portuguese in about six months.

Both of those ran on people. Long hours, tight coordination, and somebody always holding the whole picture in their head. That’s the part worth being honest about. It worked, and it didn’t scale. You can’t hire your way out of a process problem forever.

TAKEAWAY: heroics are a real strategy for about six months. After that they are a liability, because the operation now depends on the people who can perform them.

See it

The first thing I built wasn’t automation. It was dashboards.

Real-time views in Looker Studio and Metabase across the whole pipeline: how many minutes were in production, where courses were stuck, how long corrections took, how the budget tracked against the plan. Before that, the answer to most questions was a guess delivered in a confident voice.

Once the numbers were on a screen instead of in a rumor, the bottlenecks named themselves. Nobody had to be talked into believing that corrections were the problem. You could see that corrections were the problem.

Recreated for this post. The growth ratios are faithful; Crehana’s raw internal numbers are not shown.

TAKEAWAY: you can’t improve what you can’t see. Build the instrument before you touch the engine.

Centralize it

Then I moved the whole workflow into Jira and made it the only place the work lived. Here’s what that bought.

Six stages, one board. Production plan, backlog, documents, QA documents, sourcing, production. A course moves through them in order.
One source of truth. The spreadsheets went away, and so did a Notion board that had quietly stopped being true months earlier.
Clear handoffs. Every stage has an owner and a due date, so work stopped falling into the gap between two departments.
An SLA on every stage. Once a stage has an owner and a date, you can say what late means, and the board says it instead of a person.

That one change did more than any script I wrote. When every team reads the same board, the meetings about who has what stop happening.

Automate it

With the work visible and in one place, the repetitive steps were easy to hand to software. Jira, Python, and Google Sheets did nearly all of it.

Assign a reviewer by category.
Submit a course for review, and pull it back when the review is done.
Track scores and launch progress.
Publish the upcoming launch calendar straight off the board, instead of someone rebuilding it by hand every week.
Notify the next owner when a stage changes hands, and send the instructor their update over Slack and email.
Break down cost per course, so the numbers arrived without anyone assembling them.

Not all of it was software. I supervised a set of Premiere templates for the editing team, so a first cut started from a finished structure instead of a blank timeline. First cuts got faster, and corrections got faster with them.

The dubbing pipeline got the same treatment. From 2022 into 2024 we moved course dubbing to AI voice cloning with lip-sync, and dubbing cost came down about 30 percent, with a faster turnaround.

The results were the kind you can measure. Post-production output went from about 500 minutes a month to over 1,000. Correction turnaround dropped from weeks to under 48 hours. The pipeline held at full uptime. Throughput, counted in courses out the door, rose about 80 percent. Across the three years the operation shipped more than 600 courses.

One honest note. That automation, and the templates, meant work we had been paying freelancers for stopped being necessary: the QA coordinator role, and two editing seats. That’s the part of this work nobody puts on a slide, and it’s worth saying out loud.

$ jira-automation --status
qa queue      · auto-assigned by category
corrections   · 0 open past sla
launch feed   · published from the board

Cut what’s left over

Some of the largest wins were subtractions.

I audited the tool stack and cancelled what overlapped or went unused. Frame came off the bill at $3,240 a year. Trint was replaced by Whisper, which did the same job for the cost of running it, at $12,340 a year. A Dropbox cleanup took off another $840. That’s $16,420 a year in tools nobody missed.

Replacing a manual translation process with an AI-assisted one saved another $10,000 and cut the turnaround at the same time, at about a tenth of the previous cost. Add the efficiency savings in review time and production minutes. The number I handed over when I left was more than $22,000 a year.

TAKEAWAY: an unused subscription is a standing invoice. Auditing the stack is some of the cheapest money you’ll ever find.

What the team got

This is the part I care about most, and it’s the easiest part to fake, so here’s what actually changed.

People got their time back. The manual reporting work, cost analysis per course, the launch calendar, the QA scoring reports, had been somebody’s week. Afterwards it was a dashboard that updated itself, and those people spent the week on work that needed a person.

The chasing stopped. Corrections used to sit for weeks while someone followed up. Once every stage carried an SLA, the system did the following up. That removed a whole category of friction, because “where’s my correction” stopped being a conversation between two colleagues.

Nobody waited to find out where they stood. Team metrics and OKRs were open to everyone, all the time, not gated behind a manager or a weekly meeting. Workload distribution became something you could look at instead of argue about.

The work became predictable. How booked the studios were, and what was coming next, stopped being a surprise, so planning replaced firefighting.

One contributor’s card, rebuilt from the real dashboard with the name removed. Anyone on the team could open their own, at any hour, without asking a manager.

The decisions, on the record

DEC	Decision	Status
DEC 001	Dashboards before automation: make the pipeline visible first	SETTLED
DEC 002	One source of truth in Jira; retire the spreadsheets and the Notion board	SETTLED
DEC 003	Automate the repetitive review steps with Jira, Python, and Sheets	SETTLED
DEC 004	Every stage carries a tracked SLA, so the system chases instead of a manager	SETTLED
DEC 005	Team metrics and OKRs open to everyone, 24/7, not manager-gated	SETTLED
DEC 006	Publish the launch calendar from the board, never maintain it by hand	SETTLED
DEC 007	Audit and cut redundant or unused subscriptions	SETTLED
DEC 008	AI-assisted translation in place of a manual process	SETTLED
DEC 009	AI voice cloning and lip-sync for course dubbing, in place of studio-only dubbing	SETTLED

What carries over

None of this started as a strategy. It started with one spreadsheet I was tired of updating by hand. That’s usually where it starts.

If you run an operation that feels busy but blurry, the order matters more than the tools. See it, centralize it, automate it, then cut what’s left over. Run that backwards and you automate a process nobody understands, on a stack nobody agreed to.

The tools are replaceable. Every one of them. The sequence is not.