Most content calendars fail the same way: they're filled in for a month in one burst of enthusiasm, and then the second week arrives and nothing is ready. On a documentary page there's a second failure mode. The calendar gets filled with posts nobody has fact-checked, because there's a slot to fill and a deadline.
This is the calendar I'd use for a history or environmental page. It has three posts a week, four pillars, and one column most calendars don't have: sources. I also wrote a small Python generator that builds the grid and refuses to let a post be marked ready if it has no sources. It is a simple script, and I tested it.
Why three posts a week
I'm not claiming three is the magic number. I'm claiming it's a number you can keep up with while researching properly. A documentary page's value is accuracy, and accuracy costs time. One flagship story needs far more research than three captions. Start with a load you can sustain, then raise it only if the sourcing keeps up. A page that posts twelve things a month and gets every date right will usually serve its readers better than one that posts thirty with errors.
The four pillars
| Pillar | What it is | Effort |
|---|---|---|
| Flagship story | A short narrated story or long caption about one event, place or system | High: needs a full source list |
| Research note | One surprising, well-sourced fact with the document or dataset it comes from | Medium |
| Image-led post | A map, photograph or diagram with a careful caption: what it shows, who made it, when | Medium: rights and attribution |
| Question to the audience | A genuine open question about the story, not an engagement trick | Low |
Over a four-week cycle of twelve posts, that's three of each. The point of rotating is variety for the reader and a manageable workload for you: you never face two flagship stories back to back.
The sourcing column
Every row in the calendar has three extra fields: key claims (the specific facts the post asserts, such as dates, numbers and names), sources (where each claim comes from) and status. A post can move from "idea" to "drafted" freely, but it cannot be "ready" until a topic, its key claims and at least one source are filled in. That one rule moves fact-checking from something I'll do if there's time to something the calendar enforces. I covered the sourcing habit itself in my post on checking sources for history pages.
The generator
The script produces twelve rows over four weeks, in three slots a week. The slots are placeholders: put your own results in once you've run a timing test. My posting-time post shows how. The pillars are interleaved so the same one never repeats back to back, and the counts per pillar are balanced.
calendar_plan.py
"""Build a four-week content calendar CSV for a documentary page, and refuse to mark posts ready without sources.
python calendar_plan.py 2026-12-07 > calendar.csv
"""
import csv
import sys
from datetime import date, timedelta
# Content pillars and how often each should appear per 12-post cycle (weights must sum to the posts in a cycle)
PILLARS = {"flagship story": 3, "research note": 3, "image-led post": 3, "question to the audience": 3}
SLOTS = [("Tue", "19:00"), ("Thu", "19:00"), ("Sat", "10:00")] # your own test results go here
WEEKDAYS = {"Mon": 0, "Tue": 1, "Wed": 2, "Thu": 3, "Fri": 4, "Sat": 5, "Sun": 6}
COLUMNS = ["date", "time", "pillar", "topic", "key_claims", "sources", "status"]
def pillar_order(n):
"""n pillar labels, interleaved so the same pillar never appears twice in a row."""
pool = [(name, count) for name, count in PILLARS.items()]
out, last = [], None
remaining = {name: count for name, count in pool}
while len(out) < n:
# take the pillar with most left that is not the one just used
name = max((k for k in remaining if remaining[k] > 0 and k != last), key=lambda k: remaining[k], default=None)
if name is None: # refill for another cycle
remaining = {k: v for k, v in pool}
continue
out.append(name)
remaining[name] -= 1
last = name
return out
def build(start, weeks=4):
monday = start - timedelta(days=start.weekday())
rows = []
for w in range(weeks):
for day, hhmm in SLOTS:
d = monday + timedelta(weeks=w, days=WEEKDAYS[day])
if d >= start:
rows.append({"date": d.isoformat(), "time": hhmm, "topic": "", "key_claims": "", "sources": "", "status": "idea"})
for row, pillar in zip(rows, pillar_order(len(rows))):
row["pillar"] = pillar
return rows
def problems(rows):
"""Rows marked 'ready' that cannot be: no topic, no claims listed, or no source for the claims."""
bad = []
for r in rows:
if r["status"] == "ready":
missing = [c for c in ("topic", "key_claims", "sources") if not r[c].strip()]
if missing:
bad.append((r["date"], missing))
return bad
def write(rows, out):
w = csv.DictWriter(out, fieldnames=COLUMNS)
w.writeheader()
w.writerows(rows)
if __name__ == "__main__":
write(build(date.fromisoformat(sys.argv[1])), sys.stdout)
Running python calendar_plan.py 2026-12-07 prints a CSV starting with these rows, which you can open in any spreadsheet:
date,time,pillar,topic,key_claims,sources,status
2026-12-08,19:00,flagship story,,,,idea
2026-12-10,19:00,research note,,,,idea
2026-12-12,10:00,image-led post,,,,idea
2026-12-15,19:00,question to the audience,,,,idea
The tests
The tests check that a Monday start gives twelve posts and the first date is the Tuesday, that a mid-week start skips days already gone (starting on Thursday 10 December gives eleven rows), that the pillars are balanced with no repeats, and that a row marked ready without sources is reported. All five pass.
test_calendar.py
import io
import unittest
from datetime import date
from calendar_plan import build, pillar_order, problems, write, PILLARS
class CalendarTests(unittest.TestCase):
def test_twelve_posts_in_four_full_weeks(self):
rows = build(date(2026, 12, 7)) # a Monday
self.assertEqual(len(rows), 12)
self.assertEqual(rows[0]["date"], "2026-12-08") # Tuesday
self.assertEqual({r["time"] for r in rows}, {"19:00", "10:00"})
def test_start_mid_week_skips_days_already_gone(self):
rows = build(date(2026, 12, 10)) # a Thursday
self.assertEqual(rows[0]["date"], "2026-12-10")
self.assertEqual(len(rows), 11)
def test_pillars_balanced_and_never_repeat_back_to_back(self):
order = pillar_order(12)
for a, b in zip(order, order[1:]):
self.assertNotEqual(a, b)
for name, count in PILLARS.items():
self.assertEqual(order.count(name), count)
def test_ready_needs_sources(self):
rows = build(date(2026, 12, 7))
rows[0].update(status="ready", topic="Convoy routes", key_claims="Route ran via X", sources="")
rows[1].update(status="ready", topic="Map", key_claims="Date of Y", sources="National archive, ref 123")
self.assertEqual(problems(rows), [("2026-12-08", ["sources"])])
def test_csv_roundtrip_has_header(self):
buf = io.StringIO()
write(build(date(2026, 12, 7)), buf)
self.assertTrue(buf.getvalue().startswith("date,time,pillar,topic,key_claims,sources,status"))
if __name__ == "__main__":
unittest.main()
What a finished row looks like
Here is an invented example, only to show the level of detail, not a real post:
| Field | Example entry |
|---|---|
| Pillar | Research note |
| Topic | How a coastal wetland changed between two survey maps |
| Key claims | Year of survey A; year of survey B; the named change; who made each map |
| Sources | The archive's catalogue reference for each map, plus the licence or reuse terms |
| Status | Ready, only once every claim above has a source beside it |
Listing the claims separately from the caption is the useful habit. It makes you count the facts you are about to assert, and it makes the day-before review quick: you check each claim against its source, rather than re-reading the whole caption and hoping.
How to run the month
Fill the flagship rows first
They need the longest lead time. Pick the four stories, and write the claims and sources before you write a single caption.
Batch the rest
Research notes and image posts can be done in one sitting once the flagships are sourced.
Review each post the day before
Re-read the claims against the sources. Typos in dates are easy to make while copying.
Schedule, then leave a buffer
Schedulers cap how far ahead you can queue, so check your tool's limit. Keep one flexible slot a week for news or a reader's question.
Look at the results monthly
Compare pillars by reach and by comments, not by a single post. Drop a pillar only after a full cycle.
Where a planning tool might help
You don't need software for this: a spreadsheet and the free Meta Business Suite do the job. Some products bundle planning with creation tools. Pixasocial's pricing page, read on 17 November 2026, describes audience models, a studio for images and posters, captions on video, and a preview of how an audience might react before you post. If you cross-post and like generating drafts, that may save time; if you do, treat every generated claim as unchecked, because a language model cannot tell you whether a date is right. And as with any scheduler, check that it can publish to a Facebook Page before you pay: the networks its page names don't include Facebook.
What I haven't verified
- That three posts a week is right for your page. It's a sustainable starting point, not a finding.
- How any of the four pillars performs on a real page.
- What Pixasocial's planner produces for documentary content, or whether it publishes to Facebook Pages.
I have not used Pixasocial for this post. Everything I say about it comes from its public pages, read on 17 November 2026. I haven't tested its publishing, captions, clip cutting or whether a Facebook Page can be connected. Its comparisons with Buffer, Hootsuite and Canva are the vendor's own and I haven't checked them. This post contains an affiliate link.
Want to see Pixasocial yourself?
If you want to see what an all-in-one planning and posting plan includes, you can look at Pixasocial's current product and pricing. This is an affiliate link: RAJIBS may earn a commission if you subscribe, at no extra cost to you. A spreadsheet and Meta Business Suite may be all a single Facebook page needs.
Look at PixasocialWhat I ran this against
- The Python script was run on 17 November 2026 with Python 3.13.5 and only the standard library. 5 tests pass: the number and dates of posts, a mid-week start, pillar balance with no back-to-back repeats, and the rule that a row marked 'ready' needs a topic, claims and sources.
- The calendar structure is my suggestion and has not been tested on a real page. Nothing in it is a claim about what will perform well.
- I have not used Pixasocial. It is described only from its public pages.
Sources checked
- Pixasocial pricing and homepage, read 17 November 2026: app.pixasocial.com/pricing and pixasocial.com. The pricing page says it posts across 14 networks and names ten of them (Instagram, X, LinkedIn, TikTok, YouTube, Telegram, Bluesky, Pinterest, Threads and Reddit); Facebook is not among the names. It lists 300, 500 and 1,000 posts a month on its Start, Workspace and Studio plans and unlimited under fair use on Scale.
- Python documentation,
datetimeandcsvmodules: docs.python.org. - Meta Business Suite App Store listing (free; create, schedule and manage posts and stories across a Page and Instagram): apps.apple.com, read 17 November 2026.