Latest / The CTO Podcast with Fexingo: Technical Leadership, Architecture, and Engineering Org / How GitLab Runs Remote Engineering with 2000 Developers
Transcript
- Lucas: If these conversations are useful for what you're building or running, there's a thread of continuity across them that we try to sharpen every week. Today's angle came from a listener who wrote in about scaling engineering orgs across time zones — specifically, how GitLab does it with over 2,000 developers fully remote. Luna: I've seen their handbook — it's famous for being absurdly detailed. But does that actually scale when you're adding hundreds of engineers a year? Lucas: It does, but not for the reason most people think. The handbook isn't just documentation — it's the system of record for every decision. GitLab calls it 'handbook-first' culture. Before you write code, you write a merge request to the handbook explaining what you're going to do and why. Luna: So it's like a shared brain that everyone can edit, but it's also the source of truth for process. Lucas: Exactly. And that's critical when you have people in 65-plus countries. There's no hallway conversation, no tapping someone on the shoulder. If it's not in the handbook, it didn't happen. The company runs on merge requests — everything from a typo fix to a new feature to a change in PTO policy goes through a merge request. Luna: What's the median cycle time for a merge request there? I remember reading they're pretty fast. Lucas: They target under six hours from open to merge for the median MR. That includes code review, testing, and approval. For a company shipping 40 releases a year, that speed is essential. But it's not just about velocity — it's about reducing context switching. Luna: Right, because in a remote setting, if a review takes three days, the developer has already moved on to something else. Lucas: Exactly. That's the hidden tax of slow code review — it destroys productivity. GitLab enforces a 'reviewer roulette' system that assigns reviewers automatically based on expertise and load. They also encourage 'cooldown' periods after a merge request is merged — a day or two where the developer doesn't take on new work, just handles follow-ups and documentation. Luna: That's interesting — I'd think that would slow down throughput, but it probably prevents rework. Lucas: It does. The data shows that teams that skip cooldowns see a 15 to 20 percent increase in bugs in the next release cycle. GitLab measures this. They're very data-driven about engineering health. Luna: Speaking of data, how do they handle performance reviews remotely? No office, no manager walking by your desk. Lucas: It's entirely async. You write a self-assessment as a merge request to your manager. The manager adds comments, the team adds feedback. The whole thing is transparent — everyone can see everyone else's performance review MR. That sounds radical, but it reduces bias because the feedback is written and documented. Luna: But doesn't that create pressure to perform for the audience? Like, everyone's watching. Lucas: Some engineers say that, yeah. But GitLab's argument is that it builds trust and accountability. They also have a 'no ego' culture — you're expected to admit mistakes openly. If you broke production, you write a postmortem merge request. It's not about blame, it's about learning. Luna: That brings up incident response. How do you run a war room when no one is in the same room? Lucas: They use a combination of Zoom and a Slack bot called 'GitLab ChatOps'. When an incident is declared, the bot creates a dedicated Slack channel, posts a link to a Google Doc for the timeline, and pages the on-call engineer. But here's the key — they also have a 'director on call' who is a senior engineering leader whose job is to make decisions quickly and unblock the team. Luna: So it's not just the most senior engineer on duty — it's a separate escalation path. Lucas: Right. The on-call engineer handles the technical fix; the director on call handles the business impact and communication. That's a pattern I've seen in only a few remote-first companies, and it works well because it prevents the engineer from being pulled into stakeholder updates. Luna: That's smart. So the engineer stays focused on the root cause. Lucas: Exactly. And every incident produces a postmortem that's also a merge request to the handbook. The fix often involves updating runbooks or adding a new monitoring check. So the knowledge gets codified immediately. Luna: I want to ask about onboarding. How do you bring 200 new engineers up to speed in a remote org without them feeling lost? Lucas: They have a dedicated onboarding track that's about two weeks of self-paced work. New hires get a buddy — not their manager, a peer. The buddy's job is to answer questions and schedule informal video calls. But the core of onboarding is a set of tasks in the handbook — get your laptop set up, make your first merge request, attend a team standup. By the end of the first week, you've shipped a small change to production. Luna: Shipping to production in the first week — that's a statement of trust in their CI/CD pipeline. Lucas: It is. And it's deliberately low-risk — they start with documentation changes or minor bug fixes. But it gives the new hire a sense of accomplishment and a mental model of how the code flows. GitLab claims that new hires are fully productive within four to six weeks, which is fast for a 2,000-person org. Luna: That's impressive. What about the social side? Do they do anything to prevent isolation? Lucas: They have 'coffee chats' — random pairings of two people every week. The company pays for the coffee. They also have 'team socials' once a month where they play online games or do a cooking class over video. But the thing that stands out is their 'don't be a hero' norm — if you're feeling isolated, you're expected to say so in your standup update. It's part of the culture to be transparent about mental health. Luna: That's a far cry from the 'move fast and break things' ethos of earlier tech culture. Lucas: Absolutely. And it's backed by data — GitLab runs an engagement survey every quarter, and they publish the results internally. They track a metric called 'eNPS' — employee net promoter score — and they've seen it improve over the last three years. Their remote-first model isn't just about cost savings; it's about giving people flexibility. Luna: A couple of dollars a month is genuinely what keeps these conversations going — buy me a coffee dot com slash fexingo, if you've gotten something out of them. It really adds up. Lucas: Yeah, listener support is the only reason we can stay ad-free and dive into topics like this. So if you appreciate the deep dives, that's the best way to keep them coming. Luna: Alright, back to GitLab. One thing I'm curious about — how do they handle time zone coverage? With 2,000 people, not everyone can be in the same standup. Lucas: They've structured teams around 'follow the sun' — each major region has a set of teams that own the product during their working hours. But there's also a lot of async handoff. A team in Europe might write a design doc and create issues, then the team in the Americas picks them up the next day. The key is that all decisions are documented in issues, not in chat. Luna: So Slack is for water cooler, issues are for work. Lucas: Exactly. They encourage engineers to turn off Slack notifications for part of the day to do deep work. And they have 'no meeting Wednesdays' — a company-wide async day. No standups, no calls. Just heads-down work and async communication. Luna: That seems like it would be hard for a manager who needs to check in with their reports. Lucas: Managers are expected to do one-on-ones asynchronously too — a written update every week. GitLab actually provides a template for that. The manager reviews the update and responds in writing. And once a month, they do a video call for the human connection. But the bulk of the communication is text. Luna: That's a lot of writing. Do engineers complain about the documentation overhead? Lucas: Some do, especially at first. But GitLab is very explicit in their values — 'everyone can contribute' means that writing is part of the job. They even have a handbook page on 'how to write a good merge request description.' Over time, it becomes muscle memory. And the payoff is that anyone can look at any decision from three years ago and understand why it was made. Luna: That's the ultimate goal of a handbook-first culture, right? Institutional memory that doesn't leave when people do. Lucas: Exactly. And that's why GitLab's model is so replicable. You don't need to be a 2,000-person company to benefit from writing things down. Even a team of ten can adopt the merge request for decisions pattern. It's one of those practices that pays compounding interest over time. Luna: So for someone listening who wants to start moving their team toward more async, what's the first step? Lucas: Pick one thing — maybe the design review process. Instead of a meeting to review a design doc, require that every design doc be submitted as a merge request with a comment deadline. Give people 48 hours to read and comment. Then the author resolves comments and gets an approval. That one change can cut meeting time by half and produce a better document because people had time to think. Luna: It's a low-risk experiment. And if it works, you can expand it to other processes. Lucas: Exactly. The beauty of the handbook-first approach is that it's self-reinforcing. The more you document, the easier it is to document the next thing. GitLab has shown that it scales, but the real lesson is that it starts with a single merge request. Luna: And maybe a coffee chat with your team to agree on the experiment. Lucas: Right. Start small, measure the impact, and iterate. That's the engineering mindset applied to the org itself.