Build vs Buy: A Social Publishing Integration, Costed
The build versus buy question for social publishing sounds architectural. It is arithmetic, and the arithmetic has one input most teams never put in the spreadsheet: the surface that keeps changing after launch. You do not build a client for one network. You build a matrix with a column per network, and then you staff the calendar on which those columns mutate.
Decision memo for the team that has to keep it running.
In short
- Building one platform integration is a week of engineering. Keeping eight of them alive is the product, and nobody estimates that line.
- The break-even is not subscription price against a developer salary. It is the refresh date: token lifetimes, review policies and posting rules move on the platform’s schedule.
- Buy when publishing is a feature of your product. Build only for the network that is the whole product, or for the one the vendors will not cover.
What one integration actually includes
An integration is not a POST request. It is authentication, media handling, per-network text rules, settings the network needs before it will accept a post, token refresh, a scheduler with retries, and a way to find out later what actually published. Each of those has a per-network branch.
Here is the inventory from the publishing layer I maintain, counted on the current main branch rather than recalled:
| Piece | What varies per network | Counted today |
|---|---|---|
| Text limits | Every network has its own counting rule, some count links as fixed width, some count UTF-16 units | 32 of 34 provider modules define their own length function |
| Extra settings | Boards, categories, tags, visibility, server URLs, channels, subreddits | 16 of 34 declare custom settings fields |
| Token refresh | Some refresh on a schedule, some must refresh right before publishing or the call fails | 3 scheduled refresh paths, 2 refresh-before-publish paths |
| Media prep | One network needs JPEG conversion, one strips links from the body | 1 each |
| Composer mode | Plain text, Markdown or HTML depending on the target | 3 modes across the network set |
| Preview | Each network frames media and folds text differently | 8 preview families cover 30+ networks |
Two conclusions follow. The first is that your abstraction has to be a per-network settings blob from day one, because the second network always needs a field the first one did not. The second is that none of this work is hard. All of it is small, and small work that arrives from eight vendors’ changelogs is how a quarter disappears.
The build side, costed
Numbers below are my estimates from building this layer, labeled as estimates because I have never seen a published study with real figures that survived contact with a second team.
| Activity | First build | Yearly upkeep |
|---|---|---|
| OAuth app per vendor, scopes, review submission | 2 to 5 days plus 2 to 6 weeks of calendar | Re-review when scopes or policies change |
| Publish endpoint per network | 1 to 3 days | 0.5 to 2 days per network per quarter |
| Media host, upload, format rules | 3 to 5 days | Occasional, plus storage cost |
| Scheduler, worker, retries, backfill of results | 5 to 10 days | Steady: this is the part that pages someone |
| Token refresh and revocation handling | 2 to 3 days | 1 to 3 days per quarter total |
| Preview rendering per network family | 3 to 5 days | 1 day per quarter |
| Approval state, audit trail of who approved what | 1 to 2 weeks if you take it seriously | Growing |
For a first platform:
- Engineering: one to two weeks for a competent developer who has not done it before.
- Review: two to six weeks of calendar time for the vendors that require it, during which your posting works only for your own accounts.
- The second platform costs three to five days of engineering, because your abstraction was shaped by the first one and leaks.
For six platforms, a realistic first build is five to eight weeks of one developer, with two vendor reviews in parallel and one more that will surprise you, then steady upkeep of three to six days per quarter forever. That upkeep number is the honest one, and it is the number that decides the question.
The buy side, stated fairly
Buying is not free of engineering either. You still map your data model to the vendor’s, handle their error codes, decide what a partial failure means for your UI, and build the read-back that tells a customer what went live. What you stop doing is maintaining eight vendor clients and their review paperwork.
The real costs on this side:
- The pricing unit. Per profile, per brand, per channel and per workspace are different products sold with the same word. Model your actual roster before comparing totals, because the cheap tier and the expensive tier are often separated by the unit rather than the fee.
- Dependency. When the vendor has an incident, you have an incident, and you cannot fix it. Ask what their read-back gives you during a failure: a status you can poll, a signed webhook, or support email only.
- The gap. A vendor will not have every field of every network. Before you commit, list the fields your customers actually ask for, then check them one by one.
- The exit. Captions, media references and publishing history should export without a support ticket, and channel connections should sit under accounts the buyer controls.
A vendor that hides those four items is selling you a different kind of lock-in than building your own: the quiet kind, where leaving costs a migration rather than a rewrite.
The formula, worked
Take the arithmetic seriously and the answer often flips depending on one variable.
One-time build cost = engineering weeks x loaded weekly developer cost.
Annual run cost = maintainer days per quarter x 4 x daily loaded cost.
Then compare against the vendor’s annual price at your roster size, and add your integration time on the bought side, which is not zero: assume two to four days to integrate, plus one to two days per year per vendor version change.
A worked example, with a loaded cost of $4,000 per engineering week (estimate, adjust to your market):
| Route | One-time | Annual run | Year one |
|---|---|---|---|
| Build 6 networks | 6 weeks, about $24,000 | 5 days per quarter, about $7,700 | about $31,700 |
| Build 1 network | 1.5 weeks, about $6,000 | 1.5 days per quarter, about $2,300 | about $8,300 |
| Buy, 30-channel tier | 3 days, about $2,400 | $540 in subscription at a $45 monthly tier | about $2,940 |
The buy line wins on year one in both build scenarios, and it wins by more in year three, because the maintenance column compounds and the subscription does not. The build line only wins when the integration is the product, or when volume makes the subscription a real variable cost.
Where building is genuinely right
I would build in three cases, and I say this as someone who sells the other option:
- Publishing to one network is the product. A tool for Bluesky power users should own its Bluesky client. The vendor abstraction costs you the fields that make you different.
- You need behavior no vendor exposes. Custom threading logic, a specific media pipeline, or a deliverability pattern the API layer cannot express.
- The volumes price you out. At tens of thousands of posts a month, a flat subscription that fits becomes either a bargain or a ceiling, and you should model both.
The trap is building for the second reason when you actually have the first: a product that posts everywhere and differentiates nowhere, with a maintenance bill that grows with every network you bolt on.
The hybrid most teams should pick
Build the one network that carries your differentiation, buy the rest. Your own client for the one place your users judge you, and a publishing layer for the long tail where “it posts and tells me when it failed” is the whole requirement. That split keeps the interesting engineering and moves the changelog maintenance, which is the part nobody wants to own on a Friday.
If the long tail is what you need, the scheduling API overview covers what the layer exposes today, and the pricing page is where the roster math starts. The Buffer API retirement is the cautionary version of this decision.
Five questions for either route
Ask these before you commit engineering time or a card, because the answers separate a product from a demo.
- Who works the weekend when a platform changes? On the build side that is you, by definition. On the buy side, get a named answer and a status page.
- What happens when three of five channels publish and two fail? A retry that duplicates posts is worse than a failure. Look for an idempotency key on the write, and a documented conflict rather than a silent second post.
- Can you prove what went live? Ask for a signed webhook plus a read-back endpoint, and check the payload shape. A single event with a POST array beats a stream of notifications you have to reconcile.
- Can you gate an agent without watching it? Conditions such as “contains a link”, “outside working hours” or “over the daily cap”, with an effect of require approval or block, are the difference between automation and supervision. Idempotency and webhooks that confirm a post went live are the two mechanisms worth testing first.
- What does leaving cost? If the export needs a support ticket, price that into the decision now.
The decision is legitimate either way. What is not legitimate is choosing build because it feels like the serious option, then discovering in month four that the maintenance calendar was the product all along.
Frequently asked questions
How long does it take to build a social publishing integration for one platform?
Roughly one to two weeks of engineering for the first platform, then three to five days for each extra one, plus the vendor review calendar. The review is the part that surprises people: Meta and TikTok both gate public posting behind an app review or audit that runs on their clock, not yours.
Is buying cheaper at small scale?
Usually yes, once you count upkeep rather than only the first build. A small team's integration bill is tens of dollars a month, while the maintenance of even four platforms is measured in days per quarter. The exception is a product whose whole value is publishing to one network, where owning the client is defensible.
What is the technical exit cost if we switch later?
It depends on two things: whether you can export every caption, media reference and publishing record, and who owns the OAuth connection. A connection held by an individual's login dies with that person's access, so ask for the client-owned business account model before the first post, not after.
Do we still need our own approval and audit layer if we buy publishing?
Only if the vendor exposes approval state and publishing state as readable objects. If the only status you can read is scheduled, your dashboard cannot tell a queued post from one the platform accepted, and you will build that layer yourself anyway.