Taming P99s in OpenFGA: How we built a self-tuning strategy planner
In this technical retrospective (2026), @elbuo shares practical architectural lessons learned from running, scaling, or migrating production software under lean constraints.
Core Principles for Independent Builders:
Defaulting to simpler architectures (such as monolithic frameworks, SQLite, or managed VPS) prevents early engineering bankruptcy.
Evaluating true compute and egress costs reveals that high cloud bills can often be slashed by 80%+ through judicious re-platforming.
Code you write at 2 AM as a solo engineer must be easy to debug six months later without complex microservice dependencies.
Community Debate Themes:
HN engineers debated the tradeoffs between cloud convenience and raw server economics, database indexing strategies, and resisting premature architectural complexity.
CATEGORY Frugal Engineering →
HISTORICAL ERA Post-ZIRP & AI (2023–2026)
COMMUNITY SCORE 4 points
TOTAL DISCUSSIONS 1 comments
I really respect OpenFGA & team behind it, I used it in multiple projects and it completely eliminate the AuthZ from our code.
But it always had this issue with Admin management, It is hard for Admins to understand and maintain.
That’s why I created an Admin UI for OpenFGA, The main goal is that the UI is Dynamic and it changes as per your OpenFGA Model, Then you can Easily Add users
I built this because my team was constantly struggling with managing permissions in our applications. we tried building admin UIs multiple times, but every time the OpenFGA model changed, we had to rework the UI layer to match it one way or another.
So mainly the UI understand your OpenFGA schema and automatically renders the management interface based on the entities and relationships defined in your model.
https://github.com/yehia2amer/OpenFGA-Admin-UI ↗
Fun to see a write up applying multi-armed bandits.
I had a bit of trouble following the article as I don't understand the problem space well enough. When framing this problem, the authors wrote:
``` Answering "Can user X access resource Y?" requires traversing relationship graphs. In this context, traversal performance isn't just a feature; it is the fundamental constraint of the system's architecture.
``` Concretely, in an OpenFGA / Auth0 FGA deployment where graph traversal becomes enough of a bottleneck that introducing a planner like this becomes compelling, how is the graph and the traversal manifested? What's actually going on?
Would the relationship graph be represented as a bunch of relations stored in a single SQL DB? Or does querying and traversing the graph require making a bunch of API calls to various downstream services over the customer's network?
I don’t understand why Thompson sampling would be used for an experiment that can be rapidly repeated. Isn’t reconfiguring the FPGA orders of magnitude slower than measuring latency? It seems like you could produce a high confidence posterior by resampling so fast that there is no point in prioritizing what needs to be revisited (especially with good priors).