Solutions Architecture + Enterprise Integrations

Stephanie Dlatt

Making complex technology work together.

I work across Salesforce architecture, secure integrations and technical partnerships to connect systems, people and business goals. My focus is on practical designs, clear ownership and reliable outcomes when the technology is complex and the stakes are real.

Solutions & Integration Leader  ·  Greater Chicago Area  ·  Remote collaboration

Two dozen+
Vendor and integration relationships maintained, several brought in from scratch
~100K
Legacy member records within major migration efforts
3
CRM client success managers previously led as Support Operations Team Lead

About

Behind every record is a person having an actual day.

I build Salesforce architecture: integrations, single sign on, data migrations, and the security and permission design that decides whether a connector is trustworthy or a liability. My days are spent getting systems that were never designed to talk to each other to do it anyway, without either side throwing a fit. My title at re:Members is Implementation Specialist.

A meaningful share of that work happens before any of it is technical. Evaluating whether a new vendor is actually worth bringing in, negotiating terms that make a partnership worth keeping past the first renewal, and staying the person both sides call when something between two companies needs resolving, not just two systems. I currently maintain more than two dozen partner and integrator relationships built the same way, several of which I helped bring in from scratch rather than inheriting.

The clients I work with today happen to be membership organizations, fraternities, sororities, foundations, associations, but the actual problem is the same one any company with more than one system runs into: getting disconnected systems to agree on who a person is and what they are allowed to touch. That problem does not care what industry it shows up in.

I came into this sideways. History and anthropology as my disciplines, a stint in an archive, years in fundraising and operations, then into the systems underneath the organizations I used to work for.

Selected Work

Three pieces of work that show how I decide, not just what I built. The full narratives follow, along with seven more.

Salesforce Architecture · Secure APIs · Technical Collaboration

Secure integration architecture for a platform I could not see

Designed the Salesforce-side schema, permission model, packaging strategy and API approach for a partner platform I never had a login to. Worked with the vendor's engineering lead to split responsibilities, verify the Salesforce half myself, and leave behind a reusable production package.

Shows architecture decisions under ambiguity, least-privilege scoping, and reuse across every future client rather than one.

  • Schema design
  • Least privilege
  • Managed packaging
Read case study
Migration · Identity · Technical Risk

Identity and migration risk at scale

Worked on migration efforts involving roughly a hundred thousand legacy member records against a billing run that does not move. Rebuilt the Salesforce-side authentication from scratch when earlier patches kept drifting, and argued to keep staging validation when the deadline made skipping it tempting.

Shows root-cause judgment over repeat patching, and a sign-off treated as a risk decision rather than a status check.

  • Identity reconciliation
  • Production risk
  • Root cause
Read case study
Partner Strategy · Technical Diligence · Operational Delivery

Bringing in a partner, not just building for one

Helped evaluate, establish and operationalize a technology partnership at company level rather than wiring up one more connector. Weighed technical feasibility against commercial terms, client value, and the internal process needed to keep it working past the first renewal.

Shows technical and commercial range, and partner ownership that outlasts the integration itself.

  • Vendor evaluation
  • Commercial fit
  • Rollout ownership
Read case study

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.

Capabilities

Areas of experience, grouped by the outcome they serve rather than by vendor logo.

Solution architecture

Salesforce object and data modeling, API approaches, data flows, permission design, identity and single sign on, and the tradeoffs between them when there is no clean answer.

Integration leadership

Requirements discovery, production readiness, migration sequencing, root-cause diagnosis, cross-team communication, and knowing when to escalate a risk rather than absorb it.

Technical partnerships

Vendor evaluation, partner onboarding, technical diligence, commercial fit, and owning the relationship and the incident path after launch.

Operational scale

Knowledge transfer, documentation, client-facing enablement, reusable playbooks and process standards, so the work does not depend on remembering who to ask.

Leadership

My leadership experience spans direct team management, technical decision-making, cross-functional delivery and building the processes that make good decisions easier to repeat.

As a Support Operations Team Lead I managed three CRM client success managers while building the documentation, support practices and self-service resources underneath them. In my integration work I influence decisions across product, engineering, vendors and client teams by making technical risks and tradeoffs understandable. I measure leadership by whether the work gets clearer, the team gets more effective, and fewer problems have to be solved twice.

Building and running a support team, not just staffing it

