Why activist investors are pushing Elden Ring developer to self-pub...

The Activist Investor Playbook: FromSoftware as a Case Study in Developer Autonomy

When a group of activist investors recently demanded that FromSoftware - the studio behind the critically acclaimed Elden Ring - dump its long-time publisher Bandai Namco and go it alone, the gaming world took notice. The official argument, as reported by Kotaku, is blunt: "We think the current arrangements with the game publishers like Bandai Namco and Activision are no longer good deals for the Company. " This isn't just a story about corporate boardroom battles; it's a litmus test for the entire software development and distribution model that has dominated the industry for decades.

At its core, the dispute is about control of the distribution pipeline and the economics of software monetization. As a senior engineer who has watched the shift from physical media to digital storefronts, I see striking parallels to the open-source revolution and the rise of platform-agnostic deployment. The investors are effectively asking: Why should a studio that has built one of the most successful games in history hand over 45-50% of its revenue to a publisher when it could capture that margin by selling directly to platforms like Steam, Epic Games Store or even its own launcher?

But the answer isn't simple. Self-publishing a modern AAA title like a future FromSoftware game means owning an entire technical stack: build pipelines, patch delivery, DRM integration, localization tooling, platform certification, and customer support infrastructure. Let's examine what this shift would actually entail from a software engineering perspective - and why the outcome matters for every developer working on a commercial product.

The Financial Math of Self-Publishing: Why 45% Revenue Share Hurts Developers

Traditional publisher deals typically give the developer 20-30% of net revenue after the publisher recoups its expenses. For a game like Elden Ring that sold over 20 million copies at $60 each, Bandai Namco likely kept 40-50% of the gross - after platform fees (Steam's 30%, PlayStation's 30%, etc. ) the studio's actual cut may have been as low as 15-20%. The activist investors argue that by self-publishing, FromSoftware could capture the entire net revenue minus platform fees - effectively doubling or tripling their per-unit profit.

