Latest / The CTO Podcast with Fexingo: Technical Leadership, Architecture, and Engineering Org / How Salesforce Fixed Its Engineering Culture
Transcript
- Lucas: There is a specific kind of exhaustion that happens when you work at a company the size of Salesforce. It isn't just about the hours; it is about the noise. You are building on top of layers of legacy code, third-party integrations, and a platform so vast that no single engineer understands more than five percent of it. The challenge for any CTO in that environment is not technical complexity per se, but organizational entropy. Luna: Right, because when you have thousands of engineers working on the same core product, you inevitably start seeing duplicate efforts and conflicting APIs. It feels like trying to build a house where every contractor has their own blueprint. Lucas: Exactly. And for years, Salesforce operated with a highly decentralized model that encouraged speed at the expense of consistency. Teams were organized around features rather than underlying platform capabilities. This meant that if you wanted to use a new authentication method or a specific data storage protocol, you might have to rebuild it yourself because the central platform team wasn't moving fast enough to support your specific use case. Luna: So you end up with what I call the 'not invented here' syndrome, but internalized. Teams hoard knowledge and resources because they don't trust the central infrastructure to deliver what they need. Lucas: Precisely. And the cost of that inefficiency shows up in two ways: first, in wasted engineering hours spent reinventing the wheel, and second, in security vulnerabilities because decentralized teams often lack the rigor of centralized security reviews. The real turning point came when leadership realized that developer velocity was being capped by internal friction. They needed to stop treating the platform as a shared resource and start treating it as a product with customers—where those customers were the other engineers inside the company. Luna: That is a fascinating shift in perspective. Treating internal tools as products requires a completely different set of metrics than traditional software development. Lucas: It does. The key insight was introducing the concept of 'cognitive load' as a measurable constraint. They started tracking how many decisions an engineer had to make to deploy a simple change. If the answer was more than three or four, the system was too complex. This metric forced platform teams to simplify their interfaces, abstract away unnecessary configuration, and provide clearer documentation. It wasn't just about making things faster; it was about making things understandable. Luna: I love that. Because usually, when companies try to fix complexity, they just add more layers of management or more meetings. Here, they actually removed steps. Lucas: They did. By focusing on reducing decision points, they empowered engineers to move faster without sacrificing control. But there was another piece to this puzzle, which was the restructuring of the teams themselves. They moved away from purely feature-based squads toward a hybrid model where platform experts sat embedded within product teams. Luna: So instead of having a separate platform team that throws things over the wall, you have specialists who understand the deep infrastructure but also understand the specific business problems their product team is solving. Lucas: Correct. This eliminated the 'throw it over the fence' mentality. When a platform expert is part of the daily workflow, they can spot potential architectural conflicts early. They can say, 'Hey, if you build it this way, it will conflict with our upcoming data migration plan,' rather than discovering that six months later when everything breaks. It shifts the dynamic from reactive firefighting to proactive collaboration. Luna: And that changes the incentive structure for everyone. The platform team isn't judged solely on uptime anymore, but on how well they enable the product teams to ship. Lucas: Yes, and that is where the real cultural shift happened. Previously, platform teams were often seen as gatekeepers or bureaucrats. Now, they are viewed as enablers. Their success is tied to the success of the engineers they support. This alignment reduced the tension between 'build fast' and 'build right.' You don't have to choose between speed and stability anymore because the platform provides the guardrails that make speed safe. Luna: It reminds me of how high-performing sports teams operate. The coaches don't just give orders; they design drills that make the right play the easiest play. That is what good platform engineering feels like. Lucas: That is a perfect analogy. And one of the most concrete examples of this was their approach to documentation and self-service tools. They built an internal developer portal that acted as a single source of truth. Instead of emailing questions to random engineers or digging through outdated wiki pages, developers could go to the portal, find the standardized patterns for their task, and execute them immediately. Luna: Because let's be honest, nobody reads the documentation unless it is painfully obvious that they have no choice. Making it easy is the only way to get compliance. Lucas: Absolutely. And the portal didn't just host text; it hosted executable templates. You could spin up a compliant microservice instance with pre-configured logging, monitoring, and security policies in one click. This reduced the setup time from days to minutes. It also ensured that every new service launched met the baseline requirements for observability and security, which drastically reduced the operational burden on the SRE teams later down the line. Luna: So you are solving tomorrow's problems today by baking the requirements into the creation process. That is smart proactive design. Lucas: It is. But there is a nuance here that often gets missed. Standardization can sometimes stifle innovation if it becomes too rigid. Salesforce had to walk a fine line. They standardized the boring stuff—the networking, the identity management, the basic container orchestration—but left the interesting stuff open for creativity. They gave engineers freedom within boundaries. Luna: Like giving someone a perfectly soundproof studio with all the best instruments, but letting them decide what song to write. You remove the distractions so the music can happen. Lucas: Exactly. And this approach also helped with onboarding. New hires at a company of that size can feel overwhelmed by the sheer volume of systems. With standardized patterns and a clear portal, the learning curve is much flatter. A new engineer can become productive in weeks rather than months because they are following proven paths rather than exploring a maze. Luna: Which is huge for retention. Nobody wants to spend their first three months just trying to figure out how to send an email internally. Lucas: Right. So, quick honest thing — a handful of listeners chip in monthly through buy me a coffee dot com slash fexingo, and that is literally what funds making this many of these. No ads, just us talking shop. Luna: Yeah, if these conversations are useful for what you are building or running, consider joining that small group of supporters keeping the show going ad-free. Lucas: We appreciate it. Anyway, back to the structural side of this. One of the less glamorous but more impactful changes was in how they handled incident response. Before this shift, incidents were often treated as isolated events. Post-mortems were written, filed away, and forgotten. Luna: Which means you keep making the same mistakes. Because humans forget, but systems remember. Or at least, they should. Lucas: They do. Salesforce started linking incident post-mortems directly to their product roadmap. If an incident revealed a gap in the platform or a confusing API, that item was automatically added to the backlog for the platform team. It turned pain points into priority items. This closed the loop between breaking things and fixing the root cause. Luna: That is such a simple idea but rarely executed well. Most companies treat post-mortems as blame exercises rather than improvement opportunities. Lucas: Precisely. And by removing the blame element and focusing on systemic fixes, they created a culture of psychological safety. Engineers felt comfortable reporting issues early because they knew it would lead to better tools, not punishment. That openness accelerated the feedback loop significantly. Luna: So you get more data earlier, which leads to better decisions. It is a virtuous cycle rather than a vicious one. Lucas: It is. And looking at the broader implications, this model suggests that technical debt is not just a code problem. It is a communication problem. When teams are siloed and incentives are misaligned, debt accumulates regardless of how clean the code is. Aligning those incentives through platform-centric structures can pay dividends far beyond the immediate technical improvements. Luna: I think a lot of leaders underestimate how much of their engineering output is lost to translation between teams. Fixing that translation layer is half the battle. Lucas: It really is. And finally, one metric that stood out to us was the reduction in mean time to recovery. By standardizing observability and providing better self-service tools, they cut the average downtime for minor incidents by nearly forty percent. That is not just a number; that is revenue preserved and customer trust maintained. Luna: Forty percent is massive. It shows that when you invest in the foundation, the roof stays up even during a storm. Lucas: Exactly. So, the question for us as leaders is whether we are treating our internal platforms as a cost center to be minimized, or as a strategic asset to be optimized. The answer determines whether our engineers are builders or firefighters. Luna: And probably both, until you decide to change the dynamic. Which sounds like a difficult but necessary conversation for any growing tech org. Lucas: It is. And I wonder if the next big wave of efficiency gains won't come from companies that finally master this internal product mindset. Luna: Likely. Because once you stop fighting your own structure, you have plenty of energy left to fight the competition. Lucas: Well said. We will leave it there for now.