As Support Operations Team Lead, I managed three CRM client success managers, half of whose work was direct client member support alongside me. I built the structure underneath that: documentation, templated responses, and a full client-facing resource center so organizations could troubleshoot their own single sign on and Salesforce member support issues instead of opening a ticket every time. The measure of a good support structure is not how fast my team answers. It is how many questions never need to reach us at all.

Defining the categories before there was a system to track any of it

In my second year, before my team had any ticketing system to log this kind of work, I drafted the first written distinction we used between a vendor, an integrator, and a partner, because the three words were being used interchangeably and it kept causing avoidable confusion with clients. That same distinction is still how the team categorizes outside relationships today. Across those same pre-system years, I delivered somewhere around twenty distinct third-party integrations, one client organization at a time, invisible anywhere except scattered internal notes until I went looking for the record myself years later. Not long into that stretch, a partner organization spent an afternoon training me on how to write documentation for the very resource center I now own outright. The trainer and the trainee are the same job, just at different points, separated by enough time that people forget which one you used to be.

Closing a security gap nobody assigned me

Nobody put an OAuth scope audit on my calendar. I did one anyway, on integrations that were already live, and found two partner connections carrying identity permissions they did not need plus a misconfigured callback URL, the kind of gap that is invisible until the day someone finds it before you do. Both got closed before that day arrived. The permission-scoping decisions in the case study above are not a one-time exercise. They are a habit I apply to integrations nobody asked me to look at.

Setting the standard, not just meeting it

During a stretch where the team was stacked past what was sustainable, I told people directly how many hours I had and what each commitment actually needed, instead of quietly absorbing the overflow. My manager told the group afterward that's the mindset they want the whole team to run on. Naming your real capacity is not a retreat. It is what makes a commitment worth anything to the person receiving it.

Getting a process changed, not just following it

I proposed a hard cutoff for new scope introduced late in a project, after watching it repeatedly stall timelines that were not just mine. My manager did not just agree. They built it into how they described the problem to the rest of the team a few minutes later, unprompted, and named where the idea came from.

Building for other roles, not just my own

I built training material aimed at three different roles across the company, not mine, because I had noticed I was the bottleneck people had to track down whenever the same question came up. The measure of whether it worked will not be whether I answer fewer questions. It will be whether the questions stop needing me specifically.

Pushing on a problem that was not fully mine to fix

I have spent months pushing a product team on a data-model gap that mostly shows up for whoever is holding the actual client relationship when it breaks. A teammate backed the same point independently, without us comparing notes first, which is how I knew it was not just a me problem.

Fixing the cause instead of reapplying the patch

An individual's access issue had been bouncing between people for weeks, with repeated manual account fixes that kept failing to stick. The real cause was that the person had multiple unlinked login accounts in the underlying billing platform, so every fix landed on an account they were not actually using to log in. Once I understood why the patch did not hold, I stopped recommending it, routed the actual fix to the team that owns account linking, and flagged that anyone else in that organization with more than one chapter affiliation was probably hitting the identical problem. A fix that has to be reapplied is not a fix. Catching that early meant the effort went toward the systemic cause instead of patching the same account a third time next month.

Producing large-scale events and staffing volunteer leadership

Earlier in my career, as program staff at a nonprofit federation, I planned and ran events ranging from intimate gatherings of about a hundred people to large-scale fundraising and cultural events drawing up to 3,700 attendees. Part of the role was staffing a board of directors and several volunteer committees, including a philanthropy committee and a next-generation engagement committee I helped build from the ground up: real governance, real budgets, and real competing priorities, just running through volunteers instead of employees.

Naming a permanent limitation instead of promising a fix

A reporting gap kept resurfacing because everyone assumed it was a defect waiting on a fix. It was not. The qualification field the sync depends on is packaged, and it structurally cannot return the records in question. I said so plainly instead of leaving room for a fix that was never coming, and got agreement that the manual process is the long-term answer for that organization rather than a stopgap. Calling a permanent limitation permanent is less satisfying than promising a fix, and a great deal more useful to the people planning around it.

Two no's in the same week, both cheaper than the yes

Two access requests landed the same week and both got a no. A vendor asked for admin-level access to a production org; they got a dedicated named login scoped to what they actually need instead. Separately, an organization wanted member statements routed to a shared officer inbox, which would have quietly broken the link between a person's login and their own record. Neither no was the popular answer in the moment. Both were cheaper than the incident that follows the yes.

