When two clients are rivals, the lessons travel and the data stays
An FDE serving competitors needs the boundary written into code and contracts, because memory alone will eventually let something from one client reach the other.
In brief
- Working for two competitors is ethical as long as no information passes from one client to the other without permission.
- Vendor-owned patterns can travel. Data, client-specific prompts and models trained on a client's data stay behind.
- Enforce the boundary in the data layer and test it on every release, rather than relying on each person's care.
Take an FDE who spends a Monday at the offices of restaurant chain A, finishing a system that reconciles revenue between its point-of-sale terminals and the delivery apps.
Three weeks later, sales announces a new client: chain B, A’s direct competitor, and it wants exactly the same thing. There is a good chance the first question B asks at kickoff will be: “How is A doing it?”
The right answer is that you don’t say. But saying nothing does not mean starting from zero. If every project had to be rebuilt from scratch, an FDE would be nothing more than an expensive consultant. Carry over the wrong thing, though, and the company could lose both clients at once.
The skill is separating the lesson from the data, and that separation has to be done in code and contracts as well as in your head.
The ethical line is actually narrow
David Mortman, a security consultant, sets out the basic rule for working with two competing companies: never disclose anything about one client to another without permission. In his view, taking work from both rivals is acceptable, provided no information crosses from one side to the other.
The rule is simple, but it is harder for an FDE to keep than for a consultant. Palantir describes the product engineer as “one capability, many customers” and the FDE as “one customer, many capabilities”.
You work deeply with a single client and read their real data, which, according to The Pragmatic Engineer, is often sensitive and proprietary and sometimes sits in an air-gapped environment.
At the same time, an FDE’s value lies in feeding what was learned at one client back into the product. At OpenAI, a voice model improvement built for one customer later benefited the Realtime API and every other customer. The problem, then, is how to let the lessons move while the secrets stay put.
Who owns what: read the contract before the code
The first step is to read the contract, before opening an editor. Martin at Databricks says that for work to be reusable and flow back into the product, the vendor has to own the IP. The same piece also makes clear that a custom model trained on a client’s data belongs to the client.
That gives three groups. Shared code and patterns owned by the vendor can travel. Data, business configuration and prompts containing A’s specific details belong to A. A model fine-tuned on A’s transactions also belongs to A, even if you wrote the training pipeline.
Irudayaraj at Alteryx describes precisely this case of reconciliation for a restaurant chain: build it once and never build it again for later clients. What gets reused there is the pattern, and none of the client’s data.
Separate by structure, not by memory
Even with the best intentions, a RAG agent can leak information. All it takes is pulling a passage of A’s context while answering B’s question. Wolfia describes the defensive pattern: every AI request must be scoped to a single customer, both the prompt and the retrieved context.
The tenant filter is built into the data access layer, so every query has to pass through it instead of depending on a developer remembering to add it. Every release also runs tests that check isolation between tenants.
Applied to the reconciliation project, the code might look like this:
class TenantScopedRetriever:
"""Every retrieval is locked to one tenant; there is no way around it."""
def __init__(self, store, tenant_id: str):
if not tenant_id:
raise ValueError("tenant_id is required")
self._store = store
self._tenant = tenant_id
def search(self, query: str, k: int = 5):
# The filter is applied here, not left for the caller to remember
return self._store.search(query, k=k, filter={"tenant_id": self._tenant})
def test_no_cross_tenant_leak(store):
store.add("September revenue discrepancy rate", tenant_id="chain_a")
b = TenantScopedRetriever(store, "chain_b")
assert all(d.tenant_id == "chain_b" for d in b.search("revenue discrepancy"))
The crucial point is that the agent never holds the raw store; it only receives a retriever already locked to a tenant. Put that test into CI so that a hurried refactor cannot quietly strip the filter out.
Write lesson cards the old client would not recognize
The code layer solves only half the problem. The other half lives in your head and in the notes you leave for the team. Before leaving project A, write lesson cards, then reread every line and ask: if A’s CTO read this, would they recognize their own company?
| Raw notes after project A | Lesson card that can travel |
|---|---|
| A’s September payout file didn’t match the POS because the delivery app closed its books late | Payout files from delivery platforms often close their books late, so reconcile by order ID with an amount tolerance, not by date |
| A’s accountants only trust the report exported at 6 a.m. | Ask early who signs off the numbers and which source they trust |
| The few-shot prompt uses 20 real transactions from A | Prompt structure; examples must be rewritten from synthetic data |
The left column contains dates, internal habits and real data, so it must not leave project A. The right column is a set of patterns any industry runs into. Only that column goes into the shared wiki, into templates, or into tickets for the product team.
Starting with client B
When B asks “how is A doing it?”, have an answer ready: “I don’t share anything about other clients, just as I won’t share anything of yours with anyone. What I bring is an approach that has been proven.” That sentence is, in fact, a reason for B to trust you.
If you want to reuse something in a grey area, such as a case study, ask A for permission in writing, exactly as Mortman’s rule requires.
The generalized part should go back into the product, so that it becomes “one capability, many customers”, as Palantir describes the product engineer’s job.
At that point you no longer carry the lesson around with you, because it has become a feature.
One more step is often skipped: checking the training policy of every third-party tool in the stack. HubSpot’s documentation says some models are trained on data from multiple customer accounts, and that opting out only takes effect from that point onward.
With such tools, opting out cannot remove data already used for training. Settle the question on day one, before any real record is loaded.
Four common mistakes
The most common mistake is treating the boundary as a matter of personal discipline. If every query needs tenant_id added by hand, sooner or later one will miss it. If the architecture allows a leak, one day it will leak.
The second is using anecdotes to sell, along the lines of “a big chain in the industry is doing it this way”. In a market with only a handful of competitors, a detail like that is enough for the listener to guess who it is.
The third is carrying A’s fine-tuned model or few-shot set over to B, when, according to Insight Partners, a model trained on A’s data belongs to A. The fourth is believing that opting out erases the past.
Turning this skill into a hiring advantage
When describing past projects, show that you generalized a solution without exposing the client.
On a CV, a line such as “built a tenant-isolated data access layer for a RAG agent, with cross-tenant tests in CI; packaged the reconciliation pattern into a module used across clients” is far more concrete and verifiable than “security-minded”.
When reading job descriptions, look for phrases such as multi-tenant, data isolation or “feed learnings back to product”. They are likely signs that the company needs exactly this skill. In interviews, if asked about previous projects, tell the story in the language of your lesson cards. The way you tell it proves on its own that you know how to hold the line.
Client B will never learn what A taught you. The only thing from A allowed to reach B is the method, and B sees it only in the fact that its project did not have to be worked out from scratch.
Was this article useful?
Thanks for the feedback!
5 sources
- The Pragmatic Engineer: Forward Deployed Engineers · 2025-08-12
- What are the ethical issues when consulting for two competing companies? · 2009-02-03
- Demystifying the forward deployed engineer (Insight Partners) · 2026-07-14
- What measures prevent AI from leaking data between customers (Wolfia) · 2026-07-06
- HubSpot machine learning data · 2026-09-08