Fueling application innovation at scale
How decentralized teams maintain speed with shared context
When engineering leaders talk about “modernizing the application stack,” it often turns into a shopping list for their teams.
They’ll name-drop cloud-native tools, faster CI/CD pipelines, or some new AI assistant that promises to write all the code for you. But in my experience as CEO at RedwoodJS Inc, modernizing the stack often starts with adopting new tools; but success depends on whether your team understands how everything fits together and why it matters.
That’s what makes decentralization so hard.
Whether it’s distributed teams, modular infrastructure, or fragmented workflows, the real challenge is context. If developers can’t reason about the system on their own machine; if security and product aren’t aligned, if platform teams are bottlenecks instead of enablers, then all the “modern” tools in the world won’t help you ship faster or safer.
At RedwoodJS, and in every engineering org I’ve worked with, the pattern is clear: decentralization demands more than just better tooling. It demands intentional structure; systems that surface the right context to the right people at the right time.
Let’s talk about what that looks like in practice.
Application innovation beyond tooling
You’ve got distributed teams working across time zones, developers focused on features, security focused on risk, platform teams owning infrastructure, and AI injecting code whether you’re ready or not. Everyone has their own tools, incentives, and workflows.
The assumption is that newer tools will fix this. But they often make it worse. What teams actually lack isn’t capability; it’s clarity.
The hardest part of modernizing isn’t skill or scale, it’s the environment gap. You used to develop on what you deployed. Now, continuous integration lives in the cloud, developers are local, production is somewhere else entirely, and none of them behave the same. Your developers are flying blind and “it worked on my machine” becomes a daily disaster.
Real innovation is removing micro-frictions so your team can ship today, not someday. That starts with closing the environment gap. But the real fix is shared context.
Velocity depends on context: The invisible blocker in distributed work
Velocity isn’t a product of better tooling. It’s a result of unblocked decision-making.
When a developer writes code and opens a pull request, what happens next? If the reviewer lacks context; why the change was made, what trade-offs were considered, who asked for it, they have to go hunting for it. That slows everything down. And in distributed teams, the people with answers might not even be online.
That’s why we started doing video pull requests (PRs) at RedwoodJS.
Instead of writing a wall of text or hoping someone reads the Jira ticket, the developer records a quick screen share. They walk through the code. They explain the “why,” not just the “what.” They talk through what they struggled with and what the reviewer should focus on. It’s not fancy, just a simple screen recording. But it turns a cold, context-less PR into a human conversation.
Context is how you keep velocity without sacrificing understanding.
When that context disappears, you start seeing shortcuts. Tests flake, so developers skip them. A deadline looms, so they cut corners. The feedback loop breaks, trust erodes, and velocity drops through the floor. Video PRs, clear ownership, and shared standards are all ways to fight that entropy.
When application development and security aren’t aligned, nobody wins
In a conversation I had with Trey Guinn, Cloudflare Field CTO on the series Beyond the App Stack, we discussed a stat from the 2026 Cloudflare App Innovation Report: 80% of organizations think their dev and security teams are fully aligned.
I’ll say what I said then: that’s bullsh*t.
Devs are rewarded for delivering features quickly and security is rewarded for preventing risk. That’s not alignment; it’s an obstacle course.
The result is predictable: security feels like an arbitrary tax on the developer’s time, the organization ends up with systems that are neither fast nor safe, and everyone loses.
The solution is a platform team that acts like Switzerland.
When platform teams work, they serve the product teams. Their job isn’t governance, it’s enablement. They provide secure-by-default foundations so devs don’t have to choose between safety and speed. They make the “right way” also the easiest way. And they own the boring, repeatable stuff that nobody else wants to think about. That includes compliance. When security is embedded early through shared infrastructure and defaults, it stops being a bottleneck and starts being automatic. Platform teams are in the best position to make that happen; by baking in controls, auditability, and consistency across environments without slowing teams down.
When the platform team becomes a blocker, they’ve failed. But when they act as a service provider, with devs as their customers, they can realign incentives across teams that were previously pulling in opposite directions.
Clear ownership is what makes secure defaults work
Once teams have shared context, the next step is clear ownership. Context helps people understand why a decision was made. Ownership ensures someone is responsible for what happens next. Without it, even well-intentioned developers can go rogue; not out of malice, but out of necessity.
I’ve seen developers pull full production databases onto their laptops because “staging was useless” and they had to debug a timezone issue. I’ve seen push notifications that say “testing…123” go out to real customers. And I’ve seen interns connect to prod and drop tables by accident; because nobody told them not to. These are warning signs of systems built without guardrails.
When ownership is unclear, context disappears. And people do whatever it takes to get unblocked.
AI is only as good as your platform’s structure
Application innovation should make sure developers never have to “test in prod” just to do their jobs. That means strong defaults, safer environments, and clear boundaries around access and data. But it also means investing in the long tail: documentation, decision logs, naming conventions; anything that helps new people get up to speed without guessing.
That kind of structure is exactly what AI systems will rely on to be useful. Platform teams also play a critical role in preparing orgs for AI, by centralizing knowledge, enforcing standards, and making decisions machine-readable.
AI can write code fast. But if that code lands faster than it can be reviewed or understood, you get chaos. Conflicting patterns. Inconsistent UX. Tribal knowledge that doesn’t scale. If an AI assistant can’t explain to a new hire why we don’t use a certain library, it’s just adding to the bloat.
The future belongs to organizations that structure for speed
Here’s the principle I wish more CTOs followed with application innovation: Ask yourself, “Is our system understandable?”
Not “do we have the best tools.” Not “are we using the latest framework.” Just: can a new developer get productive in a day or two without asking 50 questions?
If the answer is no, your stack doesn’t matter. You’re failing at the only thing that counts: velocity.
Application innovation means creating an environment where teams move fast without introducing unnecessary risk; where speed and safety aren’t in conflict, and context is built into every step of the workflow. That means embedding context into workflows, aligning incentives across dev, security, and platform teams, and defining ownership; not just of systems, but also of standards and decisions.
In a decentralized world, context is the infrastructure and the teams that figure that out are the ones that will win.
Building momentum
Modernizing your applications marks an ongoing shift in how teams build, ship, and secure applications; not a one-time milestone. To sustain that momentum, you need a platform that accelerates velocity and enforces guardrails at every layer.
Cloudflare’s connectivity cloud supports that shift, whether you’re migrating legacy systems, scaling microservices, or building AI-native applications. With a unified platform combining performance, security, observability, and developer tooling, Cloudflare reduces friction and gives teams the context and control to move fast, without compromising trust or inflating costs.
This article is part of a series on the latest trends and topics impacting today’s technology decision-makers.
Dive deeper into this topic.
Learn more about how organizations are modernizing their app stacks and processes in the 2026 Cloudflare App Innovation Report.
Author
Peter Pistorius — @peterpistorius
CEO, RedwoodJS
Key takeaways
After reading this article you will be able to understand:
How context accelerates decentralized teams
Why alignment is key to secure application modernization
The role of platform teams in scaling AI readiness