自动化社交媒体帖子：从内容日历到API

管理产品的社交媒体意味着在不同平台之间保持一致的发布，每个平台都有其独特的API特性、认证流程、媒体要求和速率限制。在每周三次手动将相同内容发布到四个平台后，我构建了一个自动化流程，负责调度、格式化、媒体处理和发布——其中包含一个审批步骤，以确保所有内容都经过人工审核。本文将介绍其架构、平台特有的陷阱，以及构建自定义系统与使用现有工具之间的权衡。

平台API概览

每个主流平台都有自己的API生态系统，开发者体验差异巨大。以下是截至2026年初，各平台的真实状况。

Twitter/X API

自平台转型以来，X API经历了重大变革。当前的API (v2) 提供发布、媒体上传和分析端点。免费层级每月允许发布1,500条帖子，并可读取自己的帖子，这对于大多数自动化用例来说已经足够。

认证模型使用OAuth 2.0 with PKCE进行用户上下文操作（代表用户发布），并使用OAuth 2.0 App-Only进行读取操作。该API文档相当完善，开发者门户提供了清晰的速率限制信息。

import { TwitterApi } from 'twitter-api-v2';

const client = new TwitterApi({
  appKey: process.env.TWITTER_API_KEY!,
  appSecret: process.env.TWITTER_API_SECRET!,
  accessToken: process.env.TWITTER_ACCESS_TOKEN!,
  accessSecret: process.env.TWITTER_ACCESS_SECRET!,
});

async function postTweet(text: string, mediaIds?: string[]): Promise<string> {
  const tweet = await client.v2.tweet({
    text,
    ...(mediaIds && { media: { media_ids: mediaIds } }),
  });
  return tweet.data.id;
}

async function uploadMedia(filePath: string): Promise<string> {
  const mediaId = await client.v1.uploadMedia(filePath);
  return mediaId;
}

主要限制： 帖子有280个字符的限制（高级用户更长）。图片上传支持JPEG、PNG、GIF和WEBP格式，最大5MB。视频上传支持MP4格式，最大512MB，但对于超过15MB的文件需要分块上传。推文串（Threads）需要创建多个带有reply设置的帖子，这增加了复杂性。

Instagram Graph API

Instagram的API是Meta生态系统的一部分，需要一个链接到Instagram专业账户的Facebook商业主页。设置过程出了名的复杂——你需要一个Meta应用、商业验证（针对某些功能）以及正确的权限组合。

发布流程分为两步：首先创建媒体容器，然后发布它。

async function postToInstagram(
  igUserId: string,
  imageUrl: string,
  caption: string,
  accessToken: string
): Promise<string> {
  // Step 1: Create media container
  const containerResponse = await fetch(
    `https://graph.facebook.com/v19.0/${igUserId}/media`,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        image_url: imageUrl, // Must be a publicly accessible URL
        caption,
        access_token: accessToken,
      }),
    }
  );
  const container = await containerResponse.json();

  // Step 2: Publish the container
  const publishResponse = await fetch(
    `https://graph.facebook.com/v19.0/${igUserId}/media_publish`,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        creation_id: container.id,
        access_token: accessToken,
      }),
    }
  );
  const result = await publishResponse.json();
  return result.id;
}

主要陷阱：

• 图片必须托管在公开可访问的URL上。你不能直接上传二进制数据。这意味着在发布之前，你需要将媒体托管在S3或CDN上。
• 轮播帖子（多张图片）需要为每张图片创建单独的容器，然后创建一个引用它们的轮播容器。
• Reels（视频）有额外的要求：9:16的宽高比，时长在3到90秒之间，并且视频必须在发布前完全处理完毕。
• 访问令牌会过期。长期令牌有效期为60天，需要定期刷新。

LinkedIn API

LinkedIn用于发布内容的API使用“社区管理API”（以前称为“分享API”）。认证使用OAuth 2.0，其中w_member_social范围用于个人资料，w_organization_social用于公司页面。

