
Why Integration Auth Is So Hard to Maintain and How to Offload It
Authentication sounds like the easy part of building an integration. You grab an API key, or you run an OAuth flow, and you’re off. Then you actually try it.
I’ve spent years building connectors, and here’s what I can tell you. Auth eats time and causes weird bugs, and it has almost nothing to do with what your integration is supposed to accomplish. It also never stays done. This post covers what auth management involves, then walks through a couple of war stories and how we handle it at Pandium so your engineers don’t have to.
What auth management actually covers
When we talk about auth management, we mean the whole job of connecting your product to each customer’s third-party apps. That means running the OAuth or API key flow and storing the credentials securely. It also means keeping tokens fresh and fixing connections when they break.
The credentials can be API keys or OAuth tokens, and sometimes even database entries. At Pandium we collect them from your customers and store them in a secret vault and a secrets engine, so you never have to carry that responsibility yourself. If a security review has ever asked you exactly where third-party secrets live in your stack, you know why that matters.
For OAuth, we also handle refreshes. Every time a sync runs, it uses a fresh access token that’s ready to work. Nobody on your team writes refresh logic or sets calendar reminders for expiry. That behavior is built into every one of our connectors, and we cover 300+ systems, from public and private APIs to SFTP servers and direct database connections.
OAuth is a standard in name only
On paper it looks simple. API keys on one side, OAuth on the other. In practice OAuth 2 is a standard mostly in name. Every company implements it a little differently, and there are plenty of switches to flip on or off depending on the vendor.
Think about what a basic OAuth flow involves. Your customer clicks a button and approves access on a consent screen. Your app gets a code back and trades it for an access token. Simple enough. Now layer in the real world. Some vendors expire access tokens in an hour and others in a day. Some rotate refresh tokens every time you use one, which means a single failed write can lock you out. Some are picky about redirect URLs and scopes. Each of those details lives in documentation that may or may not be accurate.
So when you sit down to build an auth workflow, you end up in a maze, trying to figure out which combination gets you a valid token. Here’s the part that bugs me. Once somebody has solved that maze for a given system, nobody else should ever need to solve it again. That’s the whole reason we exist. We figure out how to connect to a system once, and every customer using that connector benefits.
Why auth never stays done
Most engineering tasks have a finish line. Auth doesn’t. Every app authenticates differently and every customer brings their own credentials. On top of that, every token eventually expires. Multiply all of it across dozens of integrations and hundreds of customers and you’ve got a real, ongoing engineering cost.
Silent failures.
- A failed token refresh quietly stops a sync. Your customer finds out when their data looks stale, and then you find out when they open a ticket.
Security scope.
- The moment you store third-party secrets, encryption and key management land on your team, along with audit scope. Every stored credential widens what you have to defend.
Then there’s the human side. Walking customers through connecting their apps turns into support tickets, especially when every vendor’s flow looks and feels different. None of that work makes your product better. It just keeps the lights on.
Why it’s the most painful part of building an integration
Think about what your integration engineer is supposed to be doing. They’re focused on business logic and on getting data from one system to another. Auth sits off to the side of all that. It’s a one-time sunk cost on every single integration, and it adds load without adding value to the product.
Remove that need and your engineer can spend their time on the logic that matters. That’s how you get integrations live faster. It’s also why we built Pandium as a code-first embedded iPaaS. Your team writes the integration logic in your own repository, and we run the auth layer and the infrastructure around it. If you’re comparing approaches, our breakdown of code-first versus low-code integrations goes deeper on the tradeoffs.
Two connectors that tested our patience
We build connectors for a living, and we usually measure development time in hours. Two of them blew that up.
The first was one of the big tech companies, and I’ll leave it there. This was four or five years ago, right after they launched a new marketplace. They deployed an OAuth 2 style API where you had to pass four client IDs and secrets through each other in a specific order. That order changed depending on how the customer connected. Were they coming from inside the vendor’s marketplace, or from outside, inside ours? I still don’t know why they designed it that way, and they eventually scrapped it. But it took us two weeks. When we usually measure connector development in hours, that was one of our most painful deploys ever.
The second came up on an international system. To get user credentials, you needed to receive an actual postcard in the mail. That was only to sign into an account that could then give you API credentials. Then there was a QR code system layered on top. Physical mail, across borders, as step one of an integration. These are exactly the things you don’t want to deal with every time you build out an integration.
Both stories point to the same thing. Auth quirks are unpredictable and have nothing to do with your product, and the cost lands on whoever happens to be building that integration.
How your customers connect
A core part of deploying Pandium is giving your customers a way to connect their systems to us. We offer a few patterns, and you choose how deeply to embed the experience.
Auth only.
- You embed a link wherever you like and design the experience around it. When your customer clicks, a window pops out. If it’s an OAuth flow, they walk through it. If it’s an API key, we collect it. The whole thing is managed through our marketplace settings, so it can be branded to look like your product. You can also send an Auth Link for a single connector, or share a Magic Link that works without a Pandium account.
Embedded install flow.
- Next level up, you deploy the first-time user experience (the FTUX) from our In-App Marketplace anywhere inside your application. Customers land in a flow where they set up their own configurations and secrets, and they pick their own schedule.
Fully managed.
- This one adds discovery. A customer visits a page and searches for QuickBooks. The QuickBooks tile comes up, and they can read about what the integration does in your system and run the install right there.
Fully headless.
- You can drive everything through the API and treat us as a headless service. You call us, and you build the display layer yourself. The docs will get you started.
For the first three patterns, everything is powered by an embedded link carrying a JWT, and how embeddable you want things to be is entirely up to you. With embedded auth-only connections, your customers never see Pandium at all, and they never need a Pandium account.
Whose OAuth app is it?
This question comes up a lot, and the answer matters. Your OAuth app and partner developer account stay with your company. Pandium runs the auth flow on top of them. That keeps the partner relationship yours and white-labels the experience, so customers see “App by [your company]” on the consent screen instead of our name.
How we keep secrets safe
Security is usually the first thing a technical buyer asks about, so here’s how it works.
Third-party credentials are encrypted with AES-256, and OAuth tokens get customer-specific encryption keys. Everything travels over TLS 1.3 or later, and credentials are never logged. Only the relevant tenant can access its decryption keys, and secrets can’t be exported.
At runtime, secrets arrive in your integration as environment variables. You can set them per customer or once globally for every tenant. Each integration runs in an isolated environment, and Pandium is SOC 2 Type 2 certified. Our security page has the full details.
The practical effect is that your own audit scope doesn’t grow with every credential you’d otherwise be storing.
What happens when a connection breaks
Tokens expire and customers change passwords. Connections break, and the real question is how fast you find out and how much it costs to fix.
When a sync run fails, Pandium sends email and webhook notifications, and the alert states the reason, including connection and token refresh errors. Each customer’s connection status is visible inside Pandium. To fix a dead connection, your team sends the customer a fresh auth link. Support can reconnect a tenant without opening an engineering ticket, which is a big deal when you’re running hundreds of customer connections. If you want a wider view of how your integrations perform, Integration Insights shows the real impact of every integration.
Building it yourself versus offloading it
Here’s how the work compares task by task.
Secrets are only half the story
Secret management is the obvious piece. Keep the keys safe and keep them fresh. The other half is the collection experience, meaning how your customers actually hand those credentials over.
Every vendor does that a little differently, and your customers feel the inconsistency. One system wants an API key pasted into a box, and another sends users through a multi-screen consent flow. Then there’s the one that wants a postcard. We normalize all of it. Whatever the system on the other end demands, your customer gets one clean, consistent experience, and your team gets a lot less to build and maintain.
API key or OAuth?
Teams ask me which one their integrations should use. It depends on what each third-party app offers, and Pandium supports both. OAuth gives customers a consent flow and scoped, revocable access. API keys are simpler to set up but tend to be long-lived. Our connectors handle whichever method each app requires, so you rarely have to pick a side.
What if the connector you need doesn’t exist yet?
Ask for it. We build new connectors free of charge, typically in one to two days. The connector handles auth and webhooks, and your integration code handles everything else. If you’d rather have experts build the integrations too, our Integration Development Services team can take that on. The AI-Powered Integration Code Generator can speed up whatever code your team does write.
Since you own the code, you keep control. Your integration logic lives in your own repository, and Pandium runs the auth layer and the infrastructure around it.
Where to go from here
If you’re evaluating platforms, our Product & Engineering Guide to choosing an integration platform walks through the technical and business questions worth asking, including how to judge a platform’s AI capabilities.
If you’re staring down an integration roadmap and dreading the auth work, that’s your signal. Let someone who has already been through the maze handle it, and get your engineers back to the work that moves your product forward.
From the Blog
