Skip to main content
What I'd Change About Anvil Connect for Non-Technical Users
ai-infrastructureproductidentityagentsplatform-engineering

What I'd Change About Anvil Connect for Non-Technical Users

Learn what I would redo in Anvil Connect, why identity across self-hosted AI apps stayed hard, and the push-button product it all points to.

Sekou M. Doumbouya

Sekou M. Doumbouya

· 9 min read

Listen to this article

The views expressed here are my own and do not represent those of any current or former employer.

Part 6 of a six-part series on Anvil Connect.

On November 18 I put into words the thing this whole series had been circling: “I’m building some really interesting, complicated tools that help me get my work done, but the actual product I’m building should not be for someone that has my skill set.”

Five posts about passkeys, gateways, sandboxes and per-user memory, and that sentence is where they all land. The person I built Connect for shouldn’t have to care how any of it works. Most of what I’d change below is a place where I built for my own skill set instead of theirs.

What works

Sign-in does its job. A browser signs in once with a passkey, the person sees a tile for each service they are granted, and the grants live per user.

Onboarding stopped being a project. Once email onboarding landed, adding a tester took one command. Authelia emails them a short-lived setup link, and they choose a password and add a passkey themselves. Deploys are repeatable, with rollback.

And the part that actually matters: it gets used. My friends now just jump in and ask whatever they want. I can tell them I have a new model, and they try it on their own use cases and tell me how it does. That is the feedback loop I wanted from the start. The origin story ends with someone getting in. This series was about what it took for getting in to be worth something.

Prove the real user’s path before calling it done

The pattern I would break first is a status line that read, in effect, backend checks pass, browser untested. I saw some version of that more than once. And more than once, the next thing that happened was me hitting a 500 or a 502 myself.

The backend checks were not lying. The parts worked. But the person I was building for does not call a health endpoint. They click a link, sign in, land on a tile, and expect the thing behind it to load. Every layer between that click and the app (the edge, the session, the identity handoff, the app’s own idea of who is logged in) is a place the path can break while every individual check stays green.

It’s not a testing gap. It’s a definition gap. My definition of done meant the parts worked. It should have meant a real person, signed in as a real member, reached the result. If I started over, the first check written for any new service would be the member’s path through a browser, end to end, and nothing would be called finished until that path had been walked.

Build the tester’s experience first

The second change is about order. On October 17 I spent an hour waiting on a tester who never arrived, with no way to see where they were in the setup.

Onboarding visibility came after that hour, not before it. That is backwards. The first steps after an invite are where people who don’t use these tools get stuck, and they were the steps I could see least.

If I did it again, tester accounts and onboarding visibility would come first, ahead of the next feature. An account I can sign in as to walk the member path myself. A view that tells me where each invited person is in the setup. The people you are building for are the scarcest resource in the whole system. Losing one in setup because you could not see them stuck there is expensive.

Every app has its own idea of who you are

Sign-in is a problem you solve once. The gateway checks the passkey session, and every published app accepts it. Isolation is a problem you solve once per app. Authelia, Open WebUI, Grafana, Hermes and Pi each have their own login, their own roles, and their own keys. I wrote none of them.

Getting someone signed in is not the same as landing them in their own space, unable to wander into mine.

That gap showed up across this series. Per-user isolation always lagged behind sign-in. Someone could reach an app before the app knew how to keep them in their own space: their own Hindsight storage, their own sandboxed environment, their own rate limit tied to their own token. Each got built, app by app, after sign-in already worked. In Pi, a member got a shared workspace with no separate permissions inside it. The first trial with my wife and my friends had the same shape.

The lesson I would carry into anything like this again: treat isolation as part of sign-in, not a follow-up to it. A service is not published until it knows who you are and has somewhere that is only yours.

Agents built most of it

I should be honest about who did the typing. As of November 18, most of the commits in Connect’s history were authored by Anvil Operator, not by me.

The agents ran under rules, the same way a good on-call rotation runs under a runbook. Codex took operations, with standing instructions: investigate before restarting anything, repair only the missing piece, and ship fixes through CI and review. New features did not start as code. They started as an Anvil requirements doc, and they waited for my go-ahead. When Claude Code ran the November 16 work, each change went up as its own draft pull request, reviewed read-only by a different model than the one that wrote it. You do not let the engineer who wrote the bug approve the fix, and that rule turns out to apply to models too.

October 27 shows why investigating comes before restarting. After an upgrade, the tunnels looked broken. They were not: idle timeouts, and all nine tunnels were up. A false alarm. But Codex found two real bugs on the way to that conclusion. A module was missing from the management tool’s package. And a watchdog was restarting Connect seconds before Connect’s own recovery would have finished, two well-meaning rescuers tripping over each other at the same bedside.

The agents were excellent at proving the parts. It took real Caddy and Authelia in a browser to prove the path.

What is still unsolved

Native apps sit outside the browser flow. The Hermex iPhone app could not finish Connect’s browser sign-in, so Tailscale still sits beside Connect for phone apps, as I covered in the Hermes post.

Isolation still lags sign-in. Every app that keeps its own login will bring its own users, roles and keys, and the work of mapping a Connect member onto that app’s idea of a person will still be done one app at a time.

And a non-technical installer does not exist yet. Docker plus an installer is the direction I leaned toward in that same post. It is a direction, not a thing I have shipped.

The product is the glue

So here is where it all points. Products going forward should shrink “that gap of the complex work” and give someone “that push button experience.” Someone who wants to build something without setting up all the infrastructure. In my words, “the product we provide is the glue between.”

Every hard part above was glue: proving the path from click to result, seeing a person stuck in setup, carrying identity across apps never meant to share it. The components were never the hard part. Caddy, Authelia, Open WebUI and the rest already exist. The hard part was the space between them, and that space is exactly what a non-technical person cannot be asked to build.

The challenge, in my words, was always “dealing with users that don’t use these different tools, that aren’t as tech savvy.” I worked on it for my wife and my friends first, with tools only I would want to operate. The person who comes next “probably doesn’t care about the actual individual components,” but likes the end result and wants a boost to get there.

Build for the person who wants the result

I will keep building complicated tools for my own work. That is how I learn, and the complexity is mine to carry. But the complexity is the cost of the product, not the product. Carry it yourself, and hide all of it from the person who just wants the result. Define done as their result, not your parts. Build the glue first, because the glue is the only piece they will ever touch.

0 claps

Enjoyed this? Tap to applaud, hold to really applaud.

Share this post
LinkedInXHacker NewsBluesky

Co-authored with AI, based on the author's working sessions, dictations, and notes.

Explore the source

fakoli/anvil-serving

This article discusses an open-source project. Star it, fork it, or open an issue.