7 min read
Migrating 100k users with no maintenance window: dual-write, shadow reads, and reversible cutovers.
Migration · Architecture
_industries / Enterprise: scale
Enterprise is where speed goes to die. We build so it doesn't.
For large organizations, iFlux builds software that clears the whole gauntlet, not just the demo: single sign-on and role-based access control the security team approves on the first pass, integration layers that wrap the legacy system of record without touching it, and migrations that move thousands of users with zero downtime — using dual-write, backfill, and shadow reads instead of a risky big-bang cutover.
// thousands of users. dozens of integrations.
// a security team with veto power.
// a procurement cycle that outlasts most projects.
We build for all of it — the user, the auditor, and the approval process.
Tell us about your enterprise challenge →// a security team with veto power.
// a procurement cycle that outlasts most projects.
We build for all of it — the user, the auditor, and the approval process.
SSO / SAMLRBAC / ABACLegacy IntegrationSOC 2Data GovernancePlatform EngineeringZero-Downtime MigrationObservability
_problems we've actually solved
// identity & accessSSO, SCIM, RBAC
Access control that the security team signs off on the first time
In the enterprise, a feature that can't enforce who sees what doesn't ship. We build SAML/OIDC SSO (single sign-on — one login across every company tool), SCIM provisioning (accounts created and shut off automatically as staff join or leave), and role- or attribute-based access control (RBAC/ABAC) from the first commit — so the security review is a formality, not the wall your project dies against three weeks before launch.
// legacy integrationsystem of record
The system of record that nobody will replace and everything depends on
There's a mainframe, an ERP, or a homegrown platform at the center of the business, and touching it is off the table. We build the integration layer around it — anti-corruption boundaries (isolation layers that translate between the old system and the new code so problems in one don't leak into the other), event streams, and API facades — so new capability ships fast without forcing a migration nobody signed up for.
// migrationat scale
Moving 100,000 users without a maintenance window
A big-bang cutover on an enterprise system is a resume-generating event. We do it the boring way: dual-write, backfill, shadow reads (writing to both old and new systems, copying historical data over, and quietly comparing results before any customer sees the new system), and a reversible cutover per cohort — so the migration is a series of non-events instead of a weekend the whole company holds its breath through.
// governanceaudit & lineage
The data lineage and audit trail the compliance team will actually ask for
When the auditor asks who touched this record and where this number came from, "we think" is not an answer. We build immutable audit logging, end-to-end data lineage, and access records that reconstruct any event on demand — governance engineered in, so SOC 2 (the security-controls audit enterprise customers require before they'll sign a contract) and internal audit stop being fire drills.
// scalethe production p99
The p99 latency that only shows up in production, never in the demo
Enterprise scale breaks the assumptions that held at 100 users. We build for the tail — load-tested against real traffic shapes, instrumented for the slow query under lock contention, and degradable when a downstream dependency stalls — because at your volume, the rare event happens every day.
// procurementthe approval process
Building for the approval process, not just the end user
In the enterprise, the person who uses the software and the people who approve it are rarely the same. We build for all of them: the IT governance layer, the security questionnaire, the procurement cycle, and the user who just needs it to work — because a product that delights users and fails the security review still doesn't ship.
In the enterprise, the best product doesn't win. The one that ships past the security review, the procurement cycle, and the migration risk does.
// we engineer for the whole gauntlet.
// not just the happy-path demo.
_the trust
layer// security is
// not a feature
// you add.
// it's how the
// thing is built.
layer// security is
// not a feature
// you add.
// it's how the
// thing is built.
SOC 2 Type II
Controls that hold up over time, not a point-in-time snapshot. Audit-ready logging, access management, and change control engineered in.
SAML / OIDC SSO
Enterprise single sign-on with SCIM provisioning and deprovisioning. Identity federated to the IdP your customers already run.
RBAC / ABAC
Role- and attribute-based access control enforced at the data layer, not just hidden in the UI. Least privilege by construction.
ISO 27001
Information security management aligned to the framework your enterprise buyers require before they sign.
GDPR / CCPA
Data subject rights, consent, retention, and deletion built into the architecture — not bolted on when the DPA lands on your desk.
Audit Logging
Immutable, queryable records of every access and state change, streamed to your SIEM and retained to policy.
_what an enterprise audit looks like
iflux: enterprise_platform_audit.sh
~/iflux/Industries/Enterprise $ audit --scope=platform --security=true --scale=true
→ Reviewing identity & access model...
⚠ Access enforced in UI layer only. API returns unauthorized records directly.
⚠ No SCIM deprovisioning. Offboarded users retain active sessions.
→ Auditing data governance...
✗ Audit log mutable and non-immutable. Cannot satisfy SOC 2 change-control criteria.
⚠ Data lineage undocumented. Source of 3 reporting metrics unverifiable.
→ Load-testing at enterprise volume...
⚠ p99 latency 4.1s under 10k concurrent. Lock contention on write path.
→ Evaluating migration plan...
⚠ Planned cutover is big-bang, no rollback path. High-risk single event.
→ Checking legacy integration boundaries...
✓ System of record stable. Anti-corruption layer viable without replacement.
✓ Audit complete. 6 issues found. 1 critical audit-log violation flagged.
→ Priority fix list generated. Security-review readiness mapped.
~/iflux/Industries/Enterprise $ _
_what we've built for the enterprise
✓
Enterprise SSO & identity with SAML/OIDC federation, SCIM provisioning, and fine-grained RBAC/ABAC
✓
Legacy integration layers with anti-corruption boundaries, event streams, and API facades around systems of record
✓
Zero-downtime migrations using dual-write, backfill, and reversible per-cohort cutovers
✓
Governance & audit platforms with immutable logging, data lineage, and SIEM integration
✓
Platform engineering with internal developer platforms, paved paths, and self-service infrastructure
✓
High-scale services load-tested and instrumented for the production p99 under real traffic
✓
SOC 2 & ISO 27001 readiness with the controls and evidence auditors ask for built in
✓
Observability stacks with distributed tracing, SLOs, and the context to resolve incidents fast
_services we bring to the Enterprise
Every enterprise engagement is backed by the full iFlux capability stack, matched to the governance, scale, and integration reality you actually operate in.
_frequently asked
Can you build enterprise SSO and access control that passes our security review?
Yes, and we build it from the first commit rather than retrofitting it. We implement SAML/OIDC single sign-on, SCIM provisioning, and role- or attribute-based access control enforced at the data layer, so the security team's review confirms what is already there instead of blocking the launch.
How do you migrate a large system without downtime?
We avoid big-bang cutovers entirely. Our approach uses dual-write, backfill, shadow reads to validate the new system against the old, and a reversible cutover per user cohort. Each step is independently safe and rollback-able, so a migration of 100,000 users becomes a series of non-events rather than a high-risk weekend.
We have a legacy system of record we can't replace. Can you still modernize around it?
That is one of our most common engagements. We wrap the system of record with anti-corruption boundaries, event streams, and API facades so new capability ships quickly without forcing a migration. The legacy system keeps doing its job while the business gets modern software on top of it.
Are you SOC 2 and ISO 27001 aware in how you build?
We engineer the controls those frameworks require directly into the architecture: immutable audit logging, least-privilege access, change control, and data lineage. That means SOC 2 Type II and ISO 27001 evidence is a byproduct of how the system is built, not a scramble before the audit.
How do you handle scale and performance for enterprise workloads?
We build and test for the tail, not the average. That means load testing against realistic traffic shapes, instrumenting for slow queries and lock contention, and designing for graceful degradation when a downstream dependency stalls. At enterprise volume the rare event happens daily, so we plan for it up front.
_thinking / Enterprise
6 min read
Why enterprise deals die at the security review, and how to build so they don't.
Security · SOC 2
8 min read
The anti-corruption layer: shipping fast around the system of record nobody will replace.
Legacy · Integration
Shipping inside a large organization?
Talk to a Flux who's cleared the gauntlet.
// no team that discovers your governance layer late.
// no migration weekend the whole company dreads.
// just an honest conversation with someone
// who already knows where enterprise projects stall.