The thread through all of it: build the structure once, write down why, and hand it over cleanly enough that the next person does not have to find you. That is the work I want more of.

Writing

Posts from LinkedIn, archived here in full, newest first.

Two days of their time instead of six months of their goodwill

I sent a message to two colleagues recently that opened with, roughly: "Hi, welcome to the party. I come bearing gifts, and by gifts I mean several integration upgrades, a wall of questions, and some genuinely unfriendly deadlines." I was handing them a piece of my chaos, and I knew it. I said so out loud. Then I told them why I was doing it anyway. I could have guessed at the parts of the project outside my expertise. I would have gotten a decent amount of it right. The version where I guess wrong is the version where a handful of clients begin a brand new relationship on a sour note, and none of those relationships had the runway to absorb that. So I borrowed two days of their time instead of six months of their goodwill. Asking for help is not evidence that you do not know your job. Frequently it is the clearest possible evidence that you do, and specifically that you know exactly where your edges are. Name what you are handing over. Say why. Then thank them as you mean it, because you should. If you are fortunate enough, like me, to have access to Bonusly, thank your colleagues even more. Make sure your monthly allotment goes to them. My next month's refresh was gone in less than an hour after I got it, specifically for them.

Assigning the work is the easy part

Last week, someone in my network reached out with a question I recognized immediately. They'd been handed CRM administration on top of their existing job, no formal training, just a system that needed to keep running. They wanted to know what I wished someone had told me sooner. I've been in that seat. Early in my career, I was handed database admin duties for a different CRM, not the one I work in now, because I was young and the assumption was I'd figure it out. So I did, piecing it together from whatever documentation I could find and whoever would answer a question. It worked out. But looking back, what got me through wasn't a system. It was persistence and a handful of people willing to answer the basic questions. That is not a plan an organization should rely on. It is what happens when nobody else has the bandwidth to own it properly. I think about this a lot in operations and systems roles. The people quietly keeping the data clean and the integrations running rarely get asked what they need to do that well. The real leadership move isn't just assigning the work. It's building in the time and support for someone to learn it properly instead of figuring it out alone after hours. Assigning someone a critical system is the easy part. Building in the time for them to actually learn it is the part that gets skipped.

I've stopped writing documentation for smart people

I've stopped writing documentation for smart people. I write it for someone who's never seen this system before, has forgotten most of what she used to know, and still has to get it right on the first try. That someone is me, eight months from now. A lot happens in eight months that has nothing to do with the system I'm documenting. There were good stretches: a couple of cruises, a full softball season, new restaurants worth remembering, a musical that actually lived up to the hype. There was also a surgery for one of my parents, and the weeks of recovery after it, the kind that reorders what counts as urgent pretty fast. Somewhere in there, a very spoiled dog got more treats than any dog has a right to, because some days that was the easiest way to feel like things were okay. None of that is in the document. None of it should be. But that's why the document has to carry the whole load on its own, because future-me will not remember the clever workaround I found today. She will barely remember this project existed. She'll have whatever I wrote down, and nothing else. So she doesn't get three paragraphs of context before the first instruction. She gets order of operations, first and plainly. The why sits right next to the what, because the mechanics will mean nothing to her by then, but the consequences of skipping a step still will. Anything I'm not sure about gets labeled an open question instead of a confident guess, because a guess that sounds like fact is worse than an honest blank space. The real test of a process document isn't whether it's thorough. It's whether the next person can run it without having to find you first, especially on the weeks when finding you isn't realistic. If they still have to find you, that's not documentation. That's a hostage situation. Maybe that's the real standard: write for the version of yourself who is tired, distracted, and has a lot going on, because that version shows up more often than the sharp one. What's your test for "good enough to ship"?

Firm about the boundary, gracious about the person

