Flank Memos

Flank Memos

Kitchen Drawers, Clayton Christensen, and Beta-Testing Your Internal Tools

Subscribe to my newsletter and never miss my upcoming articles

Written For: Engineering Managers

I used to be pretty smug about internal tools. I was an early adopter of Retool, so, you know, I was a connoisseur of sorts.

Then, to my surprise -- and joy, but also disappointment when I realized how dumb I was (ugh, again??) -- I discovered people who were building internal tools at a totally different level.

Storytime

Obie in Ops needs an internal tool.

Enrico the Engineer writes the business logic to solve the problem. He deploys his code, but now he has a problem: how does Obie access the program?

(Note: I'm using "Ops", but Obie could be any other breed of non-engineer -- Analyst, CSM, PM, whatever)

(Second note: When I say that Enrico writes "business logic", I'm talking about a runnable program. Anything ranging from a serverless function to an API endpoint to a script in a container.)

Enrico's Choice

If you had asked me a year ago, I would have said that Enrico has three choices.

  • Do nothing
  • Build an interface
  • Stash it in an existing interface

Since then, I've talked to a lot of companies about how they build internal tools. Some are worse, some are better. As you'd expect, a lot of the variation is explained by whether or not the company has their shit together.

So, as someone who thought they had their shit reasonably well together, I was surprised to discover outliers -- companies that are way better at building internal tools. They have an entirely different way of thinking about internal tools. One that identifies the problems with the status quo and (keep reading) presents a better alternative.

OptionDoesn't Scale Because...
Do nothing. When Obie needs it run, Enrico will manually run the taskIf the company grows, Enrico will find himself underwater with requests
Build an interfaceObie will be overserved/underserved
(I'll explain below)
Stash it in an existing interfaceCreates tech debt in the "kitchen drawer"
(I'll explain below)

Overserved/Underserved Interfaces

Look at the situation from Obie's point of view. Most of the time, he wants a tool as quickly as possible. He doesn't want the interface to be a total dumpster fire, but it doesn't need to be a piece of art either. The exception is that one tool that Obie uses all the time. That tool actually deserve a nice interface.

At most companies, Obie does not get what Obie wants. To borrow Clayton Christensen's terminology, he's either underserved or overserved.

Overserved: The company builds a beautiful internal app for every single tool. Great, but Obie doesn't care if the interface is a 6/10 or a 10/10. He just wants access to the tool as quickly as possible.

Underserved: The company stuffs new tools wherever without a second thought. They never upgrade anything and the user interfaces are a disaster. Obie's workday is a slog through confusing interfaces.

Learning From the Best

They're rare, but I've talked to companies that have two interfaces for internal tools. I'll call them the Minor League interface and the Big League interface. The Minors interface is quick and dirty. Engineers use it to put internal tools in front of Ops as quickly as possible. (At one company, this interface was a Slackbot.) The Bigs interface is a custom-built website. It is reserved for the most important tools.

Back to our boy Enrico. After he deploys the code, he delivers the new tool to Obie using the Minor League interface. Obie uses it for two weeks. The interface isn't great, but he and Enrico are still working out the kinks, so it's not a big deal. After a month, it's obvious that this tool is important. This tool gets promoted to the Bigs, and Enrico polishes it.

minors-to-majors.png

Under this system, Enrico don't waste time on stupid tools. Obie is no longer over/underserved. Obie is properly served.

Tech Debt in the Kitchen Drawer

Long Tail Segment.png

Next question: How does Enrico organize the long tail of Minor League tools? Keep the answer in mind. Now ponder another one: How do you organize the long tail of tools in your house?

For most companies, the answers to the two questions are the same:

kitchen-drawer.jpeg

That drawer didn't start out as a mess. It started out as 1 pen and 1 chapstick that didn't belong anywhere else in the kitchen. Then the next random thing went in there, and then the next one...

Software is no different:

Enrico: "In a perfect world this would be deployed as a serverless function, but you know, we have that internal site wired up to that API, so screw it, I'm just gonna stash this script in a new endpoint and call it /internal/random/run-report-generator. We'll figure out a better solution later."

Then, that happens 100 times, and boom! You have your kitchen drawer.

Kitchen drawers create technical debt. In the example above, the script belonged in a serverless function. Enrico shoehorned the code into an API endpoint. Why? Because the backend isn't really decoupled from the front end. There is enough setup, configuration, and glue code to make the API the path of least resistance.

Flank Is a Beta Testing Platform

What is the perfect setup?

  1. Two interfaces: Minors and Bigs
  2. Measure usage. Only promote the most important tools.
  3. Keep the Minor League "drawer" organized by decoupling the interface from infrastructure
  4. Easy-to-use interface for our poor friend Obie

Hopefully you see where this is going. We're building an out-of-the-box Minor League interface. Flank (that's the name of it) gives Obie a "Run" button for programs in the cloud. It saves Enrico the hassle of building an interface.

(Hey Angus, uhhh, this is your subconscious, listen, maybe you shouldn't use an analogy that compares the product to the Minor fucking leagues? Emphasis on word "Minor". Just a thought. Okay, point taken, but I'm just being honest, and the fact is that engineers don't want to waste time on the Minors. They have more important things to do! Also, if it makes you feel any better, Flank has an awesome interface, so it's better than the Minors!)

flank-to-bigs.png

Flank also solves the kitchen drawer problem. It abstracts over infrastructure, turning all code-running services into "tasks". Serverless Function? Container? All equals in the eyes of Flank. That decoupling (plus a well-designed interface) keeps the kitchen drawer organized.

Drawer Improvement.png

Put it all together, and what you have is a beta-testing platform for internal tools. Enrico deploys, and Flank immediately delivers the program to Obie. Flank measures usage. Usage informs Enrico's priorities. It's a better way of building software. One with tighter feedback loops:

Feedback Loop.png

Feel free to shoot me an email at angus@flank.cloud, or, if you want to chat, hop on my calendar!

I owe the kitchen drawer analogy (and a very clear articulation of the value prop) to the one and only Tim Getsch

 
Share this