Building My Automated Social Media Publisher — Part 2: Finding the Middleman


In Part 1, I explained how the idea began with a fairly simple problem: I wanted to automate the repetitive job of promoting my blog posts on social media.

Our first instinct was to connect the application directly to the social networks.

It was a logical idea, but the more we considered it, the less attractive it became. Every social network meant another API, another authentication system, another set of permissions and another integration to maintain.

So we changed the question.

What if my application only had to talk to one service?

Looking for an Intermediary

What we were looking for was effectively a middleman.

My application would prepare the promotion and tell the intermediary where and when it should be published. The intermediary would then deal with the individual social networks.

That would completely change the programming problem.

Instead of building this:

My application → X
My application → Facebook
My application → LinkedIn
My application → Instagram

we could build this:

My application → One publishing service → Social networks

Suddenly the application itself could remain relatively small.

There Were Plenty of Choices

Once we started looking for an intermediary, we discovered that this wasn't an unusual problem at all.

There are a number of services designed to manage social-media publishing. One of the better-known names we considered was Hootsuite.

These services can provide a considerable amount of functionality: scheduling, managing multiple accounts, analytics, collaboration and various other tools intended for people and organisations running substantial social-media operations.

But this raised another question.

How much of that functionality did I actually need?

I Didn't Need a Social Media Department

The answer was: not very much.

I wasn't trying to create a social-media management department. There weren't going to be teams of people collaborating on campaigns, and I wasn't looking for an enormous analytics platform.

The requirement was much more modest.

  • Take a blog article.
  • Create a short promotional post.
  • Attach an image where appropriate.
  • Choose the social account.
  • Choose when it should be published.
  • Send it to the social network.

That was essentially it.

Once we had defined the requirement that way, paying for a huge collection of features that we weren't going to use didn't make much sense either.

Cost Matters Too

There was another consideration: cost.

This was going to be a private application for my own blogs. I wasn't building a commercial social-media management service, so there was little point in paying for functionality designed for an organisation much larger than mine.

What I wanted was an intermediary that provided the functionality I actually needed at a cost that made sense for the relatively small amount of publishing I intended to do.

Why We Settled on Buffer

That was what eventually led us to Buffer.

Buffer gave us the important part of what we needed: an intermediary between our application and the social networks.

More importantly, it fitted the scale of the project.

We didn't need the most powerful social-media platform. We needed one that did enough.

This was an important architectural decision because it meant that our application didn't need to know how every individual social network worked.

Our application only needed to know how to communicate with Buffer.

Buffer could then deal with the platform-specific publishing arrangements.

The Architecture Changed

This decision gave us a much cleaner architecture.

The application would be responsible for the things that were specific to my blogs:

  • finding the articles;
  • recording the promotions;
  • deciding what should be promoted;
  • deciding when it should be published;
  • and keeping track of what had already been scheduled.

Buffer would then take over the final stage of getting those scheduled posts onto the selected social networks.

Our application would decide what to publish and when. Buffer would handle where it gets published.

But We Still Needed to Build the Machine

Choosing Buffer solved one of the biggest architectural problems, but it didn't actually automate anything yet.

We still needed to build the application that would discover my blog posts, decide which ones should be promoted, schedule them and keep track of everything it had done.

That became the next stage of the project.

In Part 3, we'll start building the machine itself.

Comments