Every October, my dad and I scope the same project: decorating my parents' house for Halloween. Lawn inflatables galore. Stickers on the windows. A light-up in every single window. The plan is the same every year. And every year, right on schedule, the scope creeps. A brand new inflatable appears, or an old favorite gets revived long after its best Octobers are behind it. Some things are never up for discussion. My dad answers the door in the same crazy mask he's had since I was little, and the four- to six-year-olds are his favorite audience because nobody plays along better. The scary song playlist still runs off a 1985 cassette tape on a boom box he still owns. Strangely, the speaker still sounds pretty good. My mom wears the Halloween vest she has had since she was my Brownie and Girl Scout troop leader. Those are not scope creep. Those are the requirements. Then there was Frankenstein, affectionately called "Frank". Last year was the season to lay Frank to rest. Dad would not take no for an answer. So we tried. Several attempts, a fair amount of MacGyvering, and my lifelong need to be the handy kid. At last, he had to accept defeat. Most out-of-scope requests at work come from someone who cares about the outcome as much as my dad cares about that lawn holiday decor. A flat "no" on day one does not solve anything. It just turns you into the obstacle in their story. What works better: Say back what they are actually trying to accomplish, so they know they were heard and not just handled. Be clear about what fits this round and what does not. Vague feels kind in the moment. It just moves the disappointment to a worse night. Offer the path, and be honest about where it ends. Some things can come back next season. Some things are Frank. Know what core is. Protect that first, and everything else gets easier to negotiate. Firm about the boundary. Gracious about the person. Hold the line. Keep the relationship. Leave the porch light on. ๐ŸŽƒ P.S. Frank may be retired, but Tom the turkey is already on deck for November.

My first job was at a Chinese restaurant

My first job was at a Chinese restaurant. I was in high school. I stayed three years. Phone orders, cashier, hostess, packing carryout, and somewhere in there I became the person who updated the POS system. I waited tables a few times. I was not good at it. The kitchen tickets printed in Chinese. Mine printed in English. Same order, two formats, and somebody in the middle had to make sure what left the kitchen matched what the customer actually asked for. I have been doing a version of that job ever since. The chefs spoke Cantonese. The dishwashers spoke Spanish. The waiters spoke some combination of English, Spanish, and Chinese, rarely the same combination as each other. Most of the kitchen worked six days a week, ten hours a day, on their feet the whole time. We ran on hand signals, my extremely novice Spanish, and a shared understanding that the food went out correctly regardless. My favorite station was the back. Hot kitchen, packing orders, knowing every dish at a glance. The easy work was out front. After a couple of years the owners, John and Joanne, took me and one other long-timer to Chinatown in Chicago for the day. Their favorite restaurant, the dishes they actually eat, the herbal shop and what everything in it was for, dragon boat racing. Then we drove back and worked the evening shift. A lot of teenagers had come through that restaurant. They had never done that for any of them. It was not a reward for staying. It was a reward for who we had been while we were there. I think about that more than any certification I have earned since.

Stop making people earn the answer

The fastest way to stop being a bottleneck is to stop making people earn the answer. When someone asks why a sync failed, the instinct is often to walk them toward it. Ask what they think happens when a record does not qualify. The intent is good. It is meant to teach. But when someone is under deadline pressure with a client waiting, they need the fix first. The why lands better right after it. The shape I use: 1. The answer, stated plainly, in the first line. 2. The why, as a short mechanism. One or two sentences, plain English. 3. What to do about it. 4. What to expect next, including anything still unconfirmed. 5. Then a link to the documentation if they want to go deeper. That is how knowledge actually transfers. Not because you drew it out of someone, but because you handed it over cleanly enough that they can use it again next week without you. The goal was never to be needed. It is to not be the only one who can fix it.

An email address is not an identity

Friendly reminder from someone who has cleaned up the aftermath: an email address is not an identity. People graduate. They get married. They change jobs. They finally abandon the account they made in eighth grade. Meanwhile the system you built is quietly matching records on that address and creating a brand new person every time someone updates it. Now you have one member with four records. Three of them have her history. One of them can actually log in. None of them agree on her last name. Use a stable, system-generated ID as your match key. Store it alongside whatever your authentication layer uses, so record matching and login are never fighting over the same field. Treat email as a contact method, which is all it ever was. It is not a glamorous rule. It will save you a data cleanup project that eats an entire quarter. Ask me how I know. Actually, do not. I am still recovering. ๐Ÿซฃ

The best database training I ever got

