Three pieces of work that show how I decide, not just what I built. The full narratives follow, along with seven more.
Full case studies
Vendor Integration · Salesforce Architecture · Knowledge Transfer
Building an integration for a system I never had a login to
Situation
A third party vendor needed a Salesforce integration built for their platform. Their lead engineer was sharp and thorough, but new to Salesforce entirely, and I never had a login, an admin panel view, or any direct visibility into their system across the several months we worked together.
Approach
Most of the early work was knowledge transfer: what a permission set is and how it differs from a profile, why "the object is accessible" and "the field has a value" are two separate promises, why a system user needs API access enabled at the profile level before anything else works.
But the harder half of the work wasn't admin configuration. It was schema design: how an application record relates to its reviewers, its grades, and its comments, and which identifier survives if an email address changes but a record cannot. It was an API architecture decision hiding inside a volume question: records moved through synchronous calls capped at two hundred each, or through an asynchronous bulk job built for larger loads. And it was a packaging decision most admins never touch: which org owns a Salesforce package once it's created, and what breaks for every future client if that ownership is wrong from the start.
The permission set itself was scoped tight on purpose: full access on the objects that belonged to the vendor, since they were the source of truth for that data, and read only access on a short list of named fields everywhere else. Two versions of the same permission set were built, one for clients licensing the connector as a full platform user, one for the cheaper API only integration license, since those two license types quietly support different permissions.
Working without visibility
I never tried to reconstruct their platform in my head. When the engineer described how a record connected to another, I took the description at face value and reasoned from what Salesforce needed to receive, not from a guess about what their database looked like. My side of the integration, I verified myself, directly. Their side, I trusted them to be the expert on, because they were.
Outcome
A production integration that installs the same scoped, tested package for every future client the vendor signs, and a vendor engineer who went from no Salesforce experience to shipping schema changes independently. He thanked me for being direct about timelines instead of vague. I'd take that over almost any other compliment the project produced.
Production Migration · Identity & Access · Risk Management
Rebuilding an authentication layer that three other fixes hadn't held
Situation
Several membership organizations needed on the order of a hundred thousand legacy member records remapped from an old system's IDs to new Salesforce IDs, against a billing run that does not move because the work isn't finished. On one of them, authentication kept drifting. More than one attempt to patch the configuration had already failed to hold.
Approach
Instead of patching the same configuration a fourth time, I rebuilt that organization's Salesforce-side authentication from scratch: a new External Client App, fresh credentials, nothing inherited from whatever state it had drifted into. Because this was the first time a mass production sync had run at this volume, I flagged the risk of skipping staging validation to save time and argued for keeping it, even with the deadline pressing. Partway through, a platform constraint surfaced that nobody had hit before: the billing system would only accept one relationship or role per member per batch. I filed it as a permanent fix rather than letting it become a one-off workaround someone would have to remember next time.
Outcome
The migration held, and every organization behind it in the queue moved forward on my sign-off rather than ahead of it. The work got unsolicited recognition from leadership above my own manager, which does not happen for a quiet fix. The batch constraint I filed outlived the project: every mass sync at that volume since has run into the same limit, so the fix is permanent instead of tribal knowledge.
Partner Development · Vendor Relationships · Cross-Functional Rollout
Bringing in a partner, not just building for one
Situation
Most of the integrations I own started as relationships I inherited: an existing vendor, an existing agreement, my job to make the technical side hold up. This one I helped build from the ground up. A fintech partner had a product that filled a real gap for our client base, and the question was whether to bring it in as a company-level partnership rather than a one-off connector for a single client.
Approach
The technical integration turned out to be maybe a third of the work. The rest was evaluating whether the partnership actually made sense: what the product did that we could not, what it would cost our clients against what it would save them, and what the revenue-share terms needed to look like for both sides to still want the relationship past the first renewal. Once the deal was struck, I wrote and circulated the internal rollout plan myself, because a partnership that lives only in a signed agreement and nobody's calendar is not actually live yet. I have since written vendor-vetting criteria for another organization's partner program too, since the questions that matter (how they handle authentication, what happens when their side fails, who owns the data in a dispute) are the same questions regardless of whose logo is on the letterhead.
Outcome
The partnership became a standing option across our client base rather than a single deal, and I still maintain more than two dozen partner and integrator relationships built the same way. The measure I actually care about: a vendor whose product had a real bug once fixed it because we found it and told them plainly, not because we made it their problem in public. That is what a relationship built to last past the first renewal looks like from the other side of the table.
Archives · Information Architecture · Records Consolidation
Turning more than forty boxes into something a stranger could search
Situation
As an archives intern at the Indiana Historical Society, I processed the records of a community organization I had also worked for: more than a hundred years of material, from 1900 to 2013. It arrived as more than forty boxes of documents, photographs, albums, slides, negatives, and videotapes, with no structure anyone outside the organization could follow.
Approach
The work was arrangement, description, and preservation: sort the material into series, consolidate it, rehouse what needed protecting, and then write the collection guide that tells a researcher what is in the boxes, how it is organized, and where to find the one thing they came for.
The hardest part was identity. The organization went by four different names between 1910 and 1980, and later merged into another. A researcher searching under any one of those names still needed to land on all of it, so the guide had to carry the full history of who the organization had been, not just what it was called when the boxes arrived.
Once or twice a week I also staffed the reading room, pulling material for researchers, members, museum visitors, and people tracing the history of their own town, and showing them how to handle it without damaging it. Watching strangers use guides like mine was the clearest possible feedback on whether a description actually worked.
Outcome
More than forty boxes consolidated to fewer than thirty, described in two published collection guides that are still the public entry point to the collection: the main collection guide and its addition, both completed in spring 2015. It is the same problem I solve in Salesforce today: many records, several names for the same entity, and a user eight months from now who needs to find the right one without knowing who built any of it.
Identity & Access · Vendor & Client Communication · OAuth Migration
Rebuilding the affected-integrations list from scratch instead of trusting the record
Situation
A federated single sign-on system we integrate dozens of client organizations through is deprecating its legacy authentication flow in favor of a more secure standard, moving from an implicit grant to authorization code with PKCE. No reliable, current list existed of exactly which client organizations and integrations the change would touch.
Approach
Rather than trust whatever list already existed, I rebuilt the full inventory of affected client organizations and their individual integrations from scratch, cross-checking it against our own CRM as I went. I drafted both the vendor-facing and the client-facing messaging for the change separately, so each audience got what actually applied to them instead of one message trying to do both jobs.
Outcome
Rebuilding the list instead of trusting it surfaced data mismatches between the CRM and the existing record of integrations, catching them before the migration got underway rather than during it, when they would have shown up as failed logins with no obvious cause.
Root-Cause Diagnosis · Integration Architecture · Data Integrity
A sync gap that looked like one chapter's problem until the mechanism said otherwise
Situation
An alumnae-chapter sync gap surfaced for one organization, and the fix on the table would have treated it as a one-off bug specific to that organization.
Approach
I traced the mechanism from one member's case up through the pipeline logic instead of patching the symptom. The reconciliation job only re-announces a record when its own source-side copy has changed; if the edit happens on the receiving platform instead, the job has no way to notice the drift and self-correct, so the two sides can stay silently out of sync indefinitely.
Outcome
Establishing that the gap was structural, not organization-specific, meant filing the defect against the integration itself rather than proposing a workaround scoped to the one client that happened to surface it first.
Root-Cause Diagnosis · Data Integrity · Membership Platforms
Ruling out the obvious cause before it burned a week chasing the wrong fix
Situation
A member sync's duplicate-detection logic was quietly rejecting valid relationship records for one specific membership type, a lifetime status rather than a renewing one.
Approach
My first hypothesis was that the sync used an insert instead of an upsert. Building out real test data disproved that within an hour, which redirected the investigation before it burned days chasing the wrong fix. The actual cause turned out to be in how the platform's deduplication key gets constructed for that membership type.
Outcome
The defect had only surfaced for one organization so far, but was structurally certain to hit every other organization using that same membership type as the platform scaled. I built the diagnostic queries, documented the mechanism, and staffed the fix to engineering instead of patching around it organization by organization.
Data Quality · Investigation · Risk Management
32 flagged accounts, and the fix that would not have worked
Situation
An organization asked for a review of a set of chapter accounts it suspected were duplicated. The fix already on the table was to clear an ID field on the extras.
Approach
I went through all 32 flagged accounts individually: confirmed 20 genuine duplicate pairs, separated out 2 tangled special cases, and turned up 15 more unrelated duplicates nobody had flagged.
Outcome
The more useful part was explaining why the proposed fix would not have worked. The sync between the two platforms matches records on both an external ID and an email address, so clearing one key leaves the other still linking the records. We agreed to hold off on any changes until the actual goal of the cleanup was settled, since the right fix depends on what you are actually trying to solve.
Root-Cause Diagnosis · Sync Architecture · Data Integrity
Fifty records a timestamp-based sync was never going to see
Situation
A sync had been quietly skipping about fifty member records, and it looked at first like a configuration problem.
Approach
Those records qualified for sync through a background recalculation, and the platform does not stamp that kind of change as a real edit, so an incremental sync keyed on modification time never saw them. I forced the timestamp to bring the backlog through, then wrote up the pattern so the same symptom could be recognized elsewhere instead of re-diagnosed one group at a time.
Outcome
The fix itself took an afternoon. Naming the class of bug was the part worth keeping.
Vendor Diagnosis · Identity & Access · Client Communication
The lockout that will come back unless the fix changes the right thing
Situation
Members of one organization were getting locked out of a third-party platform, and the vendor's matching logic was the reason: it identified people by email address rather than by their permanent member ID.
Approach
That holds up until someone has more than one login or changes their email, which in a membership organization is not an edge case. I wrote the explanation in language the client-facing team could send along without translating it first, and split the next steps explicitly between us, the client, and the vendor so nothing stalled in the gap between three parties.
Outcome
The open question I am still holding the vendor to: whether their fix actually switches to the permanent ID, or just refreshes the stored emails and recreates the same problem a year from now.