The 23 Cron Jobs That Run My Entire Business

My business runs on 23 cron jobs. Not a workflow platform. Not a drag-and-drop automation builder. Twenty-three lines in a crontab file that execute Python scripts on a schedule.

Total monthly cost: $5.83 in AI API calls. Total monthly SaaS: $0.

Here's every single one, why it runs when it does, and what breaks if you get the timing wrong.

The Full Crontab

# === CONTENT PIPELINE (5 tweets/day, off the hour) ===
07 7  * * * cd ~/operator && python3 poster.py >> logs/poster.log 2>&1
37 9  * * * cd ~/operator && python3 poster.py >> logs/poster.log 2>&1
07 12 * * * cd ~/operator && python3 poster.py >> logs/poster.log 2>&1
37 15 * * * cd ~/operator && python3 poster.py >> logs/poster.log 2>&1
07 18 * * * cd ~/operator && python3 poster.py >> logs/poster.log 2>&1

# === ENGAGEMENT (3 windows/day) ===
00 8  * * * cd ~/operator && python3 engagement.py >> logs/engage.log 2>&1
00 12 * * * cd ~/operator && python3 engagement.py >> logs/engage.log 2>&1
00 18 * * * cd ~/operator && python3 engagement.py >> logs/engage.log 2>&1

# === CONTENT REPLENISHMENT ===
30 6  * * * cd ~/operator && python3 queue_manager.py >> logs/queue.log 2>&1
00 5  * * 1 cd ~/operator && python3 calendar_to_queue.py >> logs/calendar.log 2>&1
00 4  * * 4 cd ~/operator && python3 thread_poster.py >> logs/thread.log 2>&1

# === ANALYTICS & REPORTING ===
45 23 * * * cd ~/operator && python3 analytics.py >> logs/analytics.log 2>&1
50 23 * * * cd ~/operator && python3 dashboard_gen.py >> logs/dashboard.log 2>&1
55 23 * * * cd ~/operator && python3 daily_summary.py >> logs/summary.log 2>&1
00 9  * * 5 cd ~/operator && python3 weekly_report.py >> logs/weekly.log 2>&1
00 10 * * 5 cd ~/operator && python3 scorecard_gen.py >> logs/scorecard.log 2>&1

# === HEALTH & MONITORING ===
*/30  * * * * cd ~/operator && python3 watchdog.py >> logs/watchdog.log 2>&1
*/30  * * * * cd ~/operator && python3 alert_monitor.py >> logs/alerts.log 2>&1
00 6  * * * cd ~/operator && python3 auth_monitor.py >> logs/auth.log 2>&1

# === REVENUE ===
00 22 * * * cd ~/operator && python3 revenue.py >> logs/revenue.log 2>&1
00 7  * * 2,5 cd ~/operator && python3 checkout_test.py >> logs/checkout.log 2>&1

# === MEMORY & KNOWLEDGE ===
00 3  * * * cd ~/operator && python3 nightly_extract.py >> logs/extract.log 2>&1

# === MONTHLY ===
00 9  1 * * cd ~/operator && python3 voice_audit.py >> logs/voice.log 2>&1

That's the whole thing. Let me walk through why each one exists and why it runs when it does.

Content Pipeline: Why "Off the Hour"

Notice the posting times: :07 and :37. Not :00 or :30.

Two reasons:

1. Everyone else posts on the hour. Scheduling tools default to :00 and :30. By posting at :07, my tweets land in feeds after the initial rush has scrolled past. Less competition for attention in the first 15 minutes — which is when Twitter's algorithm decides whether to amplify.
2. Stagger to avoid rate limits. If your poster, engagement script, and analytics all fire at :00, you'll hit API rate limits. Staggering by 7+ minutes means each script gets clean API access.

The 5-post schedule (7:07, 9:37, 12:07, 3:37, 6:07 CT) covers the three main B2B attention windows:

• Morning commute: 7:07 AM — people scrolling before work
• Mid-morning break: 9:37 AM — first coffee done, quick scroll
• Lunch: 12:07 PM — peak scrolling time
• Afternoon dip: 3:37 PM — procrastination window
• End of day: 6:07 PM — winding down, longer reads

