Many enterprise IT departments have become big fans of an “API-first“ strategy. I think that in general, this is a bad idea. (Thread)

Apr 15, 2020 · 9:28 AM UTC

37
251
46
592
When you start with APIs, you really have to have a very good grasp of what that API’s users will need. You typically don’t. Instead, you try to come up with things that will “obviously” be re-usable, and end up with things that are not even useful.
4
12
2
103
Most often, APIs are shaped, and almost always restricted, by the capabilities of underlying systems they encapsulate. That’s great if these are great. They typically aren’t.
2
3
44
An API-first strategy assumes that great applications can be built by “just” “orchestrating” the capabilities exposed through APIs. That’s true for some applications, but not for many, and typically not for great ones.
1
3
34
Unless APIs are the actual product you provide to your outside customers, the horizontal divide created by putting an API boundary between your end users and the business logic (and the resulting Conway’s law effects) will create lots of pain and little value.
1
9
1
54
In many cases, an API-centric strategy is a sign of the strategists not wanting to have to deal with actual end users and their needs. It’s much easier to create re-usable services that someone else has to assemble, and even easier to create a meta-strategy for that.
4
17
1
69
(On the plus side, an API-first strategy works great if you have an API gateway product to sell, or want to legitimize legacy systems that are slowing you down by putting a “bi-modal” or “two-speed IT” sticker on them)
1
1
27
I blame most of the disasters in modern enterprise IT strategy on the fact that it’s people like me – backend architects with way too little focus on UI/UX aspects – who have been put at the controls for far too long.
3
16
7
99
You need a strategy for modular application delivery, not only including, but starting from, end-user needs. APIs are a meaningful means to an end for that. Starting with them is going to end badly, independently from your choice of protocol or data format.
13
27
2
81
Replying to @stilkov
Do you feel this happens when companies recommend teams/services interact primarily through APIs? Put another way, have you seen API-first show up primarily as a result of that kind of recommendation?
1
No. Teams interacting via APIs seems like a completely reasonable approach to me.
1
4
Replying to @stilkov
2/2 Not everything is an API. But thing you access often or capabilities that crop up multiple times as you triage your project backlog definitely should be APIs. But you can’t just adopt APIs without changing the mindset of the producers and consumers (the humans writing code)
1
Replying to @stilkov
I haven't found a better way to do things than to start at both ends and then marry them up in the middle. The best way to represent something on the back-end is often arduous for the client-side to deal with. And client-driven db schemas are usually horrendous.
2
4
Replying to @stilkov @dtanzer
I agree that "APIs first" without having the whole picture is the solution for nothing and may create problems. But in many bigger IT organizations APIs enable self-service like interactions between teams and thus reduce dependencies.
1
Interesting thread. I approach this as a technical writer, but I see developers in my group who are gravitating away from UX and toward back-end development. What with corporate UX teams and style guides, they see front ends as mere "skins" and look down on front-end developers.
I definitely see what you're talking about: the UI is simply a display of the output of specific APIs. There's almost a one-to-one equivalence.
Replying to @stilkov
First you have to understand the big picture. After that you can think about UI/UX of the MVP. The API is one part of the way to the product.
Replying to @stilkov
Dead on the money! Defining the user interaction should always be first, particularly with new products. Older products are more difficult, but you should still focus on what you need for the user first, and design the APIs around that. Good thread!
1
5
Replying to @stilkov @ewolff
IT failing to build something that meets a need/desired outcome isn't new. The tools, technologies, and architectures change, but the problems remain depressingly the same.
1