What luxury hospitality taught me about software

Before I shipped a line of production code, I had spent six years inside the highest-end resort operations on the Egyptian North Coast. I started at eighteen, as a temporary waiter. Within two months I was leading shifts. By the second season I was the only temporary employee in the resort’s history ever trusted with full restaurant operations. I was twenty when I first ran a service of seventy guests by myself, on a sunset Saturday, with a brigade of eight under me.

What I learned in those six years is the foundation of everything I have built as an engineer since. I want to write what the connection is, because most people would not expect a hospitality background to be relevant to software.

The most important concept I took from hospitality is the sequence of service. In a fine-dining restaurant, the sequence is the choreographed order in which everything happens at a table. The greeting. The water pour. The menu. The order. The wine pairing. The bread. The amuse-bouche. The first course. The course change. The second course. The pause. The dessert. The petit fours. The bill, presented closed. None of this is improvised. The order matters. The pacing matters. The discipline is that nothing arrives before the guest is ready for it, and nothing is forgotten because the previous step was missed.

This sounds like the work of a server. It is also the work of a backend system. The order in which data is loaded onto a screen. The state transitions a user moves through during a checkout. The choreography of a multi-step form. The pacing of when a notification is allowed to interrupt. The discipline that nothing is shown before the user is ready for it, and nothing is forgotten because the previous step was missed.

When I look at a feature in a product I am building, I see the sequence of service. I see the moments where the system should pause. I see the places where the user is overwhelmed because too many things arrived at once. I see the places where the user is stuck because the previous step did not complete cleanly. The vocabulary I learned in a dining room transfers directly to product engineering, and I have not found a better vocabulary anywhere else.

The second thing hospitality taught me is the discipline of making the effort invisible. A guest at a great restaurant does not see the kitchen. They do not see the prep cooks who started at five in the morning. They do not see the wine director who tasted forty bottles to choose the four that made the list. They do not see the manager checking the temperature of the dining room before service. The guest sees the meal, and the meal feels effortless, and that feeling is the entire point.

The same discipline lives in great software. A user opening a well-designed product does not see the database query that was optimized over three days to load in two hundred milliseconds. They do not see the caching strategy that prevented the third-party API from melting under load. They do not see the error handler that caught the malformed response and presented a coherent message instead of a stack trace. The user sees the product, and the product feels easy, and that feeling is the entire point.

The third thing hospitality taught me is presence. A great server is not on their phone. A great server is not thinking about the next table. A great server is in the moment, watching the guests at their table, reading their body language, noticing the half-empty water glass three seconds before the guest reaches for it. Presence is a discipline. It is also a quality you can feel when it is missing. A server who is going through the motions is delivering a worse meal than one who is fully there, even if every plate arrives on time.

The same is true of engineering work. The engineer who is in the moment, reading the codebase carefully, noticing the pattern, asking the question that should be asked, ships different work from the engineer going through the motions. The two engineers may produce the same number of pull requests in a given week. Their work is not the same. Presence is not a measurable output. It shows up in the quality of what gets shipped.

The fourth thing hospitality taught me is recovery. Things go wrong in restaurants. A dish comes out wrong. A guest arrives ninety minutes late and the kitchen is closed. A bottle of wine is corked. The discipline is not in preventing every mistake. The discipline is in how the mistake is handled. The guest does not remember the mistake. The guest remembers what you did after.

Engineering systems break. Code has bugs. Deployments fail. Integrations regress. The discipline is not in preventing every failure. The discipline is in how the failure is handled. The user does not remember every bug. The user remembers what you did after.

I will sometimes write about software using vocabulary from hospitality. Sequence of service. Pacing. Recovery. Presence. The vocabulary fits. The two crafts are closer than they look, and the lessons travel.