Testing showed 5 posts/day as the sweet spot: 3/day left engagement on the table, 7/day triggered unfollows from fatigue. 5 gets 2.1% engagement rate vs 1.8% at 3 and 1.4% at 7.

Engagement: The 3-Window System

Three engagement runs per day: 8 AM, 12 PM, 6 PM. Each one:

1. Pulls new mentions and replies
2. Classifies them by priority (Haiku, $0.0004/classification)
3. Generates replies for high-priority mentions (Sonnet, $0.001/reply)
4. Posts replies automatically for Tier 1–2 conversations
5. Queues Tier 3+ for human review

The classification criteria:

PRIORITY_RULES = {
    "high": [
        "direct question about product",
        "customer with purchase history",
        "account with >5K followers asking genuinely",
    ],
    "medium": [
        "general question about AI ops",
        "someone sharing related content",
        "constructive disagreement",
    ],
    "low": [
        "generic compliment (like, don't reply)",
        "tangential mention",
    ],
    "ignore": [
        "obvious troll",
        "spam/bot account",
        "reply guys with no followers and no substance",
    ]
}

Total daily engagement cost: $0.015. I reply to ~8 mentions/day automatically and review 2–3 manually.

Content Replenishment: The Monday Pipeline

Three scripts keep the content pipeline full:

queue_manager.py (daily at 6:30 AM) — runs before the first post. Checks queue depth, expires timely content older than 14 days, recycles evergreen content after 60 days, deduplicates against recent posts. If queue drops below 7 days of content (35 tweets), it triggers an alert. Cost: $0 (pure file operations).

calendar_to_queue.py (Monday at 5 AM) — converts the weekly editorial plan into queue-ready tweets. Takes the content calendar JSON (which types to post on which days), generates 35 tweets for the week, scores them (specificity, voice match, originality), filters to top 80%, and adds to the queue. Cost: $0.08/week ($0.34/month).

