When building new systems, some kind of administrative interface is almost always necessary. They’re funny beasts in the software making process, ranging from almost forgotten in the excitement of building the customer-facing experience, or over-designed to the point of being an entire toolbox when all you need is a screwdriver.
Admin interfaces can be challenging: the people using them have a very different perspective from their customers. If you think about the back of house in a restaurant with cooks and kitchen equipment and how different that is from the dining experience, you have a sense of the gap between the customer and the admin perspective in software. It’s a real need, but can quickly turn into project quicksand.
At the heart of the problem is that we never really understand what problems will happen until the product is launched and live and in your customer’s hands. In other words you can build defences in all the wrong places, spending budget and adding code complexity that delivers little value.
We’ve developed two principles to keep ourselves and clients from getting lost in unnecessary administrative design and coding, which we’ve come to call the Admin Lite approach.
1. Start with None
We start by assuming that there will be no admin interface, even when we know there will be. We see what problems we can solve without building specific interfaces, either through good interaction design or clever coding for background handling.
Eventually we find a case that requires administrative intervention and tackle that problem, but we keep our effort minimal because of the second principle.
2. Solve Only Existing Problems
This principle requires courage from the client and agility from us: we see what problems come out of actual use, and then make something to solve them. Optimism and pessimism, the twin trouble-makers of admin interface design, can’t mislead us at that point because we can see the problem as it is rather than as it might be.
Of course, there are some good administrative practices that are tried and true in years of software design. We recognize those and accommodate with the first principle, but through the second we ensure a clear connection between what is needed and what is built. The result is higher value to clients and their customers, less code complexity and leaner interfaces that get the job done.