The best database training I ever got was turning more than forty boxes of records into a collection guide. I was an archives intern at the Indiana Historical Society, working on more than a hundred years of records from a community organization I also worked for. Documents, photographs, slides, videotapes, and a fair amount of utter mess. By the time I finished, those forty-plus boxes were down to fewer than thirty, arranged and described so someone else could actually use them. That someone else was the whole point. A collection guide (archivists call it a finding aid) tells a stranger what is in the boxes, how it is organized, and where to find the one thing they came for. I met those strangers once or twice a week when I staffed the reading room: researchers, members, museum visitors, people looking up the history of their own town. Knowing who it was for was the easy part. Making it work for them was harder, because the organization at the center of the collection went by four different names in seventy years and then merged into another. Someone searching for any one of those names still needed to find all of it. Along the way, the people in those boxes became real to me. I found friends and community members I knew, in their early years, making the impact I had only ever seen the end of. That was a joy. I also met, on paper, the people whose names are on buildings around town, and finally learned why they put them there. I think about that job almost every week now. A data model is a collection guide. A field name is a description. An organization that merged is a duplicate record waiting to happen. And the person you are really building for is not in the room. They show up eight months from now, looking for one specific thing, with no idea who built any of this. My route here was not traditional: history and anthropology, an archive, a fundraising shop, then a CRM. Each stop taught me how people actually organize information versus how we wish they would. If you are worried your background is too unrelated to count, it is probably load-bearing. You just have not named it yet. What did an earlier job teach you that you still use every week?

A good launch day is boring

A good launch day is boring. That is not a shrug. It is the entire point, and it takes weeks, if not months or possibly years, of invisible work to earn. No heroics. No war room. Nobody sprinting toward a deadline with a laptop open on their knees. Just a sequence of steps already tested, run in the order they were written down, by people who already know who owns what. Everything that makes launch day boring happened weeks earlier: Validation in a lower environment, so nothing about production surprises anyone. Notifications suppressed before the initial load, so no member receives a hundred emails apologizing for their own existence. A freeze window everyone agreed to in writing, and that nobody quietly works around because they needed just one exception. A confirmed answer to "which system is the source of truth after this," settled before launch instead of discovered during the first disagreement. If launch day is thrilling, that is rarely a sign of a bold team. It usually means something got skipped. Aim for boring. Boring is the deliverable. ๐Ÿ˜ด

Precise, not brief

I asked Slack AI, Slackbot, what animal I'd be based on my Slack activity. It said a bee ๐Ÿ. Constantly buzzing between projects, apparently the person everyone pings to confirm something is "good to go," and, direct quote, possessing "low patience for over-long messages." Accurate. Rude, but accurate. Except I had one objection: I send long messages all the time. Ask anyone who's received a Stephanie integration explainer that opens with "quick note" and runs four hundred words. So I pushed back. How am I the impatient one AND the person writing walls of text? The robot did not hesitate. It pointed out that bees are precise communicators. The waggle dance is basically a technical spec: here's exactly where the nectar is, here's the distance, here's the angle. So I'm not the bee with no patience for detail. I'm the bee that skips the two-second gesture and hands you the fully documented flight path. Which, honestly, is the most accurate thing anyone has said about me all week. I don't have low patience for length. I have low patience for a wall of text with the actual question buried in paragraph five. A detailed walk-through of why a sync will behave a certain way, so nobody's surprised in three weeks? Worth every word. Precise, not brief. Turns out those are different things. The dance has to be right, or everyone flies to the wrong flower. Back to the hive. Something needs to be synced, and I have a very thorough set of instructions to follow. What would yours say about you? Bring receipts. ๐Ÿงพ For those wanting to learn more about a waggle dance, because I certainly did: https://lnkd.in/ghgjC2Ai

That's normal for where I sit

I built a Salesforce integration for a system I have never logged into.

Here's what that actually took.

Before any security questions, we had a schema to design. How an application record relates to its reviewers, grades, and comments. What happens when two relationships need to point to the same person? Which identifier survives if an email address changes but a record cannot.

An API architecture decision was hidden in a volume question that sounded simple. Five thousand records, moved through synchronous calls capped at two hundred records each. Or an asynchronous bulk job, built for exactly that kind of end-of-cycle load.

And underneath it all, a packaging problem most admins never touch. Which org actually owns the package once you create it? Why a sandbox and a production org authenticate against two different endpoints. What quietly breaks for every future client if that ownership is wrong from the start and nobody catches it early.

That's normal for where I sit.

New vendor. Little to no context on their side. No login. I work off questions, scoping conversations, and whatever the other engineer can show me.

Most of it was knowledge transfer.

What's a permission set, versus a profile. Why "the object is accessible" and "the field has a value" are two different promises, and skipping the second means an integration writes blank fields for weeks before anyone notices.

But most of it wasn't admin work.

A schema to design. An API architecture call: two hundred records per synchronous call, or an async bulk job. A packaging decision most admins never touch.

That's architecture and integration design.

