SFOS Content Workflows

# SFOS Content Workflows

## Overview

Content in SFOS flows through a structured pipeline from ideation to publication.
Each content type (blog, social, newsletter) has its own workflow with defined
handoff points between personas.

## Blog Content Pipeline

```
CMO                    Writer                 Founder              Publish
 |                       |                      |                    |
 | 1. Create outline     |                      |                    |
 |    in Notion           |                      |                    |
 |                       |                      |                    |
 | 2. N8N triggers       |                      |                    |
 |    Writer workflow --->|                      |                    |
 |                       | 3. Draft written      |                    |
 |                       |    to vault           |                    |
 |                       |    /content/blog/     |                    |
 |                       |    drafts/            |                    |
 |                       |                      |                    |
 |                       | 4. Review notif  ---->|                    |
 |                       |    (Slack/email)      |                    |
 |                       |                      | 5. Review draft     |
 |                       |                      |    approve/reject   |
 |                       |                      |                    |
 |                       |                      | 6. Set status:  --->|
 |                       |                      |    approved         |
 |                       |                      |                    | 7. Publish via
 |                       |                      |                    |    publish-content.py
 |                       |                      |                    |
 |                       |                      |                    | 8. Update frontmatter
 |                       |                      |                    |    status: published
```

### Step Details

1. **CMO creates outline:** In Notion, the CMO creates a content brief containing:
   - Topic and angle
   - Target keywords (SEO)
   - Target audience
   - Key points to cover
   - Desired length and tone
   - Related product (if any)

2. **N8N trigger:** A Notion webhook or polling trigger in N8N detects the new outline and triggers the Writer workflow.

3. **Writer drafts:** The Writer persona receives the brief, writes the post, and saves it to the vault:
   - Path: `/content/blog/drafts/<slug>.md`
   - Frontmatter includes all required fields plus SEO metadata.

4. **Review notification:** N8N sends a Slack message or email to the founder with a link to the draft.

5. **Founder reviews:** The founder reads the draft in Obsidian or via the vault's git web UI.

6. **Approval:** The founder updates the frontmatter status to `approved` (or `rejected` with notes).

7. **Publish:** The `publish-content.py` script reads approved content and publishes it to the blog platform (e.g., push to docs repo for Docusaurus, or API call to CMS).

8. **Status update:** Frontmatter is updated to `status: published` with the publication URL.

## Social Media Pipeline

```
CMO                           Vault                    Publish
 |                              |                        |
 | 1. Generate batch of         |                        |
 |    social posts              |                        |
 |                              |                        |
 | 2. Write to vault ---------> |                        |
 |    /content/social/          |                        |
 |    scheduled/                |                        |
 |                              |                        |
 |                              | 3. Scheduled posts     |
 |                              |    picked up by    --->|
 |                              |    publish script      |
 |                              |                        |
 |                              | 4. Move to             |
 |                              |    published/ <--------|
```

### Batch Generation

The CMO persona generates social posts in batches (typically weekly):
- Creates one markdown file per post.
- Each file has frontmatter with `platform`, `publish_date`, and content.
- Posts are stored in `/content/social/scheduled/`.

### Scheduling

The `publish-content.py` script runs on a cron schedule:
- Reads all posts in `/content/social/scheduled/` with `publish_date` <= now.
- Publishes to the target platform API.
- Moves published posts to `/content/social/published/`.

## Newsletter Pipeline

```
CMO/Writer               Vault                Founder             Resend
 |                         |                    |                    |
 | 1. Draft newsletter     |                    |                    |
 |    content              |                    |                    |
 |                         |                    |                    |
 | 2. Write to vault ----->|                    |                    |
 |    /content/newsletter/ |                    |                    |
 |    drafts/              |                    |                    |
 |                         |                    |                    |
 |                         | 3. Notify  ------->|                    |
 |                         |    founder         |                    |
 |                         |                    | 4. Review          |
 |                         |                    |    approve         |
 |                         |                    |                    |
 |                         |                    | 5. Trigger   ----->|
 |                         |                    |    send            |
 |                         |                    |                    | 6. Send via
 |                         |                    |                    |    Resend API
 |                         |                    |                    |
 |                         | 7. Update  <--------------------------------|
 |                         |    frontmatter     |                    |
 |                         |    with send_id    |                    |
```

### Newsletter Details

1. CMO or Writer drafts the newsletter in the vault at `/content/newsletter/drafts/`.
2. The newsletter includes both HTML and plain-text versions.
3. Frontmatter specifies the recipient list or segment.
4. After founder approval, `publish-content.py` sends via Resend batch API.
5. The Resend send ID and recipient count are written back to frontmatter.
6. The newsletter file is moved to `/content/newsletter/sent/`.

## Content Templates

Templates live in the vault at `/templates/`:

### Blog Post Template
```markdown
---
persona: writer
product: <product-id>
date: <YYYY-MM-DD>
status: draft
title: <title>
tags: []
platform: blog
publish_date: null
---

## Introduction

## Main Content

## Conclusion

## Call to Action
```

### Social Post Template
```markdown
---
persona: writer
product: <product-id>
date: <YYYY-MM-DD>
status: draft
platform: <twitter|linkedin|threads>
publish_date: <YYYY-MM-DDTHH:MM:SSZ>
tags: []
---

<post content here - respect platform character limits>
```

### Newsletter Template
```markdown
---
persona: cmo
product: general
date: <YYYY-MM-DD>
status: draft
title: <newsletter-title>
platform: newsletter
tags: [newsletter, monthly]
---

# <Newsletter Title>

## Highlights

## Product Updates

## Community

## What's Next
```