Marek Cermak6 min

On the Go: The Inside Story of Go Engineers at STRV, Vol. 2

EngineeringInside STRVSep 11, 2023

EngineeringInside STRV


Sep 11, 2023

Marek CermakGo Platform Engineering Manager

Share this article

So, where did we leave off with the story? Right… I was sitting, very uncomfortably, listening to Michal’s offer for the Go team after having been told the team lacks experience in the most fundamental things. “There is a catch, though,” he said.

I recommend checking out Volume 1 to read about how (and why) our Go team began the “2022 infiltration of STRV.”

The Catch

“Things are never plain and simple, are they?” I replied to break the silence after we’d been staring at each other for quite a while. By the time Michal responded, I’d already devised a strategy for my team to get employed at the nearest branch of McDonald’s, where I’d proceed to drown my sorrows in a bucket of chicken wings.

“Well,” Michal interrupted my thoughts, “I would like to give you all a chance. You’ll all get offers…” So far so good, I thought. What’s the catch, then? 

“...but you’ll have to get to the level of our backend engineers in two months. In that time, it will be your responsibility to get the Go platform and all the engineers on par with the existing tech stack.”

Now, I’ll let you in on a little secret. Written in Node.js, the STRV tech stack’s API template alone had taken two years to perfect. Dozens of engineers of all seniority levels had contributed to that template. Moreover, it’s Node.js; there’s a library for literally anything. Heck, there’s even a library to check if a number is equal to 10,000! Whilst in Go, you may not have that kind of luxury.

I looked at Michal. Really, the question was: Can we set up a whole tech stack in two months and build a project for thousands of users with it? So I replied:

“Sure, we can do that.” 

Rising to the Challenge

If there’s anything that I’ve learned over the years, it’s that you can face any challenge if you have a team with the willingness and motivation to overcome it. So how was I sure that we could get up to speed with STRV backend engineers in two months? Well, I wasn’t. In fact, I knew it couldn’t be done. Not for all six people, not in two months. 

Don’t get me wrong, I trust in the abilities of my Go guys more than I trust my own. But I knew that the STRV team was top-class, and that they’d already perfected the template based on dozens of production-grade projects. That’s a level of quality that we couldn’t possibly compete with in a few weeks. So why did I accept the offer, knowing that my head was on the chopping block? Because I knew it wasn’t about matching STRV’s level at all — it was about rising to the challenge. And spoiler alert: The challenge presented to us was nothing compared to the one that we’d face in the first month at STRV.

After my call with Michal, I naturally went on to discuss it with the team. I told them what was expected of us and asked them whether they think we’d be able to do that. Their answer was: “No clue, but let’s do our best.” 

The following day, when I came to the office, the team was standing around the whiteboard, brainstorming what libraries we’d need for the new Go API template. The week after, a PR containing a skeleton for the backend API was ready for review. Remember when I mentioned that a team with the willingness and motivation to overcome challenges can and will do so? This is what I meant.

The Happy Path

The day after our STRV onboarding marked the first day of our two-month challenge. The rules were relatively simple: We would prepare the whole Go tech stack so that after those months were up, we’d be able to pick up any client project. 

A week went by and Michal asked me to jump on a call. I assumed it was just a regular call, a team temperature check. Well… I was partially correct. It wasn’t really a check — but it sure had to do with the temperature, because it was about to get rather hot.

“Hey Marek, remember how I told you you’d get two months to prepare for the first client project?” I went with the only viable answer: “Eh… yeah?” Michal continued, “Well, how about two weeks instead?” 

You know that Harold hiding pain meme, right? That was my face at that moment. Apparently, a new deal came in and, by coincidence, they were asking specifically for two Gophers. It was an agile deal, meaning we wouldn’t need to set up the whole project from scratch… but still. Going for it would mean two fewer engineers working on the Go tech stack. What a lucky coincidence! 

“Sure, we can do that,” I replied.

You see, what I didn’t mention was that there was a period between the time we got the offer from Michal and the time we joined STRV. It was roughly a month and, seeing as we were already unemployed, we figured — why waste time? So we’d started working on the STRV tech stack. Cut to this moment where, thanks to that decision, we were relatively ahead of schedule. We’d thought it might come in handy if we were to hit some sort of a speed bump.

Now, if you think we were on the happy path to completing the challenge, let me stop you right there. Because in just a week, things were about to get much more complicated.

Down to One

Two weeks in. The backend team is almost fully utilized at this point. And here comes the kicker: A deal to build a media platform (that matches our experience perfectly) comes in and, sure enough, we’re asked to take it. The project start date: in two weeks’ time.

Let me summarize some facts.

We’re supposed to build an entire tech stack, which means preparing a full-fledged production-grade API template — including custom libraries, CI/CD setup and configuration management. It’s something that’s been in progress for a couple of years in the Node.js platform’s tech stack. We have two months to do it.

Originally, it was five engineers and me.

After a week of officially working on it, it was three engineers and me.

Then, one month in, we’d be down to one engineer and me. One month left until the deadline.

Well, what can I say. We’re all brave humans inside. “Sure, we can do that,” I replied. And when I told the last brave human standing that it would be him and me from now on, I’m pretty sure we must have looked like Buzz and Woody from Toy Story.

Was it foolish to accept the deal and start working on the client project while being in the middle of building the tech stack? Not really. Because by the time we’d start working on the client project, we’d already have the first version of the template — and could put it to the test. 

The strategy was clear. Two engineers would work on the client project, using the initial version of the template and continuously reporting what’s missing for the real-world use case. The remainder of the team — plus the engineers on the agile deal — would support them, should time allow it. With that, we’d efficiently create a deal within a deal, with an agile setup within an agile setup (I know, right?). The two “client project engineers” would be the stakeholders, with the rest of us continuously iterating internally to provide them with the best possible product.

A Deal Is a Deal

Believe it or not, when the “two months since joining STRV” timer dinged, we were already running a microservice architecture in AWS, using AWS event queues and a managed relational database, having continuous integration ready to yell at us for every linting issue or failed test with minimal tech debt in the backlog… and the roadmap reached its conclusion right on time. 

A deal is a deal. And we delivered our side of it. 

In two months, the team was 80% allocated (and FYI, just a week later, we hit 100% — as we got yet another deal). A team that hadn’t existed just two months prior, using a language that had never been used at STRV before, was 100% allocated in 10 weeks. 

We were supposed to finish the tech stack in two months with six engineers working on it full-time. The team managed to finish it with two engineers being in an agile setup since week two, the other two engineers being on a client project since week four, and one guy — me — who was supposed to be of some help to the team but was mostly swamped with management.

The least I could do was to share the story. It’s their success, and theirs alone. 

Every time I’d been faced with a challenge that seemed almost impossible to overcome, I answered, “Sure, we can do that.” But it’s them who deserve the recognition. It’s them who always strive for the best and never give up. And it’s them who’d been living and breathing the principles of STRV long before we joined STRV. 

It’s now been a year since we joined STRV and this is my way of showing them my respect and my gratitude. By sharing their story — the inside story of Go engineers at STRV.

Share this article

Sign up to our newsletter

Monthly updates, real stuff, our views. No BS.