You know the feeling: it's Tuesday morning, you meant to publish a blog post on Monday, but somehow another week slipped by. Your content calendar is gathering dust, your SEO pipeline is stalled, and your "publish consistently" resolution failed — again.
You don't need more willpower. You need a system.
EmDash CMS has a built-in content scheduling engine that lets you queue posts, set publish dates, and walk away. Combined with Cloudflare Cron Triggers (or an external cron service), you can automate your entire editorial calendar. Here's exactly how to set it up.
Why Content Scheduling Matters
Consistent publishing is the single highest-leverage SEO activity you can do. A study of 5 million blog posts showed that sites publishing 3+ times per week get 3.5x more traffic than those publishing monthly. But consistency is hard — until you automate it.
| Frequency | Traffic Boost (6 months) | Effort Level |
|-----------|-------------------------|--------------|
| Daily | 4-5x | High (needs automation) |
| 3x/week | 3-3.5x | Medium |
| Weekly | 2x | Low-Medium |
| Monthly | 1x baseline | Low |
The goal of EmDash's scheduling system: make 3x/week feel like monthly effort.
How EmDash Scheduling Works
EmDash stores scheduled posts in Cloudflare D1 with a `published_at` timestamp. A cron job (either Worker-native or external) runs on schedule, queries D1 for posts where `published_at <= NOW() AND status = 'scheduled'`, flips them to `status = 'published'`, and purges the CDN cache.
```sql
-- The core scheduling query
SELECT id, slug, body, excerpt, category, tags
FROM ec_posts
WHERE status = 'scheduled'
AND published_at <= datetime('now')
AND draft = 0;
```
Then the publishing worker:
1. Updates each matched row to `status = 'published'`
2. Inserts a row into `ec_revisions` for version history
3. Purges the Cloudflare cache for that slug
4. Optionally posts to Telegram/Discord via webhook
Setting Up Your First Scheduled Post
Step 1: Create a Post With a Future Date
You can create scheduled posts directly in the EmDash admin panel, or via the API:
```json
POST /api/posts
{
"title": "5 SEO Mistakes That Kill Your Astro Site",
"body": "...",
"excerpt": "...",
"category": "SEO",
"tags": ["astro", "seo"],
"published_at": "2026-05-15T06:00:00Z",
"status": "scheduled",
"draft": false
}
```
The key fields are `published_at` (future timestamp) and `status: "scheduled"`. EmDash will not serve a scheduled post at its live URL until the cron publishing job flips it.
Step 2: Set Up a Cron Trigger
Cloudflare Workers has native cron trigger support:
```toml
wrangler.toml
[triggers]
crons = ["0 6 * * 1,3,5"] # Mon/Wed/Fri at 6AM
```
Your Worker's `scheduled` handler runs the publishing query:
```js
export default {
async scheduled(event, env, ctx) {
const result = await env.DB.prepare(`
UPDATE ec_posts
SET status = 'published'
WHERE status = 'scheduled'
AND published_at <= datetime('now')
RETURNING id, slug
`).run();
for (const post of result.results) {
await purgeCache(post.slug);
await notifyChannel(post);
}
}
};
```
Step 3: Verify the Pipeline
After setting up, test the full flow:
```bash
1. Insert a scheduled post 5 minutes in the future
2. Run the scheduler immediately
wrangler tail # watch logs
3. Check the post is live
curl https://yoursite.com/blog/test-post
4. Verify cache was purged
curl -I https://yoursite.com/blog/test-post | grep cf-cache-status
```
Expected: `cf-cache-status: MISS` on first request after publishing (cache was purged), then `HIT` on subsequent requests.
Scheduling With External Cron (Non-Cloudflare)
If your EmDash site isn't on Cloudflare Workers, you can use any cron service (GitHub Actions, cron-job.org, `cron` on a VPS) to hit a publish endpoint:
```yaml
.github/workflows/publish-scheduled.yml
name: Publish Scheduled Posts
on:
schedule:
- cron: '0 6 * * 1,3,5'
jobs:
publish:
runs-on: ubuntu-latest
steps:
- run: |
curl -X POST ${{ secrets.EMDASH_URL }}/api/publish-scheduled \
-H "Authorization: Bearer ${{ secrets.EMDASH_API_KEY }}"
```
The EmDash `/api/publish-scheduled` endpoint runs the same D1 query and cache purge.
Best Practices for Content Scheduling
1. Build Buffer, Don't Batch
The biggest mistake: writing 12 posts in one weekend, scheduling them all, and forgetting about the blog for a month. Readers notice. Instead:
- Maintain a queue of 3-5 ready-to-publish posts at all times
- Write one new post for every one that publishes (steady state)
- Use the queue as a buffer, not a warehouse
2. Schedule for Your Audience's Timezone
If your audience is global, 6AM UTC is a safe default. Use EmDash's `published_at` with explicit timezone offsets if you want to target a specific region:
```
"published_at": "2026-05-15T08:00:00+02:00" # 8AM CET
```
3. Pair Scheduling With an Editorial Calendar
A content calendar (in Notion, Google Sheets, or even markdown) should be your single source of truth. EmDash's queue is the execution layer. The schedule:
| Day | Activity |
|-----|----------|
| Mon | Publish + generate next week's post |
| Wed | Publish + review analytics |
| Fri | Publish + plan next week's topics |
4. Handle Failures Gracefully
Things go wrong. Your cron service might have downtime, D1 might throttle, cache invalidation might fail. Build resilience:
```js
// Retry with exponential backoff
async function publishScheduled(retries = 3) {
for (let i = 0; i < retries; i++) {
try {
await env.DB.prepare(query).run();
return;
} catch (e) {
if (i === retries - 1) throw e;
await sleep(Math.pow(2, i) * 1000);
}
}
}
```
Store a `last_published` timestamp in D1 so you can catch up on missed runs.
Real-World Setup: Our AIKit Blog
The AIKit blog (this one!) runs on EmDash and publishes Mon/Wed/Fri at 6AM. Here's the full pipeline:
```
[6:00 AM] Cron Trigger (Cloudflare)
→ Query D1 for scheduled posts due
→ Flip status to 'published'
→ Purge cache for each slug
→ Post summary to Telegram
[6:01 AM] AI content generation script
→ Check queue size
→ If ≤1 remaining, generate 2 new posts
→ Save as JSON queue files
```
Total infrastructure cost: $0 (within Cloudflare's free tier). Total human effort after initial setup: ~30 minutes per week for editorial review.
The Bottom Line
Content scheduling is a force multiplier. It turns "I should write more" from a vague aspiration into an automated system. EmDash's scheduling, combined with any cron trigger, gives you a professional publishing pipeline in under an hour of setup time.
Set it up once. Queue your posts. Let the machine handle the clock.