Building My Automated Social Media Publisher — Part 1: The Problem
Publishing a blog post is only part of the job.
Once an article is written and published, there is another task waiting: getting people to actually see it. With several blogs producing articles on different subjects, that means repeatedly creating social-media posts, deciding where they should go, deciding when they should appear, and remembering to do it.
At first, this doesn't seem particularly difficult. One article, one social-media post — job done.
But multiply that across several blogs and several social networks, and the simple task becomes a recurring administrative chore.
The Problem I Wanted to Solve
That was the problem I wanted to solve.
I didn't want to build a giant social-media management system. I wasn't interested in replacing the commercial platforms that already exist, and I certainly didn't need hundreds of features.
I wanted something much simpler.
I wanted to write my articles and have a small application take care of the repetitive work of promoting them.
Write the article. Publish it. Let the computer handle the promotion.
The First Question
But before I could build that system, there was a much bigger question to answer.
How should my application actually get the posts onto the various social networks?
The Obvious Solution
Our first thought was obvious: connect directly to them.
X has an API. Facebook has an API. LinkedIn has an API. Other networks have their own APIs.
So why not simply write the software to talk to each one?
At first glance, this seemed perfectly reasonable. Our application would know how to communicate with each network, and we would have complete control over the publishing process.
The problem was what happened when we looked at what that would actually involve.
Every Network Is Different
Every network has its own API, authentication arrangements, permissions, data formats and publishing requirements.
Supporting another network would mean another integration, another piece of code and another thing that could eventually need maintaining.
What initially looked like one application with a few publishing functions was starting to look more like a collection of separate integrations held together by our application.
The more networks we wanted to support, the more complicated our supposedly simple application would become.
Changing the Question
At that point, the problem changed.
Instead of asking:
How do I make my application talk to every social network?
we started asking:
Is there something else that can sit between my application and the social networks?
That turned out to be a much more interesting question.
What Came Next
Once we had decided that building a separate integration for every social network was probably the wrong approach, we started looking for an intermediary.
We looked at a number of possibilities, including the larger social-media management platforms.
Eventually, we settled on a service called Buffer.
But that decision — and why we chose Buffer rather than simply building everything ourselves — is the subject of Part 2.

Comments
Post a Comment