CCFish runs automated tournaments, leaderboards, and in-game events on Telegram that generate real-time telemetry data -- and that same data now drives a fully autonomous content pipeline that publishes SEO-optimized blog posts without human intervention.
The Problem
Mobile game studios spend an enormous amount of time on content marketing. After every seasonal event, tournament, or leaderboard reset, someone has to manually write a recap, format screenshots, check SEO, and push it to the blog. For a team of three running CCFish across iOS, Telegram Mini App, and TMA, that overhead was unsustainable.
Manual event-to-content creation suffered from three specific bottlenecks:
- **Latency:** By the time a recap post went live, the event had already ended. Players had moved on, and the organic search window was missed.
- **Inconsistency:** Different writers produced different formats. Some posts had rich data tables, others just a paragraph. SEO quality varied wildly.
- **Scale:** With daily tournaments firing across multiple Telegram groups, the team could only cover 10-15% of events manually. The rest were simply lost to the content void.
CCFish had 340K+ users acquired organically through Telegram viral loops. Each user generated event data -- fish caught, tournaments entered, leaderboard positions, rewards claimed. All of that data was flowing into a game backend built on Cocos Creator 2.4.15. But none of it was making it onto the company blog.
The Solution
The solution was a marketing automation pipeline that connects CCFish's in-game event system directly to D1 (the content publishing engine on ai-kit.net). The pipeline has three stages:
1. **Capture** -- In-game events emit structured telemetry to a webhook endpoint.
2. **Transform** -- A Python middleware (running as a D1 skill) converts raw event data into blog-ready structured content.
3. **Publish** -- The structured content lands in the D1 queue as a JSON post, which D1's scheduler publishes on the next cycle.
The entire pipeline runs without human hands. A tournament ends, and within 15 minutes a blog post summarizing the tournament is queued. The post includes:
- Winner name and score
- Top 10 leaderboard table
- Total participants and fish caught
- Prize distribution summary
- Automated SEO metadata (title, excerpt, tags)
Architecture
The architecture connects four distinct systems:
```
Telegram Game Events
|
v
Game Backend (Cocos Creator 2.4.15)
|
v
Webhook Gateway (FastAPI endpoint)
|
v
D1 Skill: Event-to-Content Transformer
|
v
D1 Queue (JSON post files)
|
v
D1 Scheduler -> Published Blog
```
The webhook gateway runs as a lightweight FastAPI service deployed on a single $5 VPS. It receives POST requests from the game backend whenever an event ends. Each payload contains:
```json
{
"event_id": "tournament_2026_05_28",
"event_type": "leaderboard",
"started_at": "2026-05-28T10:00:00Z",
"ended_at": "2026-05-28T18:00:00Z",
"participants": 1247,
"total_fish_caught": 89234,
"top_10": [
{"rank": 1, "player": "FishKing42", "score": 15420},
{"rank": 2, "player": "ReelMaster", "score": 14890}
],
"prize_pool": { "total_gems": 25000 }
}
```
The D1 skill takes this payload and generates a complete blog post in under 2 seconds. It uses Jinja2 templates for the body text, auto-generates the excerpt from the first paragraph, derives tags from the event type, and writes the JSON queue file directly.
Step-by-Step Implementation
Here is how the team implemented the pipeline step by step:
Step 1: Instrument the Game Backend
The Cocos Creator 2.4.15 game client already sent telemetry to the backend for leaderboards and tournaments. The team added an exit hook that fires a webhook POST when any competitive event ends. This was a small change -- approximately 30 lines of Lua script in the game's event manager.
Step 2: Build the Webhook Gateway
A FastAPI endpoint was deployed to receive event payloads. The gateway validates the payload signature using a shared HMAC secret, normalizes field names, and forwards the cleaned payload to the D1 skill via HTTP.
Step 3: Create the D1 Transformer Skill
The D1 skill is a Python module with three components:
- **Template engine:** Jinja2 templates for different post structures (tournament recap, seasonal event, milestone announcement).
- **SEO generator:** Extracts keywords from event data, constructs the title and excerpt according to D1's slugify rules, and selects tags from a predefined taxonomy.
- **Queue writer:** Formats the output as a valid D1 queue JSON file and writes it to the queue directory with the correct filename convention.
```python
Simplified template engine excerpt
templates = {
"tournament": {
"title": "{event_name} Tournament Recap - {participants} Players Competed!",
"template_file": "tournament_recap.md.j2"
},
"seasonal": {
"title": "{event_name} - {prize_pool} Gems in Prizes Available",
"template_file": "seasonal_event.md.j2"
}
}
def generate_post(event_data):
template_key = "tournament" if event_data["event_type"] == "leaderboard" else "seasonal"
template = templates[template_key]
body = render_template(template["template_file"], event_data)
word_count = len(body.split())
Validate word count is between 800-1500
if word_count < 800:
body += expand_with_details(event_data)
return {
"title": template["title"].format(**event_data),
"body_text": body,
"excerpt": body.split(". ")[0] + ".",
"category": "Marketing Automation",
"tags": build_tags(event_data)
}
```
Step 4: Wire the D1 Scheduler
No changes were needed here. D1's scheduler scans the queue directory every hour and processes any new JSON files it finds. The pipeline simply writes to the queue, and D1 handles the rest -- slug generation, asset upload, and publication.
Step 5: Monitor and Iterate
The team added a simple monitoring dashboard that shows:
| Metric | Value |
|--------|-------|
| Events captured per week | 45-60 |
| Posts generated per week | 40-55 |
| Auto-publish rate | ~92% |
| Average time from event end to post queued | 14 minutes |
| Manual intervention rate | ~8% (edge cases) |
Results
Since deploying the marketing automation pipeline, CCFish has seen measurable improvements across the board:
- **Content volume increased 8x.** From roughly 3 posts per week (manual) to 40-55 posts per week (automated). Every tournament, leaderboard reset, and seasonal event is now covered.
- **Time-to-publish dropped from 6 hours to 14 minutes.** The manual process required a writer to pull data, draft, edit, and publish. The pipeline does it in a quarter of an hour.
- **SEO traffic increased 340%.** More posts mean more indexed pages. The automated posts consistently rank for long-tail keywords like "CCFish tournament results" and "Telegram fishing game leaderboard."
- **340K+ users now have a content experience that matches the event cadence.** Players can search for their tournament results, share links, and find the blog post about the event they just played in. This creates a virtuous loop: event plays blog post shares more event plays.
- **Team bandwidth freed up.** The three-person team went from spending 60% of their time on content creation to less than 10%. They now focus on game development, community management, and strategic content -- not writing tournament recaps by hand.
Content Quality Metrics
A/B testing showed that auto-generated posts actually outperformed manual posts on several dimensions:
| Quality Metric | Manual Posts | Auto-Generated Posts |
|----------------|-------------|---------------------|
| Avg. time on page | 1m 42s | 2m 18s |
| Bounce rate | 64% | 51% |
| Social shares per post | 4.2 | 7.8 |
| SEO keyword density (target: 1-2%) | 0.8% | 1.6% |
| Publication consistency | 70% of events | 100% of events |
The data-rich nature of auto-generated posts -- tables of winners, precise participant counts, prize breakdowns -- kept readers engaged longer and made the posts more shareable.
Key Takeaways
1. **Instrument your game for content.** Every event in your game is potential content. Add a webhook exit hook -- 30 lines of code -- and suddenly your game generates blog posts automatically.
2. **Templates beat generative AI for structured data.** For leaderboards and tournament recaps, Jinja2 templates with real data produce better, more accurate content than any LLM. Save LLMs for creative storytelling, not data transcription.
3. **Speed creates a content loop.** When a post goes live within 15 minutes of an event ending, players are still engaged. They search, find, and share. Fast content feeds the viral loop that acquired those users in the first place.
4. **SEO volume compounds.** One automated post is trivial. But 40-55 posts per week, every week, creates a compounding SEO effect. Each post is a long-tail keyword landing page that keeps bringing in new users months later.
5. **Marketing automation is not just about saving time.** It is about creating content that was previously impossible to create at scale. CCFish covers 100% of events now. Before, they covered 10-15%. The bottleneck was not the team's talent -- it was the manual process.