The Developer’s Dilemma

Deciding between using an existing service or platform, and building your own

There is a big issue I am running into, right now.

I’m trying various platforms to see if they are a good fit to be the place where I can host my courses in the future.

The platform I use now is based upon a static site that interfaces using custom integrations and no-code tools (like Airtable). Payments and course signups are managed using Node.js services. You can call it JAMstack, serverless, or any fancy term that is hip today.

Actually, I have several SAAS platforms, all similar, for each of my courses. I like to keep things simple and as straightforward as they can be. When I first started, I made a website for a course.

Then when it was time to make another course, I just copied that website, and made another “version” of it.

Now the number of courses jumped to 7, and time has come to revisit the overall infrastructure I use.

My first thought was to use a platform I could use, that could serve as a centralized hub for course material, and provide functionality that I didn’t have to build myself.

So I went out and tried a few of the popular services, including Teachable, Podia, and many others.

But I ran into what I call The Developer’s Dilemma.

At first sight those platforms are amazing. Well designed, their interface is slick, their marketing shines and it really looks great.

Then I started using them.

And I started climbing up the scale of frustration.

1. “This looks great”
2. “I like it overall, but that thing could be different”
3. “The editor sucks”
4. “I wish I could use markdown”
5. “There is a bug, how is it possible I’m the only one that ran into this?”
6. “Hey support I run into this problem” - “we’ve raised it to the engineering team, we’ll keep you posted”
7. “OMG I lost a lot of time on this already”

I am a lazy developer. I consider this the best of my technical abilities.

Over-engineering software, when you’re a lazy developer, is not an issue. It never happens. I just write the minimal amount of code necessary to perform a task.

I resist complexity.

Why is this great? You can’t anticipate the needs of tomorrow, the problems of tomorrow. And I learned this over time.

As a contractor, I worked on codebases so complex that I wanted to cry and whenever I can, I prefer over-simplistic on over-complex.

Being a lazy developer also makes me think a lot before writing software.

Because writing software is a responsibility.

You are writing the weight you’re going to take with you in the future.

Suppose, continuing what I wrote above about choosing a courses platform, that I decide to write my own course platform.

This means that I have to code it, first.

I need to make decisions. Decisions that might turn out right, decisions that might be wrong.

And after I build the software I dream about, I need to maintain the code in the future. I am responsible for it. There is no “ask support” button any more.

As a developer, we have this incredible ability of creating the tools we need. At the expense, however, of responsibility.

But it’s also an ownership dilemma. Do I want to rely on this specific platform for the next 5-10 years? What if the decisions they take do not align with mine? What if they raise their prices? Will I be able to move away from it easily?

In the ideal scenario, I’ll always choose my own platform over a platform managed by other people. But I’ll always choose the easiest route, too.

The biggest and most precious resource to me is time. I could have so much more time by picking an existing solution.

Should I spend one month writing my own courses platform?

That’s the current instance of The Developer’s Dilemma I am facing.

I tried all the possible pre-made solutions for it.

They all failed to live up to their promise (or to the image I had of them in my mind) in one way or another.

I decided I am going to write my own solution. The simplest solution, of course.