thread_poster.py (Thursday at 4 AM) — one thread per week. Pulls from the thread script library, posts tweet-by-tweet with 3-minute spacing (Twitter's algorithm rewards threaded engagement over bulk posts), handles reply-chain failures with recovery, logs thread performance. Cost: $0 (posting only, no generation).

The timing matters: content generation happens early Monday (5 AM) when API rates are low. The queue manager runs daily to prevent posting stale or duplicate content. Threads go Thursday because engagement data shows mid-week threads outperform Monday and Friday threads by 23%.

Analytics: The End-of-Day Stack

Three analytics scripts run back-to-back at end of day:

# 23:45 — Capture raw metrics
analytics.py  # Pull impressions, engagement, follower count, per-tweet data
              # Cost: $0 (API reads only)

# 23:50 — Generate dashboard
dashboard_gen.py  # Compile into dashboard.json: revenue, content, audience,
                  # email, costs, health, alerts
                  # Cost: $0 (file aggregation)

# 23:55 — Write summary
daily_summary.py  # Generate human-readable report with ASCII dashboard
                  # Cost: $0.02 (one Sonnet call for recommendations)

The 5-minute gaps ensure each script has fresh data from the previous one. analytics.py writes raw data, dashboard_gen.py reads it and adds context, daily_summary.py reads both and generates the narrative.

Friday adds two more: weekly report (cross-references 7 daily dashboards, calculates trends) and scorecard (evaluates KPIs against targets, tracks hit rate). These cost $0.08 combined.

Health Monitoring: Every 30 Minutes

Two scripts run every 30 minutes, 24/7:

watchdog.py — checks 6 critical files for freshness:

• Tweet queue (stale if no new content added in 48 hours)
• Posted log (stale if last post >6 hours ago during business hours)
• Dashboard (stale if not regenerated last night)
• Poster log (stale if no activity in 12 hours)
• Engagement log (stale if no activity in 8 hours)
• Auth status (stale if not checked in 25 hours)

Also checks queue depth — alerts at <7 days of content. Cost: $0. Zero AI calls. It reads file modification timestamps and compares to thresholds.

alert_monitor.py — threshold monitoring with cooldowns:

• Refund rate above 3% → warning
• Engagement rate below 1.5% for 3 consecutive days → alert
• No posts in 8+ hours during business hours → critical
• Queue below 14 tweets → warning
• Margin below 90% → alert

4-hour cooldown per alert type prevents notification spam. Cost: $0.001/run ($1.44/month).

Revenue: Trust but Verify

revenue.py (daily at 10 PM) — queries Stripe for the day's transactions, logs revenue, detects anomalies (sudden drops, unusual refund patterns), updates the running monthly total. Cost: $0 (Stripe API + file writes).

checkout_test.py (Tuesday + Friday at 7 AM) — hits every Stripe Payment Link with an HTTP request, verifies it returns 200 and contains the right product name. Catches broken links before customers hit them. Cost: $0.

Why Tuesday and Friday? Tuesday catches anything that broke over the weekend. Friday catches anything that broke during the week before the weekend traffic spike.

The Overnight Brain

nightly_extract.py (daily at 3 AM) — the knowledge accumulation layer. Reads the day's analytics, posted tweets, engagement data, and memory logs. Extracts atomic facts into items.json:

# Example facts extracted:
{"fact": "Tweets with specific dollar amounts get 2.3x engagement",
 "confidence": "measured", "source": "analytics_2026-03-13"}
{"fact": "Thursday threads outperform Monday threads by 23%",
 "confidence": "measured", "source": "analytics_2026-03-10"}
{"fact": "Support emails peak Tuesday-Wednesday",
 "confidence": "inferred", "source": "email_triage_weekly"}

One Sonnet call per night, $0.04. Over 30 days, that's $1.20/month for a continuously growing knowledge base that makes every other script smarter — content generation uses relevant facts, analytics references historical patterns, engagement prioritizes based on accumulated data.

Monthly: The Voice Drift Check

voice_audit.py (1st of every month at 9 AM) — compares the last 15 posts against the top 15 all-time performers. Uses Opus (the only monthly Opus call) to deep-analyze voice consistency across 5 dimensions: specificity, stance, authority, concision, originality.

If any dimension drops below 3.5/5, it flags the drift with specific examples. "Your specificity dropped from 4.2 to 3.7 — 4 of last 15 posts used vague phrases like 'game-changer' and 'next level' instead of numbers."

Cost: $0.04/month. Catches voice drift before it compounds.

The Anti-Collision Pattern

The single most important architectural decision: nothing fires at the same time.

Bad crontab:

00 8 * * * poster.py
00 8 * * * engagement.py
00 8 * * * analytics.py
# Three scripts hitting the X API simultaneously = rate limit = all three fail

Good crontab:

07 7  * * * poster.py      # Posts first
00 8  * * * engagement.py   # Engagement 53 minutes later
45 23 * * * analytics.py    # Analytics at end of day
# Each script gets clean API access

The minimum safe gap: 5 minutes between scripts that hit the same API. I use 7+ minutes for extra buffer. This one pattern has prevented more outages than any monitoring script.

What's Not on Cron

Three things that look like they should be automated but aren't:

• Content approval for Tier 3 tasks — these sit in a queue until I review them. No timeout auto-approves. If I don't look for 48 hours, they get discarded, not published.
• Pricing changes — always manual. One wrong cron job changing prices could cost thousands before anyone notices.
• Platform responses to crises — if something goes viral for the wrong reasons, a human handles it. The kill switch stops all automation and the human takes over.

Total Cost Breakdown

3,355 automated executions per month. $4.39 in AI costs. $0 in SaaS subscriptions. That's the entire operations layer of a revenue-generating business.

How to Build Yours

Don't start with 23. Start with 3:

1. A poster (fires 3x/day, reads from a queue file)
2. An analytics capture (fires once at end of day)
3. A watchdog (fires every 30 min, checks the other two are working)

Get those three stable for a week. Then add engagement. Then content generation. Then reporting. Each new cron job earns its place by solving a problem you actually experienced, not one you anticipated.

The system I'm running today took 6 months to reach 23 entries. It didn't need to be 23 on day one. It needed to be 3.