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.
- “This looks great”
- “I like it overall, but that thing could be different”
- “The editor sucks”
- “I wish I could use markdown”
- “There is a bug, how is it possible I’m the only one that ran into this?”
- “Hey support I run into this problem” - “we’ve raised it to the engineering team, we’ll keep you posted”
- “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.