Not configuration. Some of it was literally writing the query or the API payload myself, not just describing the shape of what he needed.

The permission set was tight, on purpose.

Full access on their own data. Read only, named fields, everywhere else. Two versions of the same set, built for two different license types.

Knowledge transfer isn't handing someone a stack of facts.

It's deciding which half of the problem is yours to verify, and which half you trust someone else to know better than you do.

"They thanked me for being direct about timelines instead of vague. I'll take that over almost any other compliment this project produced."

The most expensive sentence

The most expensive sentence I hear on an implementation project: "it's just one test record." It is never just one test record. That record trips an automation. The automation sends a real email to a real member who was not expecting it. She calls her chapter. Her chapter calls headquarters. Headquarters calls me. It was a Friday. It was 4:45. I do not love how avoidable that afternoon was. The record was fine. What was missing was two questions I now ask before anything touches production, no matter how small it looks. What else does this touch. Not just the field I am changing, but the automations, the notifications, the systems downstream that will notice before I do. Can I actually undo it. Not "we'll fix it if it's wrong," which is a feeling, not a plan. The real answer, before I need it. Small changes are the ones that get skipped past, because they look too minor to bother checking. That is exactly when they get expensive. Ask the two questions. Save your Friday.

I did not know I needed it

I did not know how much I needed it until it landed. Recently, a client wrote to my leadership, unprompted, about the work our team has been doing. A few of us were named. My teammates earned every word, because nobody gets a launch across the line alone. I have still read it more times than I am going to admit here. Some context on why it hit the way it did. Membership organizations run on an academic calendar, so summer is when everything has to go live. Students come back, dues cycles start, and the deadline is an actual billing run rather than a date somebody preferred. We have been launching several at once. The last stretch has been validate, freeze, load, verify, repeat. Long days, weekend checks, and the very particular fatigue of being careful for hours at a stretch, because in this work the mistakes are quiet. They do not announce themselves. They surface three weeks later. You get through a season like that by keeping your head down. Which is exactly why a note from outside your own building lands the way it does. Nobody asked him to write it. He noticed, and he said so. So if you have thought something good about someone's work recently, send it. Do not save it for their review. Do not assume they already know. I am confident in what I do. I still needed it. Most of the people around you are running on less recognition than you would guess.

I accidentally did requirements analysis

I made bingo cards for a Renaissance faire this weekend and accidentally spent an hour doing requirements analysis. The premise was simple. Six of us, pirate weekend, spot the ridiculous. I wrote twenty-four squares. The first draft was useless. "A peg leg." Does a foam cover count? A costume boot? Someone kneeling on a bent leg? We would have argued about it in the parking lot. So the square became: a genuine peg leg, carved wood, load-bearing, not a foam cover over a bent knee. "A dog in costume" became: a dog in a full costume, hat or coat; a bandana does not count. Somewhere in the second pass I stopped and looked at what I had written. Acceptance criteria. At my desk, on a Friday afternoon, for a bingo card, entirely unprompted. I have shipped integrations that failed for exactly this reason. "Sync the active members." Active according to whom? The chapter roster, the billing system, or the person who has not paid since March but still turns up to everything? Nobody was wrong. The sentence was. The faire version costs you a squabble over a turkey leg or a round of grogs. The work version costs you a launch. Anyway. Six cards, twenty-four squares, one free space. If you spot a stroller rebuilt into a pirate ship, I want to hear about it.

Introduction

Hi, I am Stephanie. New to posting here. Not new to the work. I am an Implementation Specialist at re:Members, which is a long way of saying I spend my days getting one system to talk to another without either of them throwing a fit about it. Single sign on, data migrations, API integrations, and the occasional 11 PM "why is this field empty" mystery. The organizations I work with are membership based: fraternities, sororities, foundations, associations. Groups built entirely on people showing up for each other. Their technology should make that easier, not harder. That is the whole job. I came into this sideways. History and anthropology as my disciplines, a stint in an archive, seven years in nonprofit fundraising and operations, then five years building and repairing the systems underneath organizations like the ones I used to work for. More on that in a few weeks. I am going to start posting weekly. Expect practical things I learned the hard way, opinions about unique identifiers that I hold far too strongly, and regular reminders that behind every record is an actual human being having an actual day. Glad you are here. Say hi.

Contact

The fastest way to reach me is LinkedIn. I am open to conversations about solutions architecture, integration leadership and technical partnership work.

Connect on LinkedIn