{
  "slug": "thread-schemas-field-guide",
  "title": "A Field Guide to Thread Schemas: Every Column, JSON Shape, and Lifecycle Rule",
  "deck": "Open-source the summary_json.extra_fields model as a standard. Copy-paste schemas for all five thread types.",
  "pillar": "P1",
  "pillarLabel": "Operating model",
  "date": "2026-04-27",
  "readMinutes": 4,
  "author": "dium.io research",
  "coverTitle": "Thread Schemas Field Guide",
  "blocks": [
    {
      "type": "tldr",
      "text": "Every wave-based community thread can be modeled with: thread_type, summary_json.extra_fields, and a per-mode lifecycle cron. Here are the schemas for all five thread types: copy-paste, validate against your own platform, ship."
    },
    {
      "type": "p",
      "text": "The operating model question, what is the unit of community work, and how does the platform represent it, is the question every other community decision flows from. This essay sits in that frame. The shape of <strong>Field Guide to Thread Schemas</strong> is not a UI detail; it is the primitive your members touch every time they post, the schema your engineers carry in their head, and the lifecycle your moderators have to govern. Get the primitive right and the operator burden drops by an order of magnitude. Get it wrong and every workflow downstream becomes a workaround.",
      "_enriched": true
    },
    {
      "type": "h2",
      "text": "The base schema (every thread)",
      "_id": "the-base-schema-every-thread"
    },
    {
      "type": "code",
      "code": "{\n  \"id\": \"t_abc123\",\n  \"flow_id\": \"f_main\",\n  \"author_id\": \"u_xyz\",\n  \"title\": \"...\",\n  \"context_html\": \"<p>...</p>\",\n  \"thread_type\": \"conversation|question|broadcast|session|execution\",\n  \"status\": \"open|solved|live|expired|locked|archived\",\n  \"tags\": [\"...\"],\n  \"pinned\": 0,\n  \"created_at\": \"2026-04-27T10:00:00Z\",\n  \"summary_json\": { ... }\n}"
    },
    {
      "type": "h2",
      "text": "Per-type extra_fields",
      "_id": "per-type-extra-fields"
    },
    {
      "type": "code",
      "code": "// Conversation\n{ \"thread_type\":\"conversation\", \"conv_style\":\"Open|Brainstorm|Debate\", \"slow\":false }\n\n// Inquiry\n{ \"thread_type\":\"question\", \"inquiry_mode\":\"Question|Help|AMA|Office hours\",\n  \"best_answer\":true, \"urgency\":\"Normal|High|Critical\", \"route_to\":\"@x\" }\n\n// Broadcast\n{ \"thread_type\":\"broadcast\", \"importance\":\"Normal|Important|Must read\",\n  \"cta_label\":\"...\", \"cta_url\":\"...\", \"effective\":\"YYYY-MM-DD\", \"expiry\":\"YYYY-MM-DD\" }\n\n// Session\n{ \"thread_type\":\"session\", \"format\":\"Workshop|Talk|Cohort|...\",\n  \"host\":\"...\", \"agenda_items\":\"...\", \"materials\":\"...\" }\n\n// Execution\n{ \"thread_type\":\"execution\", \"exec_type\":\"Task|Project|Hiring|Gig|Hackathon\",\n  \"roles_needed\":\"...\", \"compensation\":\"...\", \"deadline\":\"YYYY-MM-DD\" }"
    },
    {
      "type": "callout",
      "color": "mint",
      "text": "The summary_json.extra_fields pattern means you don't need a column-per-thread-type explosion. One JSON column, indexed where you query, with the per-type schema validated at the API."
    },
    {
      "type": "h2",
      "text": "Lifecycle cron sketch",
      "_id": "lifecycle-cron-sketch"
    },
    {
      "type": "p",
      "text": "The cron runs every 5 minutes, scans threads in 'open' status, applies type-and-mode-specific close conditions, and (for recurring) clones the next occurrence. See {{LINK:5-thread-types-modern-community:the operating model essay}} for the full lifecycle table."
    },
    {
      "type": "h2",
      "text": "Indexing strategy",
      "_id": "indexing-strategy"
    },
    {
      "type": "p",
      "text": "Index thread_type, author_id, flow_id, status, and (for sorting) created_at. For Inquiry, additionally index a generated column on summary_json->>'inquiry_mode' to filter the lifecycle cron. Most platforms get away with these six indexes through 100k threads per tenant."
    },
    {
      "type": "h2",
      "text": "Why this matters more in 2026 than it did three years ago",
      "_enriched": true,
      "_id": "why-this-matters-more-in-2026-than-it-did-three-years-ago"
    },
    {
      "type": "p",
      "text": "The community-software market in 2023 was a feature race. The market in 2026 is a primitive race. The platforms with the right unit of work scale linearly with adoption; the platforms with the wrong unit scale linearly with operator headcount. Field Guide to Thread Schemas sits exactly on this fault line: a small primitive decision with enormous downstream leverage. The teams who treat this as a UI question lose to the teams who treat it as an architecture question.",
      "_enriched": true
    },
    {
      "type": "h2",
      "text": "How to think about it",
      "_enriched": true,
      "_id": "how-to-think-about-it"
    },
    {
      "type": "p",
      "text": "The honest test is the composer test. Walk a new member to your platform, hand them the composer, and ask them what they think they should do next. Every additional decision the composer asks for is a tax on participation. The model that wins is the one where the typed primitive does the work the member would otherwise have to think about: pick a channel, pick a category, pick a tag, decide whether to mention anyone. Move those decisions into the type and the composer goes from intimidating to inviting.",
      "_enriched": true
    },
    {
      "type": "p",
      "text": "The second test is the search test. Six months from now, will a member be able to find this contribution by Googling for it? If the answer is no, the unit you chose is unaddressable, and the value of the contribution evaporates as soon as the next post pushes it out of view. Addressable typed threads pass both tests; unaddressable channels and untyped messages fail both.",
      "_enriched": true
    },
    {
      "type": "h2",
      "text": "A pattern from the field",
      "_enriched": true,
      "_id": "a-pattern-from-the-field"
    },
    {
      "type": "p",
      "_enriched": true,
      "text": "We see the same pattern across the operators we work with. The teams who treat Field Guide to Thread Schemas as an upstream design decision: encoded in the platform's defaults, surfaced in the operator dashboard, and audited as a standing line item in the quarterly review: see the downstream metrics move within 60-90 days. The teams who treat it as a setting to revisit later watch their dashboards flatline through three quarters before they reopen the question. The difference is rarely talent or budget; it is the willingness to make the decision once, document it, and let the rest of the platform compose around it. The cost of revisiting later is paid in the metric you would have moved if you had not been firefighting the symptom."
    },
    {
      "type": "h2",
      "text": "Anti-patterns we keep watching teams ship",
      "_enriched": true,
      "_id": "anti-patterns-we-keep-watching-teams-ship"
    },
    {
      "type": "ul",
      "items": [
        "Treating the new primitive as an extra checkbox on the existing composer rather than a first-class type selector.",
        "Ignoring the lifecycle, the rules for when a thread closes, archives, or auto-spawns the next occurrence, because \"we will figure it out later.\"",
        "Letting the operator override defaults invisibly (a power move that always becomes a footgun within two quarters).",
        "Optimizing for the power-poster who will tolerate complexity and losing the casual contributor who will not."
      ],
      "_enriched": true
    },
    {
      "type": "callout",
      "color": "lavender",
      "text": "The primitive sets the ceiling. Lifecycle, defaults, and discovery surface are the floor. Skipping any of the four turns the right primitive into the wrong product.",
      "_enriched": true
    },
    {
      "type": "h2",
      "text": "What to ship next sprint",
      "_enriched": true,
      "_id": "what-to-ship-next-sprint"
    },
    {
      "type": "p",
      "text": "Audit your composer end-to-end with a stopwatch. Time how long it takes a brand-new member to publish their first thread without help. Anything above 90 seconds is failure; below 45 seconds is healthy. Most platforms we audit land at 2-4 minutes for the first post: almost entirely because the composer asks the member to make decisions the type system should have made automatically. Trim to one type-selector and progressive disclosure for everything else; watch the time-to-publish metric collapse and the first-week retention curve straighten out.",
      "_enriched": true
    },
    {
      "type": "h2",
      "text": "The takeaway",
      "_enriched": true,
      "_id": "the-takeaway"
    },
    {
      "type": "p",
      "text": "The operating-model decisions feel small because they are encoded in defaults nobody discusses. They are not small. They are the shape your community grows into. Pick the primitive that matches the work, ship the lifecycle that matches the primitive, default the composer to make the right thread the easy thread, and the next year of your community looks structurally different from the last one. Field Guide to Thread Schemas is one of the leverage points where that structural difference compounds.",
      "_enriched": true
    }
  ],
  "cta": {
    "title": "Run the schema in your own platform.",
    "body": "Dium uses exactly these schemas in production. The migration scripts are in our docs.",
    "buttonText": "View docs → ",
    "buttonHref": "../../"
  },
  "wordCount": 992,
  "updated": "2026-04-27",
  "url": "https://dium.io/blog/posts/thread-schemas-field-guide.html",
  "category": "https://dium.io/blog/category/operating-model/",
  "authorUrl": "https://dium.io/blog/author/dium-research/",
  "coverImage": "https://cdn.twc.sh/images/igcache/Thread%20Schemas%20Field%20Guide/1200_830/blog.jpg",
  "coverImageWide": "https://cdn.twc.sh/images/igcache/Thread%20Schemas%20Field%20Guide/1600_900/blog.jpg",
  "coverImageSmall": "https://cdn.twc.sh/images/igcache/Thread%20Schemas%20Field%20Guide/600_415/blog.jpg",
  "aeo": {
    "keyClaims": [
      "Every wave-based community thread can be modeled with: thread_type, summary_json.extra_fields, and a per-mode lifecycle cron.",
      "The primitive sets the ceiling. Lifecycle, defaults, and discovery surface are the floor. Skipping any of the four turns the right primitive into the wrong product."
    ],
    "prospects": [
      "Community managers building from scratch",
      "Founders picking the right primitives",
      "Engineers designing the schema"
    ],
    "stats": [
      {
        "num": "4m",
        "label": "Read time"
      },
      {
        "num": "Operating model",
        "label": "Category"
      }
    ]
  },
  "related": [
    {
      "slug": "wave-is-right-unit-channel-wrong",
      "title": "The 'Wave' Is the Right Unit of Community Work, and 'Channel' Is the Wrong One",
      "pillar": "P1",
      "pillarLabel": "Operating model",
      "href": "/blog/posts/wave-is-right-unit-channel-wrong.html"
    },
    {
      "slug": "auto-spawn-recurring-office-hours-cron",
      "title": "Auto-Spawning Recurring Office Hours: the Cron That Turns 1 Thread Into 52",
      "pillar": "P1",
      "pillarLabel": "Operating model",
      "href": "/blog/posts/auto-spawn-recurring-office-hours-cron.html"
    },
    {
      "slug": "execution-threads-jobs-board",
      "title": "Execution Threads: How 'Hire / Hackathon / Project' Lives in Your Forum, Not Your Project Tool",
      "pillar": "P1",
      "pillarLabel": "Operating model",
      "href": "/blog/posts/execution-threads-jobs-board.html"
    },
    {
      "slug": "best-answer-opt-in-server-enforce",
      "title": "'Best Answer' as an Opt-In: Why Your Askers Should Choose, and Your API Should Enforce",
      "pillar": "P1",
      "pillarLabel": "Operating model",
      "href": "/blog/posts/best-answer-opt-in-server-enforce.html"
    }
  ]
}