Let's run the numbers. If a future title sells 10 million units at a $70 price point, at a 50% publisher split the developer nets $350 million. Under a self-publishing model with no publisher margin, the studio would keep roughly $490 million after platform fees (assuming 30% average). That's an extra $140 million - enough to fund an entire new title or double down on R&D for their proprietary engine (Game Developer analysis of FromSoftware's engine tech).

However, this math ignores the costs that publishers absorb: QA testing across multiple platforms, translation into 20+ languages, marketing campaigns that cost $50M+, and a dedicated PR team. For a studio that has never managed these functions, the operational burden can quickly erode those theoretical gains. The real decision isn't about percentages - it's about whether a developer can build the internal tooling and team to replace the publisher's services without sacrificing quality or time-to-market.

Technical Infrastructure Required for Self-Publishing: Beyond Just Uploading a Build

From a DevOps perspective, self-publishing is far more complex than hitting "Upload" on Steam. Consider the pipeline for a single patch on three platforms (PC, PlayStation, Xbox):

• Build orchestration: Automated builds triggered by Git commits, with separate configurations for each platform's SDK. Tools like Jenkins, GitLab CI. Or GitHub Actions must handle Unreal Engine (or custom engine) compilation, asset baking. And packaging.
• Patch delivery: Steam uses its proprietary Steam Pipe system; PlayStation uses specific package formats. The developer must maintain scripts that generate delta patches (binary diffs) to minimize download sizes. Without experienced engineers, a 10GB update could ship as a full re-download.
• DRM integration: Denuvo, Steam's built-in DRM. Or a custom solution must be integrated into the build pipeline. Mistakes here can cause compatibility issues or cracked versions within hours.
• Localization injection: Tools like Unreal's Localization Dashboard or custom string formats need to be compiled into platform-specific font files. A single misaligned character can crash the game on Japanese systems.
• Certification testing: Sony and Microsoft require games to pass technical certification (TRC) before any patch goes live. A self-publishing studio must either build an internal QA lab or contract a third-party certification house - each certification cycle costs $10K-$50K.

FromSoftware currently offloads all of this onto Bandai Namco. If they go independent, they'll need to hire a platform engineering team of at least 20-30 People - and that's before we talk about cloud infrastructure for multiplayer servers, which Elden Ring (surprisingly) doesn't rely on heavily, but future titles might.

The Risk of Cutting Off Distribution and Marketing: What Publishers Actually Do

It's easy to underestimate the value of a publisher's distribution network. Bandai Namco has relationships with every major retailer - both digital and physical - that allow a game like Elden Ring to appear on the front page of the PlayStation Store, secure a physical shelf space at Walmart, and coordinate simultaneous global launches. When you self-publish, you're competing for visibility on Steam against thousands of other titles. And your marketing reach is limited to your own social media channels.

The technical side of this is often overlooked: publishers have dedicated teams that handle metadata optimization, A/B testing of store page assets and platform-specific sales event submissions. Steam's algorithm rewards games that generate early wishlists and high conversion rates. Without a publisher's analytics team, a studio might run ineffective ad campaigns, misprice the game. Or miss the optimal launch window. I've seen multiple indie titles with great gameplay fail because they launched during a Steam sale when discoverability was drowned out.

Moreover, publishers provide customer support and refund management. Steam's refund policy is generous; a high refund rate (above 15%) can get a game removed from the store. Handling ticket volume at FromSoftware's scale would require a 24/7 support operation running on tools like Zendesk or Freshdesk, plus integration with the game's backend to verify purchase status. The cost is manageable. But the engineering effort to build a reliable system is non-trivial.

Engine Ownership and Technology Stack Implications

FromSoftware develops its own in-house engine, custom-built for their specific gameplay mechanics (weighty combat, interconnected world traversal, etc. ). This gives them full control over performance optimization - one reason Elden Ring runs on older hardware - but it also means they must maintain the engine internally. A self-publishing studio has to fund ongoing engine development, tooling, and documentation. Which can cost $5-10 million per year for a AAA-quality engine.

If they switched to Unreal Engine 5, they'd gain access to Nanite virtual geometry, Lumen global illumination, and Epic's robust publishing support (including the Epic Games Store cut of 12%). But they'd also lose the unique "feel" that their custom engine provides - and potentially face licensing fees (5% royalty after $1M in gross revenue). The engineering cost of porting their entire toolchain to Unreal would be staggering, likely exceeding the initial savings from self-publishing.

I argue that the smartest move would be to keep the custom engine but invest in containerized build environments using Docker and Kubernetes, allowing reproducible builds across platforms without relying on a publisher's integration team. This is exactly how many large-scale enterprise software teams handle multi-OS deployment, and it's transferrable knowledge from the broader software engineering community.

Parallels with the Open Source Movement and Developer Independence

The activist investors' argument mirrors the philosophical shift that occurred in the web development world: why rely on centralized hosting (like npm or Docker Hub) when you can self-host using tools like Verdaccio or Harbor? Similarly, game developers are beginning to question the necessity of publishers when digital storefronts are abundant and cheaper than ever. The difference is that open source tooling is free. While building a publisher-replacement platform costs millions.

However, the open-source model offers a blueprint: just as companies like Red Hat built businesses around supporting free software, a studio could use publisher services only where they add marginal value (e g., localization for certain markets) while handling core distribution themselves. This hybrid model is already used by studios like Paradox Interactive. Which self-publishes but partners with external firms for specific regions.

From a technical debt perspective, the self-publishing argument is about reducing dependency on external APIs and proprietary toolchains. Every integration with a publisher's submission system is a coupling point that can break during updates-just ask any developer who has had a game rejected due to a patch certification bug that was the publisher's fault. Owning the entire pipeline reduces such risks but increases internal liability.

What This Means for the Future of Game Development as a Service

If FromSoftware successfully self-publishes, we could see a snowball effect: other high-profile studios (like FromSoftware's sister teams, or even CD Projekt Red) reconsider their publishing deals. This would accelerate the trend toward platform-agnostic development where games are built once and deployed to multiple storefronts using unified tooling like Open 3D Engine (O3DE) or Unity's new multiplayer service.

However, the counter-argument is that self-publishing increases fragmentation. Each studio reinventing the wheel for patch management, DRM, and customer support is inefficient - akin to every web startup building its own authentication system instead of using OAuth 2. We might see the rise of "publishing-as-a-service" startups that offer the technical infrastructure without the revenue share, similar to how Stripe handles payment processing without taking a cut of the business model.

From a regulatory perspective, the investors' push also highlights how little transparency exists in publisher contracts. If the SEC ever mandates that public companies disclose revenue sharing and marketing spend per title, we might see a wave of renegotiations across the industry. But that's a long shot; for now, the battle is purely financial and technical.

A Practical Guide for Studios Considering Self-Publishing

If you're a small-to-mid-size studio evaluating self-publishing, here's a technical checklist derived from what FromSoftware would need:

• Invest in CI/CD early: Set up GitLab CI or GitHub Actions with matrix builds for each platform. Use tools like Steamworks SDK and platform-specific command line tools to automate build generation and upload.
• Build a community pipeline before the game launches: Use Discord, Steam Playtest. Or subreddits to gather early feedback and bug reports. This reduces the need for expensive third-party QA.
• Plan for a 10x support volume: add a robust ticket system with automatic telemetry from the game client to identify crash patterns before users report them.
• Localization as code: Use version-controlled JSON files for strings, with automated validation to catch missing translations. Use tools like Crowdin with Git integration.
• Self-host where it matters, outsource where it doesn't: Keep engine development in-house. But consider using Epic Online Services for matchmaking and leaderboards rather than building your own.

FAQ: Common Questions About Game Developer Self-Publishing

How much does a publisher typically take from game revenue?

For AAA titles, the publisher's share can range from 30% to 50% of gross revenue after platform fees. Indie developers often see 70-80% if they self-publish, but they bear all costs.

What are the biggest technical hurdles for self-publishing?

Platform certification (especially PlayStation and Xbox), build pipeline automation for multiple storefronts, and 24/7 customer support are the most challenging aspects from an engineering perspective.

Can FromSoftware keep using their custom engine if they self-publish?

Yes. But they'll need to fund all engine maintenance and updates without a publisher's R&D budget. That's feasible given their success, but it adds ongoing cost,

Is self-publishing becoming more common

Yes, especially for indie titles. Epic Games Store's 12% cut has forced Steam to improve its services. And middleware like Unity and Unreal make multi-platform deployment easier than ever.

What happens to marketing if a developer self-publishes?

They must invest heavily in digital marketing, influencer partnerships. And community management. Some studios hire external PR agencies, while others build in-house marketing teams.

Conclusion: The Engineering Reality of Independence

The activist investors are right that the current publisher deals may not be in From