Blog

Three years ago, we adopted a managed file uploader. Since then, we’ve rewritten our front end twice and tripled our traffic. This is the long-term report on what held up and what didn’t.

Key Takeaways

• Two full front-end rewrites crossed the upload integration without a single change to the seam.
• Per-file callbacks and returned URLs make an integration that outlives the framework it was written in.
• Traffic tripled while the upload success rate stayed inside a 0.2-point band.
• Direct-to-storage transfer kept upload bytes out of capacity planning for three years running.
• Both rough edges we hit were documented edge cases with workarounds, and neither caused an outage.

The 2023 Setup and What We Feared

At adoption, we wrote down our fears in the same document as the decision—a habit that proved invaluable. The three fears were vendor lock-in, pricing drift, and API churn. Three years later, none of them materialized in the way we expected. Lock-in turned out to be a question about our own code, not the vendor’s. The bill tracked our volume exactly. And the calls we wrote in 2023 are still the calls we make today.

What Held Up: The Integration Seam

Our integration consists of a single module, about two hundred lines, that takes files and callbacks from the application and returns URLs. Nothing else in the codebase talks to the upload service directly. In November 2023, we replaced a jQuery-era front end with React. In July 2025, we replaced that React SPA with Next.js and server components. Both migrations touched hundreds of files, but neither touched the upload module—because the module never knew what was calling it.

The quiet finding of three years: a contract made of per-file callbacks and returned URLs has nothing framework-shaped in it, so there is nothing for a framework migration to break. The seam survived two rewrites by having no opinions.

What Held Up: Reliability Under Growth

We set an SLO on upload success, measured at our edge, counting a transfer complete when the URL returns to the application. Then we watched it across a tripling of traffic. The mobile share went from one upload in five to more than one in two, yet the success rate did not budge. Chunked uploads were the reason: a phone that loses signal in a lift resumes rather than restarts. Direct-to-storage transfer earned its keep in a quieter way—upload bytes never touched our application servers, so capacity planning never had to think about them.

What Held Up: Scale and Compliance Asks

In late 2025, two enterprise deals reached the stage where security teams asked who else touches the data. Being able to hand over a SOC 2 report and a data processing agreement, rather than promising to produce one, turned both reviews from multi-week exchanges into a few days of paperwork. Three years later, the answer to what makes the best file upload API for enterprise-scale applications includes what security certifications the provider actually holds.

What Did Not Hold Up

Two things, both our assumptions meeting documented behavior rather than anything breaking:

1. Cache lifetime after replacing a file. We assumed overwriting a file would immediately change what users saw, but the edge kept serving the old version until cache expiry. The workaround took an afternoon: stop replacing files in place, write a new file and move our own pointer—and we got a version history out of it.
2. Webhook delivery. Our first handler assumed each notification would arrive exactly once and in order, which no queue promises. We created a day of duplicate records. The fix was idempotency keyed on the file handle, plus a handler that tolerates any order.

Neither was an outage. Neither cost a customer. Both were us learning what the contract actually said.

The Three-Year Verdict

Three things held up: the seam, direct-to-storage transfer, and chunked uploads. Two things needed workarounds, and both workarounds are a few dozen lines that have been quiet ever since. The transferable lesson is that durability lives in the shape of the integration—one module, events in and URLs out, nothing else allowed to reach past it. Write that on day one, and the question of what sits behind it stays a question you can answer later, cheaply, whenever you want.

Frequently Asked Questions

Does a managed file uploader survive a framework migration?

Ours crossed two—jQuery to React, then React to Next.js—with no changes to the integration. That holds when the contract is per-file callbacks and returned URLs.

What happened to upload success rate as traffic tripled?

It stayed between 99.3 and 99.5 percent across all three years, while monthly uploads went from 1.2 million to 3.6 million and mobile share went from 20% to 55%.

What should you check before an enterprise security review?

Whether your provider can hand you a SOC 2 report and a data processing agreement today, plus their data residency options under GDPR and their subprocessor list. Having those ready shortened two of our reviews from weeks to days.

What surprised you most over three years?

That the durable part was the shape of the interface rather than any particular version of anything. The module we wrote in a week in 2023 is the reason two rewrites were cheap in 2023 and 2025.