async function postToLinkedIn(
  authorUrn: string, // "urn:li:person:xxx" or "urn:li:organization:xxx"
  text: string,
  accessToken: string
): Promise<string> {
  const response = await fetch('https://api.linkedin.com/v2/posts', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${accessToken}`,
      'Content-Type': 'application/json',
      'X-Restli-Protocol-Version': '2.0.0',
      'LinkedIn-Version': '202401',
    },
    body: JSON.stringify({
      author: authorUrn,
      commentary: text,
      visibility: 'PUBLIC',
      distribution: {
        feedDistribution: 'MAIN_FEED',
        targetEntities: [],
        thirdPartyDistributionChannels: [],
      },
      lifecycleState: 'PUBLISHED',
    }),
  });

  const postId = response.headers.get('x-restli-id');
  return postId || '';
}

主要限制： LinkedIn的API文档分散在多个版本和命名约定中。大多数端点的速率限制是每个用户每个应用程序每天100次API调用，这对于发布来说很宽松，但如果你同时拉取分析数据则会很紧张。图片上传需要一个单独的上传流程，并带有注册上传请求。

TikTok 内容发布API

TikTok用于内容发布的API相对较新，并且比其他平台更受限制。你需要专门申请内容发布API的访问权限，审批可能需要数周时间。

发布流程包括初始化发布、上传视频，然后确认发布：

async function postToTikTok(
  videoUrl: string,
  caption: string,
  accessToken: string
): Promise<string> {
  // Initialize the publish
  const initResponse = await fetch(
    'https://open.tiktokapis.com/v2/post/publish/video/init/',
    {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${accessToken}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        post_info: {
          title: caption,
          privacy_level: 'SELF_ONLY', // Start as private, change after review
          disable_duet: false,
          disable_comment: false,
          disable_stitch: false,
        },
        source_info: {
          source: 'PULL_FROM_URL',
          video_url: videoUrl,
        },
      }),
    }
  );

  const result = await initResponse.json();
  return result.data.publish_id;
}

主要陷阱： TikTok要求所有自动化帖子都必须披露其自动化性质——为此有特定的API标志。视频必须符合TikTok的内容指南和格式要求。该API对每个用户账户有严格的每日发布限制。最关键的是，TikTok的API生态系统变化频繁，因此在实施前请务必查阅最新文档。

认证流程

所有四个平台都使用OAuth 2.0，但实现细节差异很大，需要针对特定平台进行处理。

OAuth 流程

一般流程是：

1. 将用户重定向到平台的授权URL，并附带你的应用的client_id和请求的scopes。
2. 用户授予权限。平台将通过授权code重定向回你的redirect_uri。
3. 用code换取access_token（通常还有refresh_token）。
4. 使用access_token进行API调用。当它过期时刷新它。

// Generic OAuth handler
interface OAuthConfig {
  clientId: string;
  clientSecret: string;
  redirectUri: string;
  authorizationUrl: string;
  tokenUrl: string;
  scopes: string[];
}

async function exchangeCodeForToken(
  config: OAuthConfig,
  code: string
): Promise<{ accessToken: string; refreshToken: string; expiresIn: number }> {
  const response = await fetch(config.tokenUrl, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'authorization_code',
      code,
      redirect_uri: config.redirectUri,
      client_id: config.clientId,
      client_secret: config.clientSecret,
    }),
  });

  const data = await response.json();
  return {
    accessToken: data.access_token,
    refreshToken: data.refresh_token,
    expiresIn: data.expires_in,
  };
}

令牌管理

令牌会过期。Instagram令牌有效期为60天。LinkedIn令牌有效期为60天。Twitter令牌在被撤销之前有效（对于OAuth 1.0a）或者使用刷新令牌是短期的（对于OAuth 2.0）。TikTok令牌有效期为24小时，刷新令牌有效期为365天。

你需要一个令牌刷新系统：

interface StoredToken {
  platform: string;
  accessToken: string;
  refreshToken: string;
  expiresAt: Date;
}

async function getValidToken(platform: string): Promise<string> {
  const stored = await db.tokens.findUnique({ where: { platform } });
  if (!stored) throw new Error(`No token stored for ${platform}`);

  // Refresh if expiring within 5 minutes
  if (stored.expiresAt < new Date(Date.now() + 5 * 60 * 1000)) {
    const refreshed = await refreshToken(platform, stored.refreshToken);
    await db.tokens.update({
      where: { platform },
      data: {
        accessToken: refreshed.accessToken,
        refreshToken: refreshed.refreshToken || stored.refreshToken,
        expiresAt: new Date(Date.now() + refreshed.expiresIn * 1000),
      },
    });
    return refreshed.accessToken;
  }

  return stored.accessToken;
}

内容调度架构

调度系统是自动化流程的核心。它需要处理时区、平台特定格式、媒体处理和故障恢复。

数据模型

interface ScheduledPost {
  id: string;
  content: {
    text: string;
    media?: MediaAttachment[];
    platformOverrides?: Record<string, { text?: string }>;
  };
  platforms: Platform[];
  scheduledAt: Date;  // UTC
  timezone: string;   // IANA timezone for display
  status: 'draft' | 'approved' | 'scheduled' | 'publishing' | 'published' | 'failed';
  results: Record<string, PostResult>;
  retryCount: number;
  createdBy: string;
  approvedBy?: string;
  approvedAt?: Date;
}

interface MediaAttachment {
  originalUrl: string;
  processedUrls: Record<string, string>; // Platform-specific processed versions
  type: 'image' | 'video';
  altText?: string;
}

interface PostResult {
  platform: string;
  postId?: string;
  url?: string;
  error?: string;
  publishedAt?: Date;
}

platformOverrides 模式

每个平台都有不同的字符限制、话题标签约定和格式规范。我没有为每个平台创建完全独立的帖子，而是使用一个基础文本，并带有平台特定的覆盖内容：

const post: ScheduledPost = {
  id: 'post-1',
  content: {
    text: 'Excited to announce our new feature: real-time order tracking. Customers can now see exactly where their delivery is. #product #launch',
    platformOverrides: {
      twitter: {
        text: 'Just shipped: real-time order tracking. Your customers can now watch their delivery in real-time. #buildinpublic',
      },
      linkedin: {
        text: 'Excited to announce our latest feature: real-time order tracking.\n\nThis was one of the most requested features from our restaurant partners. Customers can now see exactly where their delivery is, reducing "where is your food?" support tickets by an estimated 40%.\n\nBuilt with WebSockets and a lightweight location service. Happy to share the technical architecture with anyone interested.\n\n#productdevelopment #startups #foodtech',
      },
    },
  },
  platforms: ['twitter', 'instagram', 'linkedin'],
  scheduledAt: new Date('2026-03-15T14:00:00Z'),
  timezone: 'America/New_York',
  status: 'approved',
  results: {},
  retryCount: 0,
  createdBy: 'user-1',
};

Twitter获得一个简洁版本。LinkedIn获得一个更长、更专业的版本。Instagram使用基础文本作为标题。这种方法在不维护完全独立的内容日历的情况下，尊重了平台规范。

媒体处理

媒体处理是流程中最容易出错的部分。每个平台对图片尺寸、文件大小、格式和宽高比都有不同的要求。

处理流程

interface MediaRequirements {
  maxWidth: number;
  maxHeight: number;
  maxFileSize: number; // bytes
  supportedFormats: string[];
  aspectRatios?: { min: number; max: number };
}

const platformRequirements: Record<string, MediaRequirements> = {
  twitter: {
    maxWidth: 4096,
    maxHeight: 4096,
    maxFileSize: 5 * 1024 * 1024, // 5MB
    supportedFormats: ['jpeg', 'png', 'gif', 'webp'],
  },
  instagram: {
    maxWidth: 1440,
    maxHeight: 1440,
    maxFileSize: 8 * 1024 * 1024,
    supportedFormats: ['jpeg', 'png'],
    aspectRatios: { min: 4 / 5, max: 1.91 },
  },
  linkedin: {
    maxWidth: 4096,
    maxHeight: 4096,
    maxFileSize: 10 * 1024 * 1024,
    supportedFormats: ['jpeg', 'png', 'gif'],
  },
};

async function processMediaForPlatform(
  originalUrl: string,
  platform: string
): Promise<string> {
  const requirements = platformRequirements[platform];
  const image = await sharp(await downloadFile(originalUrl));
  const metadata = await image.metadata();

  let processed = image;

  // Resize if exceeding max dimensions
  if (
    (metadata.width && metadata.width > requirements.maxWidth) ||
    (metadata.height && metadata.height > requirements.maxHeight)
  ) {
    processed = processed.resize(requirements.maxWidth, requirements.maxHeight, {
      fit: 'inside',
      withoutEnlargement: true,
    });
  }

  // Enforce aspect ratio for Instagram
  if (requirements.aspectRatios && metadata.width && metadata.height) {
    const currentRatio = metadata.width / metadata.height;
    if (
      currentRatio < requirements.aspectRatios.min ||
      currentRatio > requirements.aspectRatios.max
    ) {
      // Crop to acceptable ratio
      const targetRatio = Math.max(
        requirements.aspectRatios.min,
        Math.min(currentRatio, requirements.aspectRatios.max)
      );
      const newWidth = Math.round(metadata.height * targetRatio);
      processed = processed.resize(newWidth, metadata.height, { fit: 'cover' });
    }
  }

  // Convert to supported format
  const format = requirements.supportedFormats.includes('webp') ? 'webp' : 'jpeg';
  const buffer = await processed.toFormat(format, { quality: 85 }).toBuffer();

  // Upload processed image and return URL
  const processedUrl = await uploadToStorage(buffer, `processed/${platform}/${Date.now()}.${format}`);
  return processedUrl;
}

使用Sharp进行图像处理可以保持流程快速，并处理EXIF旋转、颜色配置文件转换和格式兼容性等边缘情况。对于视频处理，FFmpeg负责转码，但视频处理要复杂得多且资源密集——我通常将其卸载到专用的工作程序或云函数中。

速率限制和重试逻辑

每个平台都强制执行速率限制，不优雅地触及这些限制会导致帖子发布失败，并可能导致临时API封禁。

速率限制跟踪

interface RateLimitState {
  platform: string;
  remaining: number;
  resetAt: Date;
  limit: number;
}

class RateLimiter {
  private limits: Map<string, RateLimitState> = new Map();

  updateFromHeaders(platform: string, headers: Headers): void {
    const remaining = parseInt(headers.get('x-rate-limit-remaining') || '100');
    const resetTimestamp = parseInt(headers.get('x-rate-limit-reset') || '0');

    this.limits.set(platform, {
      platform,
      remaining,
      resetAt: new Date(resetTimestamp * 1000),
      limit: parseInt(headers.get('x-rate-limit-limit') || '100'),
    });
  }

  async waitIfNeeded(platform: string): Promise<void> {
    const state = this.limits.get(platform);
    if (!state) return;

    if (state.remaining <= 1 && state.resetAt > new Date()) {
      const waitMs = state.resetAt.getTime() - Date.now() + 1000; // 1s buffer
      console.log(`Rate limited on ${platform}. Waiting ${waitMs}ms`);
      await new Promise((resolve) => setTimeout(resolve, waitMs));
    }
  }
}

指数退避重试

并非所有故障都是永久性的。网络超时、临时服务器错误和速率限制都是可重试的。数据库错误和认证失败则不可重试。

async function publishWithRetry(
  post: ScheduledPost,
  platform: string,
  maxRetries: number = 3
): Promise<PostResult> {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      await rateLimiter.waitIfNeeded(platform);
      const result = await publishToPlatform(post, platform);
      return { platform, postId: result.id, url: result.url, publishedAt: new Date() };
    } catch (error) {
      const isRetryable =
        error instanceof RateLimitError ||
        error instanceof NetworkError ||
        (error instanceof ApiError && error.statusCode >= 500);

      if (!isRetryable || attempt === maxRetries) {
        return {
          platform,
          error: error instanceof Error ? error.message : 'Unknown error',
        };
      }

      const backoffMs = Math.min(1000 * Math.pow(2, attempt), 30000);
      const jitter = Math.random() * 1000;
      await new Promise((resolve) => setTimeout(resolve, backoffMs + jitter));
    }
  }

  return { platform, error: 'Max retries exceeded' };
}

抖动（jitter）很重要——如果没有它，多个在相同退避调度上同步重试的客户端会产生“惊群问题”（thundering herd problems），即它们同时重试。

内容审批工作流

未经人工审核的自动化发布存在风险。格式错误、危机期间不合时宜的帖子或错误的链接都可能造成实际损害。我在流程中加入了强制性的审批步骤。

审批流程

内容创建 → 状态：草稿 (DRAFT)
       │
       ▼
生成预览 → 通知审阅者 (Slack/email)
       │
       ▼
审阅者批准 → 状态：已批准 (APPROVED) → 计划发布
       │
   或拒绝 → 状态：草稿 (DRAFT) (附带反馈) → 返回创建者

预览步骤很重要——它向审阅者准确展示了每个平台将发布的内容，包括字符数、媒体预览和链接预览。这可以捕获在内容编辑器中不明显的格式问题。

async function generatePreview(post: ScheduledPost): Promise<PlatformPreview[]> {
  return post.platforms.map((platform) => {
    const text =
      post.content.platformOverrides?.[platform]?.text || post.content.text;

    return {
      platform,
      text,
      characterCount: text.length,
      characterLimit: getCharacterLimit(platform),
      isOverLimit: text.length > getCharacterLimit(platform),
      mediaPreview: post.content.media?.map((m) => ({
        url: m.processedUrls[platform] || m.originalUrl,
        type: m.type,
        altText: m.altText,
      })),
      estimatedReach: getEstimatedReach(platform),
    };
  });
}

function getCharacterLimit(platform: string): number {
  const limits: Record<string, number> = {
    twitter: 280,
    instagram: 2200,
    linkedin: 3000,
    tiktok: 2200,
  };
  return limits[platform] || 2200;
}

分析数据收集

发布后，收集互动数据有助于优化未来的内容。每个平台都通过其API提供分析数据，但数据结构和可用性各不相同。

interface PostAnalytics {
  postId: string;
  platform: string;
  collectedAt: Date;
  impressions: number;
  engagements: number;
  clicks: number;
  shares: number;
  comments: number;
  likes: number;
  engagementRate: number;
}

async function collectAnalytics(postResult: PostResult): Promise<PostAnalytics | null> {
  if (!postResult.postId) return null;

  switch (postResult.platform) {
    case 'twitter':
      return collectTwitterAnalytics(postResult.postId);
    case 'linkedin':
      return collectLinkedInAnalytics(postResult.postId);
    case 'instagram':
      return collectInstagramAnalytics(postResult.postId);
    default:
      return null;
  }
}

我在发布后1小时、24小时和7天收集分析数据。这可以捕捉即时互动、每日表现和长尾触达。这些数据会输入到一个简单的仪表盘中，显示哪些内容类型、发布时间和平台带来了最多的互动。

自建 vs 购买：诚实评估

在构建自定义系统之前，请考虑现有工具是否能满足你的需求。

何时使用现有工具

Buffer（每月5-100美元）处理调度、多平台发布和基本分析。它支持Twitter、Instagram、LinkedIn、Facebook、Pinterest和TikTok。其API对于程序化调度来说非常可靠。对于大多数小型团队，Buffer能满足90%的需求。

Hootsuite（每月99美元以上）增加了团队协作、内容审批流程和更深入的分析。更适合拥有多个利益相关者的大型团队。

Typefully（每月12-29美元）专注于Twitter/X，支持推文串、草稿协作和受众分析。如果Twitter是你的主要平台，它非常出色。

Later（每月16.67美元以上）在视觉优先平台（Instagram、Pinterest、TikTok）方面表现出色，提供媒体库管理和可视化日历规划。

何时构建自定义系统

在以下情况下，构建自定义系统是合理的：

• 你需要与内部系统（CMS、产品数据库、CRM）进行深度集成
• 你的内容生成部分自动化（AI生成的草稿、来自产品事件的模板化帖子）
• 你需要现有工具不支持的自定义审批流程
• 你的发布量很大，导致SaaS定价变得昂贵（跨账户每天50+帖子）
• 第三方工具未暴露你所需的平台API功能

混合方法

对于手动内容，使用调度工具（Buffer、Hootsuite），而仅为程序化帖子构建自定义自动化。许多调度工具都提供API，允许你以程序化方式创建帖子，同时使用它们的仪表盘进行审核和批准。

// Using Buffer's API for scheduling
async function scheduleViaBuffer(
  profileIds: string[],
  text: string,
  mediaUrls: string[],
  scheduledAt: Date
): Promise<string> {
  const response = await fetch('https://api.bufferapp.com/1/updates/create.json', {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      access_token: process.env.BUFFER_ACCESS_TOKEN!,
      text,
      'profile_ids[]': profileIds.join(','),
      scheduled_at: scheduledAt.toISOString(),
      ...(mediaUrls.length && { 'media[photo]': mediaUrls[0] }),
    }),
  });

  const result = await response.json();
  return result.updates[0].id;
}

这为你提供了成熟工具的可靠性和用户界面，同时保留了自定义代码的程序化灵活性。

Webhook 通知

当帖子发布、失败或获得显著互动时，系统应通知团队。我使用webhook将事件推送到Slack。

async function notifySlack(event: PostEvent): Promise<void> {
  const color = event.type === 'published' ? '#36a64f' : '#ff0000';
  const title =
    event.type === 'published'
      ? `Posted to ${event.platform}`
      : `Failed to post to ${event.platform}`;

  await fetch(process.env.SLACK_WEBHOOK_URL!, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      attachments: [
        {
          color,
          title,
          text: event.type === 'published'
            ? `"${event.text.substring(0, 100)}..." — ${event.url}`
            : `Error: ${event.error}`,
          fields: [
            { title: 'Platform', value: event.platform, short: true },
            { title: 'Time', value: new Date().toLocaleString(), short: true },
          ],
        },
      ],
    }),
  });
}

错误处理模式

社交媒体API并不可靠。服务器可能宕机，速率限制可能改变，媒体处理可能失败。系统需要优雅地处理故障，而不会丢失内容。

死信队列

所有重试后仍失败的帖子将进入死信队列，等待人工审查：

async function handleFailedPost(post: ScheduledPost, platform: string, error: string): Promise<void> {
  // Update post status
  await db.scheduledPosts.update({
    where: { id: post.id },
    data: {
      status: 'failed',
      results: {
        ...post.results,
        [platform]: { platform, error },
      },
    },
  });

  // Add to dead letter queue
  await db.failedPosts.create({
    data: {
      postId: post.id,
      platform,
      error,
      originalContent: post.content,
      failedAt: new Date(),
      resolved: false,
    },
  });

  // Notify team
  await notifySlack({
    type: 'failed',
    platform,
    text: post.content.text,
    error,
  });
}

仪表盘显示所有失败的帖子，并带有重试按钮。大多数故障是暂时的，通过手动重试即可成功。持续性故障通常表明令牌过期或API更改，需要更新代码。

部分成功处理

一个针对三个平台的帖子可能在两个平台上成功，在一个平台上失败。系统需要独立跟踪每个平台的结果，而不是将整个帖子视为失败：

async function publishToAllPlatforms(post: ScheduledPost): Promise<void> {
  const results = await Promise.allSettled(
    post.platforms.map((platform) => publishWithRetry(post, platform))
  );

  const postResults: Record<string, PostResult> = {};
  let hasFailure = false;

  results.forEach((result, index) => {
    const platform = post.platforms[index];
    if (result.status === 'fulfilled') {
      postResults[platform] = result.value;
      if (result.value.error) hasFailure = true;
    } else {
      postResults[platform] = { platform, error: result.reason.message };
      hasFailure = true;
    }
  });

  await db.scheduledPosts.update({
    where: { id: post.id },
    data: {
      status: hasFailure ? 'failed' : 'published',
      results: postResults,
    },
  });
}

使用Promise.allSettled而不是Promise.all可以确保一个平台上的失败不会阻止向其他平台发布。

整合所有功能

完整的自动化流程如下：

1. 通过网页仪表盘或API创建内容（可选AI辅助起草）。
2. 使用Sharp为每个目标平台上传和处理媒体。
3. 帖子进入审批队列，审阅者在此处查看平台特定的预览。
4. 审批通过后，帖子以UTC时间戳在数据库中进行调度。
5. 一个cron作业（或计划的云函数）检查未来一分钟内到期的帖子。
6. 对于每个到期帖子，发布器会与每个平台进行认证，处理媒体上传，并发布。
7. 结果按平台记录。失败会触发带有指数退避的重试。
8. 重试耗尽的帖子会进入死信队列，并发送Slack通知。
9. 在发布后1小时、24小时和7天收集分析数据。

对于一个每周发布两次的独立创始人来说，这是否过度设计了？当然——请使用Buffer。但对于有程序化内容需求、事件驱动帖子或复杂审批流程的产品来说，自定义流程在一致性和控制方面是值得的。平台API足够稳定，工具也足够成熟，使得实现过程是直接的工程任务，而不是与文档不佳的API作斗争。这在两年前还不是这样。