<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Eriksen Costa on Medium]]></title>
        <description><![CDATA[Stories by Eriksen Costa on Medium]]></description>
        <link>https://medium.com/@eriksencosta?source=rss-d6f3dc98bdc4------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*oSxG7rBuXtApX-vXviFMsg.jpeg</url>
            <title>Stories by Eriksen Costa on Medium</title>
            <link>https://medium.com/@eriksencosta?source=rss-d6f3dc98bdc4------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 16:06:28 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@eriksencosta/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Introducing Kotlin Money]]></title>
            <link>https://medium.com/@eriksencosta/introducing-kotlin-money-ed4c370b88a0?source=rss-d6f3dc98bdc4------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed4c370b88a0</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[cryptocurrency]]></category>
            <category><![CDATA[currency]]></category>
            <category><![CDATA[money]]></category>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Eriksen Costa]]></dc:creator>
            <pubDate>Tue, 08 Oct 2024 13:02:07 GMT</pubDate>
            <atom:updated>2024-10-09T16:26:14.371Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W2oLIkXxxiCDHJC6oFAqKw.jpeg" /><figcaption>Dollar bills and Bitcoins. Photo by David McBee.</figcaption></figure><p>Manipulating monetary amounts is a common computing chore. However, no mainstream language has a first-class data type for representing money, it’s up to programmers to code abstractions for it. This isn’t an issue per se until dealing with rounding issues from operations like installment payments (e.g., buy now, pay later), foreign exchange, or even simple things like fee processing and tax collection.</p><p>Inspired by my days at <a href="https://blog.eriksen.com.br/en/platform-engineering-n26">N26</a> dealing with these challenges, I introduce <a href="https://github.com/eriksencosta/money/">Money</a>: a Kotlin library that makes monetary calculations and allocations easy:</p><pre>val price = 100 money &quot;USD&quot;                     // USD 100.00<br>val shipping = 5 money &quot;USD&quot;                    // USD 5.00<br>val subtotal = price + shipping                 // USD 105.00<br>val discount = 10.percent()                     // 10%<br>val total = subtotal decreaseBy discount        // USD 94.50<br><br>val ratios = listOf(60.percent(), 40.percent()) // [60%, 40%]<br><br>total allocate 2                                // [USD 47.25, USD 47.25]<br>total allocate ratios                           // [USD 56.70, USD 37.80]</pre><p>The library supports mathematical operations with monetary amounts, calculations with percentages, and allocation, making it simple to model use cases like those mentioned. Cryptocurrencies are also fully supported out of the box:</p><pre>val price = 0.01607580 money &quot;BTC&quot;           // BTC 0.01607580<br>val transactionFee = 1.25.percent()          // 1.25%<br>val total = price increaseBy transactionFee  // BTC 0.01627675<br>val installments = total allocate 3          // [BTC 0.00542559, BTC 0.00542558, BTC 0.00542558]<br><br>val rate = 62_555.60 money &quot;USD&quot;             // USD 62555.60<br>val totalInUsd = total exchange rate         // USD 1005.63</pre><h3>Allocation</h3><p>One of the nicest features of the library is its allocation capability. Allocation allows the distribution of a monetary amount into parts while guaranteeing that the sum of the parts equals the original value. For example, a retailer may accept purchases by credit card installments or by buy now, pay later (BNPL). What happens when a customer makes a purchase totaling USD 100.00 to be paid in three installments?</p><pre>val price = 100 money &quot;USD&quot;<br>val number = 3<br>val installment = price / number<br>val installments = List(number) { installment } // [USD 33.33, USD 33.33, USD 33.33]<br>val total = installments.sum()                  // USD 99.99</pre><p>As you noticed, there is a loss of USD 0.01. A penny here and there may seem a slight loss, but it may be <a href="https://slate.com/technology/2019/10/round-floor-software-errors-stock-market-battlefield.html">costly over time</a>. But there are other complications as well, such as overcharging a customer (which can be an infringement of consumer rights in several countries) due to rounding issues. The library provides a handy allocate() method that guarantees the result won’t differ from the original amount:</p><pre>val price = 100 money &quot;USD&quot;<br>val installments = price allocate 3          // [USD 33.34, USD 33.33, USD 33.33]<br>val total = installments.allocations().sum() // USD 100.00</pre><p>To allocate in proportional parts, pass a list of Percentage values to the method:</p><pre>val amount = 2345.89 money &quot;USD&quot;<br>val result = dueAmount allocate listOf(50.percent(), 30.percent(), 20.percent())<br>val allocations = result.allocations() // [USD 1172.94, USD 703.77, USD 469.18]<br>val total = allocations.sum()          // USD 2345.89</pre><p>As you can see in the previous examples, both results totaled up to the original monetary amount. No cent was lost or gained. By default, the library automatically allocates the difference. But you can tweak how the difference is allocated in the allocations list. For example, suppose your company requires the difference to be always allocated to the last item. You can do it by creating the allocator object directly with the desired allocation strategy:</p><pre>val price = 100 money &quot;USD&quot;<br>val allocator = EvenAllocator(OnLast)<br>val installments = allocator.allocate(price, 3) // [USD 33.33, USD 33.33, USD 33.34]<br>val total = installments.allocations().sum()    // USD 100.00</pre><h3>Wrapping up</h3><p>This post is just a glimpse of the library’s capabilities. I intend to keep the library’s API concise and to expand its capabilities gradually, including supporting Android development and out of the box persistence and serialization. Nevertheless, I hope it’s useful in its current version for people manipulating monetary amounts in Kotlin projects.</p><p>Refer to the <a href="https://github.com/eriksencosta/money/tree/trunk/docs/usage">usage guide</a> on how to work with Money. The library has built-in support for <a href="https://github.com/eriksencosta/money/blob/trunk/docs/appendixes/circulating-currencies.md">306 circulating currencies</a> and <a href="https://github.com/eriksencosta/money/blob/trunk/docs/appendixes/cryptocurrencies.md">2283 cryptocurrencies</a>. The <a href="https://github.com/eriksencosta/money/#installation">installation procedures</a> are explained in the project’s README. Give it a shot!</p><h3>References</h3><ul><li><a href="https://blog.eriksen.com.br/en/platform-engineering-n26">Platform engineering at N26: how we planned and launched it</a></li><li><a href="https://github.com/eriksencosta/money/">Money: Project repository</a></li><li>Slate. Lav Varshney, 2019. <a href="https://slate.com/technology/2019/10/round-floor-software-errors-stock-market-battlefield.html">The Deadly Consequences of Rounding Errors</a></li><li><a href="https://github.com/eriksencosta/money/tree/trunk/docs/usage">Money: Usage guide</a></li><li><a href="https://github.com/eriksencosta/money/blob/trunk/docs/appendixes/circulating-currencies.md">Money: Circulating currencies</a></li><li><a href="https://github.com/eriksencosta/money/blob/trunk/docs/appendixes/cryptocurrencies.md">Money: Cryptocurrencies</a></li><li><a href="https://github.com/eriksencosta/money/#installation">Money: Installation procedures</a></li></ul><p>Originally published on my <a href="https://blog.eriksen.com.br/en/introducing-kotlin-money">website</a> on Oct 8, 2024.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed4c370b88a0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Platform engineering at N26: how we planned and launched it]]></title>
            <link>https://medium.com/@eriksencosta/platform-engineering-at-n26-how-we-planned-and-launched-it-8c81ef1b6a51?source=rss-d6f3dc98bdc4------2</link>
            <guid isPermaLink="false">https://medium.com/p/8c81ef1b6a51</guid>
            <category><![CDATA[team-topologies]]></category>
            <category><![CDATA[developer-experience]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[Eriksen Costa]]></dc:creator>
            <pubDate>Tue, 07 Nov 2023 02:49:29 GMT</pubDate>
            <atom:updated>2023-11-07T02:49:29.779Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cYQnNTdu1aq6HOTalQkNEQ.jpeg" /><figcaption>Estação da Luz railway station by night. São Paulo, Brazil. Photo by Caio Silveira.</figcaption></figure><p>At N26, we can spin up a new service in up to 1 hour in the production environment. You read it right. A new service with all its infrastructural dependencies provisioned and fully operational, with a dedicated database cluster and with its API accessible for authenticated requests.</p><p>In 2021, when we started to assemble the team to work in our Brazilian operation, we knew that we would need to build a robust culture and environment to match the business’ ambitions. In a crowded neobank market, being able to release new products and services quickly is vital to acquiring and retaining customers.</p><p>Our current <a href="https://news.crunchbase.com/venture/vc-funding-downturn-charts-q1-2023/">startup funding winter</a> shifted the attention to survivability and, thus, to <a href="https://sifted.eu/articles/vc-slowdown-talks">profitability</a>. Delivering fast isn’t enough anymore. Startups must be able to anticipate customers’ needs instead of using their nimbleness to experiment randomly just to discover failure retrospectively. <a href="https://youtu.be/l4TwnIsckek?t=686">Anticipation is faster</a> and cheaper than experimentation.</p><p>That’s why <a href="https://blog.eriksen.com.br/en/platform-engineering-devops-maturity">platform engineering</a> is in all the rage now. Platforms are essential to raising the productivity of product teams, letting them focus on what matters, which is how to satisfy better customers’ needs and deliver business outcomes. Robust platforms take the pain away from dealing with infrastructure by automating repetitive tasks and by dealing with cross-cutting concerns like security, compliance, and observability.</p><p>Two years later, our platform engineering strategy is paying off. We’re a high-mature DevOps organization, performing better than 97% of the 2022 State of DevOps Report respondents in the financial services industry. Our journey may provide you with interesting insights on how to bootstrap your engineering platform. In advance, you’ll need to flex your product management muscles. After that, we’ll see how N26’s platform works.</p><p>Our Software Engineers deployed to production at least once every two days (deployment frequency). Each deployment took 9 minutes on average (lead time). Only 1.2% of the deploys led to incidents (change failure rate) that had a restoration time of 21 hours on average (time to restore) — data from July 2023.</p><h3>Culture eats strategy for breakfast</h3><p>Let’s time travel again. In July 2021, when we started to lay out the Engineering strategy for N26’s Brazilian operation, we were at the peak of activity to deliver the first version of our mobile app in Brazil. Unlike the European expansion, in Brazil, we built everything from scratch. This first version would be a closed beta available only for family and friends. Our goal was to test our operation and set the groundwork to comply with BACEN regulations (Brazilian Central Bank).</p><p>You may be wondering if this is a fortunate case of a greenfield project. It isn’t. When I joined N26, all the product and engineering efforts were outsourced. We even depended on our partners’ infrastructures.</p><p>This arrangement was good enough for the first release of our app, as it was a closed beta experiment. However, it wouldn’t suit our business ambitions. In a crowded neobank market, the unique value proposition requires a dedicated staff with skin in the game to learn continuously and propose solutions to actual customers’ problems.</p><p>At the time, we were a five-person Engineering team. I set time apart to run a three-day workshop to formalize our strategy and culture. Before diving into our strategy, we <a href="https://blog.eriksen.com.br/en/n26brasil-engineering-culture">discussed our culture</a>. Defining the social game was vital to us as we were on the brink of scaling up the Engineering team for the next phase of our operation. Hiring quickly and onboarding people while speeding up productivity is a challenging feat.</p><p>While discussing our principles, we have found ourselves repeating how responsibility mattered. We wanted autonomous and responsible teams at N26. For us, teams must maintain what they deliver. This approach brings teams in contact with the operational part of their applications and the customers, both feedback loops that lead to building quality into what is delivered. This approach is known as you build it, you run it.</p><p>Other principles came naturally to us. One was that all the infrastructure should be abstracted in a platform. Another important principle was to use proven management practices, including product management and techniques, to manage our Engineering department. So, platform engineering was codified organically into our culture.</p><p>After setting our culture and with the pillars of our strategy in place, it was time to start the strategic planning.</p><h3>Strategic planning</h3><p>To start the strategic planning, I ran an Impact Mapping session. The technique is highly collaborative and consists of answering four questions: “Why?”, “Who?”, “How?” and “What?”. It’s a simple yet effective technique. Let’s learn by following our impact map.</p><p>The most important question is, <em>why are we doing this</em>? Knowing the goal lets people adapt to unforeseen circumstances. An impact map always starts with the why.</p><p>We were on the path to rapid growth. The business plan was aggressive on customer growth, and we anticipated a 20 times increase in our team, from 5 to 100 people<a href="https://blog.eriksen.com.br/en/platform-engineering-n26#fn:business-plan">1</a> until the end of 2022. It is a massive growth in just 1.5 years. More than a robust platform, we needed excellent developer experience.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/255/0*EqbOaLz9O-JyApVQ.png" /><figcaption>Our goal was to make it virtually easy to deploy on day one.</figcaption></figure><p>Our answer to the “Why?” question was <em>to make it virtually easy to deploy on day one</em>. But before jumping into which features we needed to develop to achieve this goal, we discussed who would be impacted by this goal. Who was our customer?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*Cn1enJlFH-RyIdKv.png" /><figcaption>Our customer was the product engineer.</figcaption></figure><p>Our answer to the “Who?” question was the product engineer. It may seem odd to identify an internal customer, but at this phase, I knew we should refrain from accruing organizational debt. As Steve Blank — the Lean Startup movement’s godfather — points out, organizational debt can kill a company quicker than technical debt. Our main contribution to the business as an Engineering department was to staff the teams adequately and make them productive. The teams would contribute directly to the business by solving specific customer problems.</p><p>Then, we followed up to understand which behaviors we wanted the product engineers to have to help us achieve our desired goal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/710/0*9YVXTilDD7FNSZKI.png" /><figcaption>We wanted the product engineers to maintain what they built and to be productive on their first working day.</figcaption></figure><p>Our answer to the “How?” was twofold. First, we wanted our product engineers to be responsible for maintaining what they built. Secondly, we wanted them to be productive on their first working day. These were the impacts we desired to create. Finally, we discussed what we could do to support the expected impacts.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1naKVsPCuk55Wzqj.png" /><figcaption>Deliverables or features support impacts (click or tap to enlarge).</figcaption></figure><p>Our answer to “What?” was a list of features. But note, these features weren’t a shopping list of what we wanted to do. These were fully contextualized features aligned with the desired impacts and the business goal. The presence of non-technological features (e.g., getting started instructions and on-call documentation) makes it more evident.</p><p>With an essential part of our strategy well understood by the attendants, it was time to understand better which kind of experience we envisioned delivering to our fellow product engineers.</p><h3>Mapping the Developer Experience</h3><p>The impact map we created revealed two features that made us wonder which kind of developer experience we wanted to provide to the product engineers. They reinforced the infrastructure abstraction principle (the low-level details of the infrastructure should be abstracted for the product engineers) and the homogeneity and consistency principle that we set in our culture document.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*Kr3V0QBGCMo_KZu2.png" /><figcaption>The features that guided the mapping of the developer experience.</figcaption></figure><p>So, we started discussing the vision we had for the platform. We wanted to provide an experience that would let product engineers be productive on their first working day. We then started discussing our previous experience with environment provisioning processes.</p><p>Have you ever stopped to think about how the provisioning of new services works at your company? Is it entirely automated? How much manual work does it require?</p><p>I worked before in a neobank with almost twenty million customers and 350+ services when I joined. The few who knew the required steps of a new service provisioning were proud: it seemed like tribal knowledge. The engineering platform was incredible, but this part of the developer experience lacked self-service capabilities. I remember people saying it took at least two weeks on average to deploy a new service in production due to the amount of undocumented manual work.</p><p>But if two weeks seems too much, do you imagine waiting three months to have a working environment to deploy your service? A recent study by Rafay Systems found that one in four organizations takes three months or longer to deploy an application or service from code-complete to production. 9% of organizations take six months or longer. That’s a huge waste of resources.</p><p>A quick provisioning process seemed a good idea, as we could even deploy a new temporary service to production on the onboarding classes if we wanted to. We then mapped the journey of our product and platform engineers for the provisioning of a new service. We imagined a journey to provide a provisioning experience with the least effort possible to the product engineers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*V9khx1_k9umURc7f.png" /><figcaption>The user story map of the developer experience we envisioned creating (click or tap to enlarge).</figcaption></figure><p>What we found in our User Story Mapping session was a vision where our platform would solve this provisioning problem through extensive automation. We wanted a PaaS-like experience: product engineers would need to open a pull request with some lines of YAML code in a repository that would orchestrate the bootstrapping of new services in our cloud environment. We even discussed a draft of how this file would look.</p><p>After the pull request approval, the orchestration would prepare the production environment. We wanted it to take care of things like computer cluster management, database provisioning, setting up the messaging infrastructure, and so on. Also, we wanted the orchestration to bootstrap the project. It should create the repository of the project based on a service chassis and make the first deployment into production to guarantee the environment was configured correctly. Then, the product engineers would clone the repository of the newly created service and start working on it. Every push into the trunk branch would deploy the service into production.</p><p>With a broad overview and shared understanding of the developer experience, we were ready to dive deeper into what we needed to build.</p><h3>Planning to build less and the Thinnest Viable Platform</h3><p>Our deep dive started with the provisioning process and the service chassis as the starting point. We used the Story Workshop technique to decompose both features into three slices: good enough (what are the minimum characteristics to make the feature functional?), better (what would make it better?), and best (what would make it fabulous or ideal?). Slicing techniques help to understand the scope size and to prioritize better.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*QZyn66uInI_J6wcK.png" /><figcaption>Slicing the platform helps to prioritize the Thinnest Viable Platform (click or tap to enlarge).</figcaption></figure><p>The workshop reminded us of how complex software engineering is. We discussed simple concerns like database migrations and logging and more advanced things like circuit breakers and security on the Software Delivery Lifecycle (SSDLC). We had some idea that part of the discussed features would be required early on, like adopting the Money pattern to prevent rounding bugs in operations like installment calculation and credit financing. They’re <a href="https://www.inc.com/bill-murphy-jr/ubers-simple-math-mistake-will-cost-it-tens-of-millions-of-dollars.html">costly</a> and more <a href="https://slate.com/technology/2019/10/round-floor-software-errors-stock-market-battlefield.html">frequent</a> than we <a href="https://tecnoblog-net.translate.goog/noticias/2022/02/16/nubank-tem-bug-que-nao-deixa-transferir-r-1799-e-mais-3-valores-via-pix">think</a>.</p><p>However, we also knew we neither had enough people nor had time to build everything we wanted. That’s the harsh truth of software development: you never have enough people, time, and money to build everything you want. So, focus and prioritization are key. And that’s the strength of the Story Workshop technique, as it helps us define the Thinnest Viable Platform (TVP).</p><p>A TVP is the simplest platform you must aim to build. In some cases, the TVP may be a documentation of components or services that serve as building blocks for software development. Nonetheless, defining a TVP is important because software engineers love to build technical things, and a platform has the potential to be a never-ending journey of half-baked features. Without focus, there’s a risk of delivering a bloated platform that ignores the developer experience.</p><p>We set a goal to prioritize which features to deliver in our TVP. We wanted to create a provisioning process that could be run within a week. The initial feature set would help us build the backbone of our platform.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/260/0*B-RCT1x3wrOCL6ow.png" /><figcaption>Our first goal was to create a TPV that supported provisioning a service within a week.</figcaption></figure><p>So, we prioritized the setup of the computing cluster (Kubernetes), the orchestration automation (which we named “Project Bootstrapper”), and the first version of the service chassis. But how could someone deliver something without any kind of database support? We taught the team that they could use in-memory repositories for these purposes. Shortly after the TVP release, the platform team released the database provisioning feature. From there on, the product teams could deploy fully operational services in production.</p><p>That’s an important product management lesson for anyone doing platform engineering: your releases can solve the problem partially. Plan to build less and provide alternatives for the customers and stakeholders that they may implement while you work on the definitive solution. Alignment and communication are essential to work around temporary dependencies.</p><p>Our platform evolved dramatically since then. But every step of its progress was marked by the diligent work of the platform team, who always planned to advance the platform’s capabilities iteratively. Central to this process is the understanding of the business goals, product engineers’ needs, and regulatory requirements to prioritize features that deliver value to the company.</p><h3>How our platform works</h3><p>Fast forward to July 2023. Our platform evolved, and the orchestration makes everybody’s lives easier. To create a new service, the product engineer clones the repository that manages the infrastructure and runs a make command:</p><pre>$ git checkout -b overnight<br>$ make create-team spaces</pre><p>The command scaffolds a directory where the product engineer’s team will edit a single configuration file to bootstrap the new service. The file allows configuring things like the Service Level Objectives (SLOs) and the database cluster size:</p><pre>locals {<br>    projects = {<br>        overnight = {<br>            description = &quot;Calculate the balances&#39; CDI-indexed yield.&quot;<br>            repository = {<br>                bootstrap = true<br>                language = &quot;kotlin&quot;<br>            }<br>            service = {<br>                bootstrap = true<br>            }<br>            monitoring = {<br>                bootstrap = true<br>                error_rate = &quot;0.5&quot;<br>                read_latency = &quot;0.4&quot;<br>                write_latency = &quot;4&quot;<br>                apdex = &quot;0.94&quot;<br>            }<br>            database = {<br>                bootstrap = true<br>                instance = &quot;db.r6g.large&quot;<br>                replicas = 4<br>                engine = &quot;aurora-postgresql&quot;<br>            }<br>            queues = {<br>                bootstrap = true<br>                names = [&quot;invoice-paid&quot;, &quot;yield-calculated&quot;]<br>            }<br>            logs = {<br>                archive = true<br>            }<br>            cdn = {<br>                bootstrap = false<br>            }<br>        }<br>    }<br>}</pre><p>Then, the product engineer commits the files and creates a pull request, which the platform team reviews. We have a policy in place to prevent microservices envy. As Domain-Driven Design practitioners, we prefer to design our services around bounded contexts and split the services only after thoughtful consideration. The platform team review checks the conformity to the policies.</p><p>After the pull request is approved, the orchestration is triggered. The orchestration:</p><ol><li>Creates a service user for the application in AWS IAM.</li><li>Creates a Kubernetes service with horizontal and vertical pod autoscaler enabled.</li><li>Integrates the API Gateway with the Kubernetes ingress to expose the service’s API.</li><li>Creates an Aurora cluster in AWS RDS with horizontal autoscaling enabled.</li><li>Creates messaging queues/topics.</li><li>Creates an S3 directory integrated with a Content Delivery Network (CDN).</li><li>Stores credentials (API keys, database passwords, and so on) in the secrets management system.</li><li>Bootstraps the new service codebase using the service chassis.</li><li>Creates the new service repository in BitBucket.</li><li>Configures the BitBucket repository variables.</li><li>Creates the CI/CD pipelines.</li><li>Configures the quality and security gateway.</li><li>Runs the first deployment of the service.</li><li>Runs the first deployment of service workers in sidecars.</li><li>Creates a Service Level Objective (SLO) in Datadog.</li><li>Configures service alarms in Datadog.</li><li>Runs health checks to guarantee the provisioning worked.</li></ol><p>The service chassis is a Ktor-based opinionated framework that packages a curated set of open-source libraries and internally developed components to reduce the cognitive load on concerns like persistence and logging.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9G_Q2hqVsAH9xAr-.png" /><figcaption>A simplified diagram of how the orchestration works.</figcaption></figure><p>After the provisioning finishes, the product engineer clones the repository and starts working on the new service. The service chassis automatically generates a Docker Compose file to support local development. All projects share the same bootstrapping structure, which helps the product engineers when they switch between projects. Furthermore, less variability means faster optimization cycles for the platform engineers when enhancing the underlying tooling used by the Engineering team.</p><p>The services are also entirely instrumented. Early on, product engineers can monitor the application performance and troubleshoot issues like slow queries and low Apdex scores. Alarms are configured automatically and sent to standardized Slack channels (each team has a standard set of Slack channels, one dedicated to observability alarms).</p><p>To fine-tune the available computing capacity, the product engineer may update the configuration file to increase the number of Kubernetes pods required to run its service. The only way to set up the production environment from a product engineer’s standpoint is through this configuration file that abstracts the underlying cloud infrastructure. This guarantees that all changes to production are transparently audited.</p><p>We also have a set of things that require manual work but must follow guidelines or standards. Some guidelines have emerged from peer-reviewing processes, like the API design review. We strive to design our API semantically. Initially, we peer-reviewed changes to the API contract. Currently, the team follows the conventions that are available in a design document.</p><p>We can’t stress enough the importance of documentation. We documented the most critical parts of the product engineer journey, including the entire Software Development Lifecycle (SDLC). For example, product engineers can learn how to create new credentials and store them secretly in our cloud environment or adjust alarm thresholds by reading the documentation. Automated processes and documentation are the base of a self-service platform.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-2T2gsj4gdoAkhEI.png" /><figcaption>Summary table of the platform’s features with links for further information (click or tap to enlarge).</figcaption></figure><p>When a new person joins our team, our identity provider sends a welcome email with instructions on how to activate the laptop that is sent to the person’s house some days before their first day of work. The laptop is fully configured and updated to the latest version of the operating system and development tools. The only work the software engineer needs to do is to clone the repositories and run the starting scripts (generally Docker Compose commands) available in the README files.</p><p>To make our web-based tools readily available (e.g., Rancher, Datadog, Jira, Confluence, 1Password, Slack), we used Okta as the identity provider. With a single password, the person unlocks the laptop and access all the tools. Expanding our platform scope to issues like access management and laptop setup helped us to implement Engineering-wide changes like the rolling of tooling updates and enhancements without interrupting people to run setup wizards manually.</p><h3>Closing remarks</h3><p>Platform engineering at N26 has a long and winding road. From custom-built orchestration tools to standardization of manual processes, we found a way to make deployment virtually easy on the first day. In the same journey, we eliminated the dependency on third-party infrastructure, which resulted in an incredible drop in our API latency. The final payoff was an immense increase in developer productivity and a highly mature DevOps organization.</p><p>The main takeaway is to manage your platform strategically. There is much more to build than enough people, time, and money. A product mindset is paramount. Take advantage of available tools, especially open-source tools, to cut out scope. Focus on the developer experience you want to deliver and the outcomes your company pursues. Invest in building a resilient team and a developer experience that enables it to anticipate customer needs.</p><h3>Acknowledgments</h3><p>The platform engineering journey described here was possible due to the efforts of many people. Our strong foundation was born from the minds of seasoned professionals. Antonio Spinelli, Henrique Sloty, and Thiago Costa contributed heavily to strategic planning. All of them worked on the first features of the platform before moving on to work as the first engineering managers of the company.</p><p>Henrique Sloty has been managing the Engineering Platform area since the release of our TVP. Abner Maioralli joined the team and worked as the Technical Product Manager, supporting the planning, discovery, and communication processes. Although not discussed in this article, we also have a platform for mobile software development. Matheus Schmidt and Lucas Calandrine are the minds behind this platform.</p><h3>References</h3><ul><li><a href="https://blog.eriksen.com.br/en/n26brasil-engineering-culture">Building an Engineering culture</a></li><li><a href="https://blog.eriksen.com.br/en/platform-engineering-devops-maturity">Platform engineering: capabilities, roles, and its benefits for DevOps maturity</a></li><li>Crunchbase. Christine Kilpatrick, 2023. <a href="https://news.crunchbase.com/venture/vc-funding-downturn-charts-q1-2023/">The Party’s Still Over: The VC Downturn In 6 Charts</a></li><li>Sifted. Aruni Sunil, 2023. <a href="https://sifted.eu/articles/vc-slowdown-talks">The VC slowdown: Is it set to get even worse?</a></li><li>David Anderson, 2022. <a href="https://youtu.be/l4TwnIsckek?t=686">Fit for Purpose book tour presentation</a></li><li>Gojko Adzic, 2012. <a href="https://www.amazon.com/Impact-Mapping-Software-Products-Projects/dp/0955683645">Impact Mapping</a></li><li>Starbase. Feliz Leitmeyer, 2022. <a href="https://www.startbase.com/news/n26-will-in-brasilien-300-weitere-stellen-schaffen/">N26 plans to create 300 more jobs in Brazil</a></li><li>Etsy. John Goulah, 2012. <a href="https://www.etsy.com/codeascraft/making-it-virtually-easy-to-deploy-on-day-one">Making it Virtually Easy to Deploy on Day One</a></li><li>Steve Blank, 2015. <a href="https://steveblank.com/2015/05/19/organizational-debt-is-like-technical-debt-but-worse/">Organizational Debt is like Technical debt — but worse</a></li><li>Jeff Patton, 2014. <a href="https://www.amazon.com/User-Story-Mapping-Discover-Product/dp/1491904909">User Story Mapping</a></li><li>Rafay Systems, 2023. <a href="https://rafay.co/wp-content/uploads/2023/03/Rafay-EB-Environment-Provisioning-Survey.pdf">Environment provisioning for application development &amp; delivery survey</a></li><li>Inc. Bill Murphy Jr, 2017. <a href="https://www.inc.com/bill-murphy-jr/ubers-simple-math-mistake-will-cost-it-tens-of-millions-of-dollars.html">Uber’s Simple Math Mistake Will Cost It Tens of Millions of Dollars</a></li><li>Slate. Lav Varshney, 2019. <a href="https://slate.com/technology/2019/10/round-floor-software-errors-stock-market-battlefield.html">The Deadly Consequences of Rounding Errors</a></li><li>Tecnoblog. Pedro Knoth, 2022. <a href="https://tecnoblog-net.translate.goog/noticias/2022/02/16/nubank-tem-bug-que-nao-deixa-transferir-r-1799-e-mais-3-valores-via-pix">Nubank has a bug that prevents you from transferring R$ 17.99 via Pix</a></li><li>Martin Fowler, 2005. <a href="https://martinfowler.com/bliki/InMemoryTestDatabase.html">InMemoryTestDatabase</a></li><li>ThoughtWorks Technology Radar., 2015. <a href="https://www.thoughtworks.com/radar/techniques/microservice-envy">Microservice envy</a></li><li>Microsoft. Will Tsay and Aaron Crawfis, 2023. <a href="https://cloudblogs.microsoft.com/opensource/2023/10/18/enabling-developer-collaboration-with-radius/">Enabling developer collaboration with Radius</a></li><li>Microsoft, 2023. <a href="https://radapp.io/">Radius</a></li></ul><p>Originally published on my <a href="https://blog.eriksen.com.br/en/platform-engineering-n26">website with further notes</a> on Oct 31, 2023.</p><p>This article is part of a two-piece series on platform engineering. The first piece explains <a href="https://blog.eriksen.com.br/en/platform-engineering-devops-maturity">platform engineering and its capabilities, roles, and benefits for DevOps maturity</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8c81ef1b6a51" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Platform engineering: capabilities, roles, and its benefits for DevOps maturity]]></title>
            <link>https://medium.com/@eriksencosta/platform-engineering-capabilities-roles-and-its-benefits-for-devops-maturity-a53648e09087?source=rss-d6f3dc98bdc4------2</link>
            <guid isPermaLink="false">https://medium.com/p/a53648e09087</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[team-topologies]]></category>
            <category><![CDATA[developer-experience]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[Eriksen Costa]]></dc:creator>
            <pubDate>Tue, 07 Nov 2023 02:34:54 GMT</pubDate>
            <atom:updated>2023-11-07T02:46:27.283Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7LcnypBRRlWptbAIFgNDhw.jpeg" /><figcaption>platform /ˈplatˌfôrm/ • <em>noun</em> • a standard for the hardware of a computer system, determining what kinds of software it can run. Photo by Alice Yamamura.</figcaption></figure><p>Imagine you work in a modern technical environment, be it a startup or not. It’s Wednesday, and you’re ready to release a much-waited feature to the customer base.</p><p>You and your team then start checking out item by item of the release plan. You then check the last one just after switching on the feature flag. Now, it’s time to monitor the customers using the feature.</p><p>Some minutes later, you spot some warnings in the observability tool. You investigate the issue while the CX personnel open tickets with customer complaints. You check if the number of running Kubernetes pods is healthy and see that the cluster is starting more pods to cope with the load increase caused by the spike of errors. The database load is adequate, but the dead letter queue accumulates messages in a repeated pattern.</p><p>You add some extra lines to log what is happening. You copy and paste error-handling code from another project using the same programming language used by your microservice project. Then, you commit the code and wait while the CI/CD tool deploys it to the cluster.</p><p>Later on, you find that the access policy of the production environment is stricter than the sandbox environment. It seems the service isn’t able to publish messages to a secondary queue, which is used to eventually migrate required data for the new feature to work with a specific segment of the customer base. It isn’t working because you didn’t follow the naming rules.</p><p>You then decide to rename the queue by changing some lines of Terraform code and submit it to the approval of the Infrastructure team. Once approved, you redeploy the service with the fixed queue name, and everything starts working as expected. You’re happy because you solved the incident in under a couple of hours but also frustrated with how social media complaints overshadowed the launch campaign. Besides all, you all felt overwhelmed.</p><h3>You build it, you run it</h3><p>Our introductory tale has shown many attributes of companies running modern technical environments and practices. The team was able to deliver software using automated processes and was also able to set up the production environment by making changes to Terraform, an Infrastructure as Code tool. The Operations are available as a self-service, automated, and on-demand available dependency. A DevOps culture is established.</p><p>Besides DevOps, the team developing this feature is fully responsible for its software’s operations. They monitor it actively and immediately act when things go wrong since smooth operation is the top priority. Investments are made in quality to lower the maintenance burden.</p><p>The team owns the entire product cycle. The team creates a sense of how regular operation feels by working over the whole software development lifecycle (SDLC). Also, it can understand better how customers react to changes by correlating operational (application telemetry) and business metrics (KPIs, health indicators, and improvement drivers). This company adopts the “You build it, you run it” (YBIYRN) approach.</p><p>However, even with these practices, our tale spots hardships common even in highly mature DevOps organizations. The lack of a comprehensive engineering platform increases cognitive load, affecting productivity. Let’s understand what is the cognitive load before discussing platform engineering.</p><h3>Cognitive load</h3><p>Have you ever felt mentally exhausted after learning something new, like a new language, technology, or a different way of working? While learning, have you ever felt tempted to check a notification on your mobile phone?</p><p>That’s the forces of the different cognitive loads acting on your cognitive system. The Cognitive Load Theory was introduced in the 1980s to explain how our learning ability is heavily constrained by our working memory. Learning is a process that requires our cognitive system to process information in the working memory and then store it in long-term memory.</p><p>However, the working memory is highly constrained in capacity and duration and only holds information briefly. The exception is when the working memory deals with abilities previously learned since it retrieves information from long-term memory. That’s why while you’re learning something new, you practice it until you do it automatically. You experienced it many times in your life while learning to speak, read, write, dance, you name it.</p><p>The sensory memory filters out most of the incoming information. Learning is the act of encoding new schemas in the long-term memory.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/0*wXlZAvgO_RAs-r7k.png" /><figcaption>The sensory memory filters out most of the incoming information. Learning is the act of encoding new schemas in the long-term memory.</figcaption></figure><p>Understanding the kinds of cognitive load is vital to designing an environment that prioritizes learning by adjusting the load on the working memory:</p><ul><li>Intrinsic Load is imposed by the complexity of the information and the previous expertise of the person in the subject matter. That’s why we break down projects into smaller deliverables since building something by joining simpler parts is more manageable</li><li>Extraneous Load is also known as ineffective load. It diverges cognitive resources to irrelevant activities that do not contribute to learning. That’s why we must create workplaces that allow people to focus by diminishing distractions and improving processes</li><li>Germane Load is the effective load imposed on the working memory by the process of learning. Transferring information from the working memory to the long-term memory requires effort. This effort is the Germane Load. In the workplace, this happens when discovering how to solve a (business, customer, programming) problem</li></ul><p>Extra Intrinsic and Extraneous Load must be eliminated or minimized to optimize learning. Back to our tale, we want more time for the team to learn: did the new feature create value for the customers? What should we optimize based on the gathered feedback? Working on these things is more valuable than fiddling with infrastructure configuration. Providing an engineering platform is critical to increasing Germane Load by working on value-adding activities.</p><h3>Platform engineering</h3><p>Platform engineering is an emerging practice that improves the developer experience and productivity by providing a compelling integrated product — an engineering platform — that will reduce cognitive load by delivering self-service software engineering capabilities.</p><p>Put simply, this platform will package everything from developer tools to processes and standards. Imagine, for example, that the team in our introductory tale works in a fintech startup, and their working domain deals with calculating installment payments. What happens when you divide USD 100 into three equal installments? You get three installments, each one valued at USD 33.33. Where’s the missing cent?</p><p>No penny must be lost when doing monetary calculations. It may seem silly, but rounding errors cost <a href="https://www.inc.com/bill-murphy-jr/ubers-simple-math-mistake-will-cost-it-tens-of-millions-of-dollars.html">Uber tens of millions of dollars in 2017</a> and <a href="https://slate.com/technology/2019/10/round-floor-software-errors-stock-market-battlefield.html">devalued a Canadian stock index by 50% in 22 months</a>. So, instead of leaving each team in this startup to repeatedly program code that does monetary calculations, a single library must be provided to do it for them.</p><p>If monetary calculations seem an obvious example, we can move on to compliance issues. Have you ever had problems complying with GDPR-like privacy laws? Imagine the team from our tale wrongly logging Personal Identifiable Information (PII) like the social security number or credit card for debugging purposes. Now you have in your log history data that shouldn’t be there.</p><p>The solution is implementing ways to deal with PII in the engineering platform, preventing them from leaking into the logs. The platform team can redact PII on the application level (in a service chassis) and log stream. This way, the teams are freed from remembering which data they may add to the log. If they mistakenly add anything holding PII data to the log call, they will rest assured that it won’t appear in the records.</p><p>In our example, the engineering platform improves the last-mile developer experience of the existent DevOps platform. Remember, in our tale, the team was able to provision infrastructure through self-service tools. The engineering platform in this example would also package utilitarian packages (e.g., ORMs, monetary calculation libraries) and cross-cutting concerns (e.g., logging, security, error handling) in a compelling and standardized service chassis used when bootstrapping new projects in the company.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/0*0jPIS-jFPSdMXQVa.png" /><figcaption>The team consumers the platform using self-service tools. Some services like the CI/CD, container cluster, and database may be super standardized. However, the team glues everything else, like logging, quality gateway, and authentication.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/790/0*VOWSvqaKNEYhRHMK.png" /><figcaption>The team uses a service chassis that exposes the platform’s services and features with opt-in or opt-out toggles. The platform services are standardized and consistently consumed throughout the organization.</figcaption></figure><p>With a comprehensive engineering platform like this, the company would evolve its DevOps approach. The teams could focus more on the applications they need to develop and on learning what is driving the business forward and what is solving their customer needs. They can focus on value-adding and learning activities instead of working on extraneous things (reduced cognitive load). It is worth noting that platform engineering improves productivity, leading to more motivated individuals due to better developer experience.</p><p>For me, platform engineering is an organically evolutionary step of different industry-wide experiences and adopted approaches like DevOps. Speaking of DevOps, let’s expand the relationship of platform engineering with it and how it leads to higher DevOps maturity.</p><h3>Higher DevOps maturity</h3><p>If platform engineering is an evolutionary step of DevOps and other practices, how can it help to lead to higher maturity? First of all, DevOps practitioners have been creating self-serviced platforms for the last ten years. The DevOps culture evolved into an approach where automation became self-serviced platforms managed as products. From the DevOps Handbook:</p><blockquote>Instead of IT Operations doing manual work that comes from work tickets, it enables developer productivity through APIs and self-serviced platforms that create environments, test and deploy code (CI/CD), monitor and display production telemetry, and so forth. By doing this, IT Operations become more like Development (…), engaged in product development, where the product is the platform that developers use to safely, quickly, and securely test, deploy, and run their IT services in production.</blockquote><p>Moving from the packaging of operations as a platform to the entire developer experience (i.e., packaging more capabilities in the platform, like logging, security, and error handling) means less cognitive load for the teams working on products and features. Enhanced developer experience will drive the DevOps metrics to higher levels.</p><p>Indeed, the Puppet 2021 State of DevOps Report found a high degree of correlation between DevOps evolution and the use of internal platforms: 48% of the highly mature organizations used internal platforms against 25% of the mid-level group, and only 8% of the low-level group.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/425/0*qrmaQKRmF33LWTF1.png" /><figcaption>High performers use more internal platforms compared to mid-level and low performers.</figcaption></figure><p>High performers use more internal platforms compared to mid-level and low performers.</p><p>I published <a href="https://www.linkedin.com/posts/activity-7082838172002398209-okhw">N26 Brasil DevOps Metrics on LinkedIn</a> earlier this year. We scored higher than 97% of respondents from the Financial Services industry. Our Software Engineers deployed to production at least once every two days (deployment frequency). Each deployment took 9 minutes on average (lead time). Only 1.2% of the deploys (change failure rate) led to incidents that had a restoration time of 21 hours on average (time to restore). A comprehensive engineering platform was prioritized back in the early days of our operation, contributing to developing a strong DevOps culture.</p><p>Platform engineering is an evolutionary step of DevOps. However, it requires expanding the scope of the platform to embrace the entire developer experience. Before diving into the platform’s capabilities, let’s discuss what is needed to create one. Not surprisingly, you’re going to need a platform team.</p><h3>Organizational design</h3><p>Platform engineering also has roots in organizational design, specifically after the groundwork set by Team Topologies, an approach to organize business and technology teams for fast flow.</p><p>Root to the approach is the acknowledgment that organizational design starts with a team-first mindset and that teams need to minimize the cognitive load on them by establishing good boundaries and clear responsibilities. That’s why one of the most important contributions of the approach was the introduction of its topologies and interaction modes. Discussing organization design with this precise vocabulary is refreshing. The topologies are four:</p><ul><li>Stream-aligned team: aligned to a flow of work, which is usually a segment of the business domain</li><li>Complicated subsystem team: provides libraries to stream-aligned teams that solve computationally complex problems</li><li>Enabling team: helps stream-aligned teams with specialized skills (e.g., testing, Agile practices, database management)</li><li>Platform team: provides internal services to reduce the cognitive load, freeing the stream-aligned teams to accelerate their delivery rate</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/0*ajMnmQ_5oeBYkjqg.png" /><figcaption>The four topologies.</figcaption></figure><p>The stream-aligned teams are responsible for the entire software delivery lifecycle; they’re YBIYRI teams. Engineering platforms are essential because they let teams own the whole lifecycle, eliminating handoffs and waste of manual processes. Platforms minimize the cognitive load while enabling stream-aligned teams to be fully autonomous.</p><p>Counter-intuitively, autonomy means restricting collaboration by reducing the dependencies between the teams. The approach defines three modes to understand the interaction between teams:</p><ul><li>Collaboration: working together for some time to discover new things (products, APIs, technologies)</li><li>X-as-a-Service (XaaS): one team provides something as a service to another team</li><li>Facilitation: one team mentors another team</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/399/0*dt1B1V3-dlGtkdyt.png" /><figcaption>The interaction modes.</figcaption></figure><p>Your goal should be to restrict the collaboration interaction mode to specific periods, like new business opportunities that require discovering nouveau solutions. Two or more teams will collaborate closely to define a solution. Once the solution is delivered, the relationship changes to an XaaS in an upstream/downstream perspective.</p><p>The evolving organization landscape will trigger interaction mode rearrangements that will guide the relationships between the teams of all the topologies types. But to frame an example closer to our subject, imagine that a stream-aligned team found that they would need to use some new services available in the cloud provider to implement a new feature. At this moment, changing the relationship with the platform team to collaboration mode could be helpful to understand if this new technology needs only a change in the orchestration (i.e., changes in the Infrastructure as Code tool to provision the new service) or if it is something that may be abstracted for later reuse for the other teams.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/282/0*MOFuUmtcIvF5V4uT.png" /><figcaption>A team topology with two teams in collaboration mode while consuming services from the Platform team.</figcaption></figure><p>In this setting, imagine that the platform team’s first deliverable is the provisioning of the new cloud service, freeing up the stream-aligned team to deal solely with value delivery to the end customer. After this delivery, the platform team may prioritize exposing the aforementioned service as a self-service tool or place it in the roadmap for a future release. Nonetheless, the interaction mode of both teams changes back to an XaaS mode.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/282/0*FqAJTSgprzMrN_AW.png" /><figcaption>After some time, the teams resume their relationship in XaaS mode.</figcaption></figure><p>It is worth understanding the approach before designing your teams. Also, the platform team may be composed of multiple teams of other topologies. As your organization grows, you may specialize the team in the different capabilities that compound the platform: numerous teams will work under the “platform team” or “platform area” umbrella.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/450/0*Q_zbqjboE6UCW6ll.png" /><figcaption>The Platform team may be composed of multiple teams.</figcaption></figure><p>If you’re just starting with platform engineering, I suggest having at least one platform team with Cloud Infrastructure and Software Engineers in your organization. You’ll be able to plan and build your platform’s first version, which may consist of a service chassis, CI/CD pipelines, and an abstracted self-serviceable cloud runtime. In an upcoming article, I will discuss how to plan a platform with an actual example.</p><h3>Product Mindset</h3><p>A platform can be a huge endeavor. As such, it is easy to get lost in the details and deliver something that is neither compelling nor minimizes the cognitive load of the stakeholders. Wait a minute? Stakeholders?</p><p>Building a platform means having a clear understanding of the platform’s users and their needs. As with any product, you’ll never have the time, money, and people required to build your product vision. So, platforms must be strategically managed like any other product. You’ll need a product vision and management processes like roadmapping and goal setting to align the stakeholders and communicate with them about the upcoming features and priorities.</p><p>Product management goes beyond strategic planning. The platform team needs to constantly survey users to see if the provided solutions are solving their problems. Every product must be delivered with complete support, including up-to-date documentation. Simplified onboarding mechanics should be in place to minimize manual tasks, granting a smooth self-service experience.</p><p>Starting the platform may be daunting. However, it may not need to be. You only need to discover the minimum viable product for your platform (or the shortest path to value). A handful of agile practices like Impact Mapping and User Story Mapping help you set a goal and prioritize just what is needed to deliver the hypothesized value. In an upcoming article, I will discuss how to plan a platform with an actual example.</p><h3>Roles</h3><p>You may have heard the job title “Platform Engineer” or “Product Engineer.” Translating in Team Topologies terms, the Platform Engineer works in a platform team while the second works in a stream-aligned team.</p><p>Is the Platform Engineer a different kind of engineer? What’s the difference when comparing with a Product or “regular” Software Engineer? I like to keep things simple. They’re different roles instead of job titles. A Platform Engineer will develop platform-based solutions, which other Software Engineers will use. Product Engineers will develop solutions for end users, which may be other Software Engineers if the developed product is technical (e.g., a payments API). That’s why this distinction is more about the work being done, i.e., the role, than a job title. I don’t mind.</p><p>However, job titles aside, people working on platform teams require a different mentality. First, their motivation must be aligned with the fact that a platform team delivers value indirectly to the business. They’ll help to improve the organization’s productivity and also help to lower costs and standardize compliance and security controls.</p><p>Secondly, they must know data structures, algorithms, programming languages, operational systems, databases, shell scripting, and so on. It isn’t a different skill set from a “regular” Software Engineer working in a stream-aligned team. However, they must hone their API and software design skills, delivering technical products with excellent developer experience. These products must have well-designed APIs that are intuitive and easy to use. The code must set a high bar of measurable quality and solve well-defined use cases.</p><p>People who contributed to open-source projects are great candidates to work in platform teams. The only catch is to create a mindset of solving well-defined use cases. Open-source projects may have too broad APIs anticipating an unbounded number of use cases. But as a platform is for internal use, it is better to solve well-known cases than to anticipate future needs that may never happen. For SOLID practitioners, I’m not against the Open-Closed Principle. The opposite is true: I’m in for sound design, mainly if it reflects a rich domain model.</p><h3>Capabilities of engineering platforms</h3><p>Each engineering platform will evolve differently due to the pressing needs of the organization. However, some capabilities are valuable to present in the earliest versions of your product platform. Let’s take a cue from the DevOps Handbook:</p><blockquote>By adding the expertise of QA, IT Operations, and Infosec into delivery teams and automated self-service tools and platforms, teams are able to use that expertise in their daily work without being dependent on other teams.</blockquote><p>Most internal engineering platforms already package some of the mentioned capabilities in their self-service tools. We generally see some kind of automated infrastructure provisioning that spans a working environment in a cluster like Kubernetes. The same automation typically configures the CI/CD pipeline, running the automated tests for every code commit pushed to the version control system. The same pipeline may run tools like Snyk or Sonarcloud to inspect the code quality and security.</p><p>That’s a solid groundwork. However, an engineering platform requires the delivery of an integrated product. We must integrate the entire software delivery lifecycle processes, practices, and components into a compelling product. Software Engineers are constantly working with third-party code to ease dealing with the HTTP stack, database connections, and cross-cutting concerns (e.g., logging, authentication, authorization, caching, etc.) Packaging the frameworks and libraries in a standardized services chassis creates vast benefits.</p><p>A service chassis will help you standardize practices and processes while optimizing software dependencies’ governance if you’re using a microservices approach. The teams will also benefit from an easier way to navigate between the different software projects due to the standardization. Internal mobility of Software Engineers will also be improved as the ramp-up to learn a different business context will be smoother as the software development stack is well-known.</p><p>Another benefit of this standardization is that platform teams can automate the platform further as they now control part of the application layer. For example, in our introductory tale, the platform team may fix the leaking of PII data to the log by changing the log component to redact a standardized data set. After building up the feature, the CI/CD would trigger a rebuild of every service. In a matter of minutes, the entire production environment would have a new compliance and security policy applied.</p><h3>Closing remarks</h3><p>Platform engineering is a trend with great potential for organizations willing to reach higher DevOps maturity levels. Also, it is an approach with the added benefits of improving cross-cutting concerns by packaging in compelling product capabilities like security, compliance, and observability, leading to more productive teams and motivated individuals.</p><h3>References</h3><ul><li>Richard Atkinson and Richard Shiffrin, 1986. <a href="https://app.nova.edu/toolbox/instructionalproducts/edd8124/articles/1968-Atkinson_and_Shiffrin.pdf">Human Memory: A Proposed System and its Control Processes</a></li><li>John Sweller et al, 2019. <a href="https://link.springer.com/article/10.1007/s10648-019-09465-5">Cognitive Architecture and Instructional Design: 20 Years Later</a></li><li>Slava Kalyuga, 2011. <a href="https://link.springer.com/article/10.1007/s10648-010-9150-7">Cognitive Load Theory: How Many Types of Load Does It Really Need?</a></li><li>John Sweller, 2010. <a href="https://link.springer.com/article/10.1007/s10648-010-9128-5">Element Interactivity and Intrinsic, Extraneous, and Germane Cognitive Load</a></li><li>Luca Galante, 2022. <a href="https://platformengineering.org/blog/what-is-platform-engineering">What is platform engineering?</a></li><li>Bill Murphy Jr, 2017. <a href="https://www.inc.com/bill-murphy-jr/ubers-simple-math-mistake-will-cost-it-tens-of-millions-of-dollars.html">Uber’s Simple Math Mistake Will Cost It Tens of Millions of Dollars</a></li><li>Lav Varshney, 2019. <a href="https://slate.com/technology/2019/10/round-floor-software-errors-stock-market-battlefield.html">The Deadly Consequences of Rounding Errors</a></li><li>W. Edwards Deming, 2000. <a href="https://www.amazon.com/Out-Crisis-W-Edwards-Deming/dp/0262541157">Out of Crisis</a></li><li>Patrick Debois et al, 2016. <a href="https://www.amazon.com/DevOps-Handbook-World-Class-Reliability-Organizations-ebook/dp/B01M9ASFQ3">The DevOps Handbook: How to Create World-Class Agility, Reliability, and Security in Technology Organizations</a></li><li>Nigel Kersten et al, 2021. <a href="https://www.puppet.com/resources/state-of-devops-report">2021 Puppet State of DevOps Report</a></li><li><a href="https://www.linkedin.com/posts/activity-7082838172002398209-okhw">N26 DevOps Metrics</a></li><li>Manuel Pais and Matthew Skelton, 2019. <a href="https://www.amazon.com/Team-Topologies-Organizing-Business-Technology/dp/1942788819">Team Topologies: Organizing Business and Technology Teams for Fast Flow</a></li><li>Chris Richardson. <a href="https://microservices.io/patterns/microservice-chassis.html">Service chassis pattern</a></li><li>Felipe Hummel, 2020. <a href="https://building.nubank.com.br/the-value-of-canonicity/">The value of canonicity</a></li></ul><p>Originally published on my <a href="https://blog.eriksen.com.br/en/platform-engineering-devops-maturity">website with further notes</a> on Sep 25, 2023.</p><p>This article is part of a two-piece series on platform engineering. The second piece describes how <a href="http://localhost/en/platform-engineering-n26">N26 planned a robust platform, improved productivity, and reduced costs</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a53648e09087" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building an Engineering culture]]></title>
            <link>https://medium.com/@eriksencosta/building-an-engineering-culture-af517993721?source=rss-d6f3dc98bdc4------2</link>
            <guid isPermaLink="false">https://medium.com/p/af517993721</guid>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[culture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[strategy]]></category>
            <dc:creator><![CDATA[Eriksen Costa]]></dc:creator>
            <pubDate>Tue, 07 Nov 2023 02:23:11 GMT</pubDate>
            <atom:updated>2023-11-07T02:23:11.682Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Art is a cultural phenomenon. Photo by Tim Sackton." src="https://cdn-images-1.medium.com/max/1024/1*jF0mNti1Undu1zXJ53KIMA.jpeg" /><figcaption>Art is a cultural phenomenon. Photo by Tim Sackton.</figcaption></figure><p>Culture is always a much-debated subject. Peter Drucker, the father of modern management theory, allegedly said that “culture eats strategy for breakfast”. When aligned with strategy and leadership, a strong culture leads to positive organizational outcomes.</p><p>Ashley Goodall and Marcus Buckingham say that culture matters because it contributes to identity, processes, and vision. Besides that, culture is the answer that people give when they are asked, “how is it to work there?”. Culture determines how hard people will work and how long they’ll stay in your company.</p><p>Culture matters. However, culture also may be a complicated and confusing subject. Because of that, culture is too often relegated to HR alone and treated secondarily by the business. But it is possible to run a managed process to define the culture, and it takes less effort than you imagine.</p><p>Before diving into how to do it, it’s worthwhile to understand what culture is.</p><h3>What is culture?</h3><p>Culture has some definitions. Culture is:</p><ul><li>The knowledge system of a relatively big group of people</li><li>The nurtured behavior and the sum of what a person learned, of the accumulated experience that is socially transmitted — or, to make it short — the behavior through social learning</li><li>The lifestyle of a group of people — the behaviors, beliefs, values, and symbols that they accept (generally without thinking about them) and that are passed by through communication and imitation from one generation to the next</li><li>Symbolic communication. Some of its symbols include a group’s skills, knowledge, attitudes, values, and motives. The meanings of the symbols are learned and deliberately perpetuated in a society through its institutions</li></ul><p>The definitions made it clear that culture is always a collective phenomenon. Culture defines the social game: the cultural norms define what is accepted or not in the group and direct it toward a shared purpose.</p><p>This is the first hint to manage the culture definition process. Values, direction, beliefs, and behaviors are keywords that translate well to strategic management concepts like vision, mission, and values. And it is also worth talking about principles.</p><h3>Vision, mission, values, and principles</h3><p>Any leader came across the challenges of goal setting or was questioned regarding the purpose clarity. In strategic management, the tools to work on these issues are the vision, mission, and values. I particularly like the definitions found in the book Product Roadmaps Relaunched:</p><ul><li>The vision is the outcome you seek in the long term. The vision tells us where we want to go</li><li>The mission is the intent you have right now. It’s your purpose; it’s your guide toward the vision</li><li>Values are beliefs and ideas that govern the behavior of a group of people. If the vision tells us where we want to go, the values help us to correct the course toward the vision</li></ul><p>At N26 Brasil, we decided to have a set of principles for the Engineering culture. Principles are ideas or basic rules that explain or control how something must work.</p><p>Vision, mission, values, and principles. We have enough elements to start working, right?</p><h3>Define it collaboratively</h3><p>If culture is a set of shared beliefs and myths, there is no better way to define it than collaboratively. I suggest holding a workshop with clearly defined activities. Product management techniques and Agile facilitation techniques are helpful for this. At least identify the vision and values of your culture.</p><p>At N26 Brasil, we ran this process in July 2021 when the Engineering team was only five people. We needed to create a strategy for the area, and for that, we needed to know what kind of culture we would like to nurture. Once the cultural elements were set, the roadmapping process became easier. Since then, our technical strategy has been aligned with our culture.</p><p>If you’re curious to know how to run a culture workshop, <a href="https://blog.eriksen.com.br/en/playbooks/culture-workshop">check the playbook</a> I created: it is a step-by-step guide to run a process similar to the one we ran at N26 Brasil.</p><h3>Document, share, integrate, and recognize</h3><p>When Netflix shared its <a href="https://www.slideshare.net/reed2001/culture-1798664">culture slide deck</a>, it went viral. You should do the same. The first step is to define the culture. After it is done, create a document and make it easily findable for everyone at your company. To make it more useful, provide a brief description of each identified element of the culture: they will be helpful to validate the behaviors and to give examples to everyone.</p><p>However, a shared document is not the same thing as shared knowledge. Present the culture for every hire. Repeat the cultural elements on every occasion: from the All Hands to Daily meetings, explore them to make them shared and assimilated by everybody.</p><p>At N26 Brasil, the culture is presented to everyone during the onboarding sessions. Besides that, the culture document reading is incentivized in the 30–60–90 plan that we set for new hires when they join the Engineering team.</p><p>Lastly, integrate the cultural elements in your hiring process and use good examples from the day-to-day work to recognize the people’s contribution to the nurturing of the culture. There is no recipe for success. The building of your culture will depend on continuous care and attention.</p><h3>N26 Brasil Engineering values</h3><p>I highlight some of the <a href="https://n26brasil.atlassian.net/wiki/external/35783146/NzI1MDI3NTdlY2U4NGUwNGEwMmY1NjhmMTMxYTg5MjY">values of our culture</a>:</p><ul><li>Professionalism: we are trustworthy and define high standards of behavior and execution. We care about the work, people, customers, and users</li><li>Pragmatism: we are pragmatic. We know when we reach a good enough solution preventing over-engineering and cargo cult programming</li><li>Humility: no one knows everything. Every question is a learning opportunity. Seniority is no free pass to disrespectful behavior</li><li>Collaboration: the N26 Brasil goals are more important than the individual goals. Teamwork triumphs over individual effort</li><li>Diversity: we live in a diverse society, and we’ll only be able to provide solutions for it with a diverse team</li></ul><p>The Engineering culture at N26 Brasil is still being shaped. The team grew by 400% between September 2021 and January 2022. New features are being delivered, and legacy systems are being replaced quickly. Even so, it is possible to see the values defined by that small team being said in the interviews, merged in the OKRs and roadmap, used to prioritize tasks, and in the day-to-day communication between people.</p><h3>Live the culture and be an example</h3><p>Any person acting as a leader (positional or not) must exemplify the organizational culture. As highlighted by David Anderson, the potential of an organization will always be limited by the maturity of its leadership:</p><blockquote>An organization’s maturity is limited by its leadership maturity. Business outcomes and aspirations will always be constrained by culture and values.</blockquote><p>A mature leader will always work to create alignment sense, unity, and shared purpose. A mature leader manages the culture and its identity. An immature leader is selfish, narcissistic, and manipulative. Mature leadership nurtures the culture and the identity of the organization.</p><p>Culture-building work is harsh and requires consistency and repetition. Setting the values and principles but not living them as a person in a leadership role is the first step to creating cynicism in the team.</p><p>The same is true for moments of drastic measures when some cultural elements are challenged: clarify what is happening and why some trade-offs are required. The consistency in the way you act will pay off at these moments.</p><p>Did you stop to think about our culture today?</p><h3>Acknowledgments</h3><p>I am grateful to everybody who accepted to join the N26 Brasil Tech team (Data, Design, Engineering, Product). They took the challenge of changing how people deal with money. Special thanks to the participants of the culture workshop we held in July 2021: Antonio Spinelli, Diógenes Medeiros, Henrique Sloty, and Thiago Costa.</p><h3>References</h3><ul><li><a href="https://blog.eriksen.com.br/en/playbooks/culture-workshop">Playbook: Culture workshop</a></li><li><a href="https://n26brasil.atlassian.net/wiki/external/35783146/NzI1MDI3NTdlY2U4NGUwNGEwMmY1NjhmMTMxYTg5MjY">N26 Brasil Engineering: Culture, vision, values, and principles (Brazilian Portuguese)</a></li><li>Jacob Engel, 2018. <a href="https://www.forbes.com/sites/forbescoachescouncil/2018/11/20/why-does-culture-eat-strategy-for-breakfast">Why Does Culture ‘Eat Strategy For Breakfast’?</a></li><li>Boris Groysberg et al., 2018. <a href="https://hbr.org/2018/01/the-leaders-guide-to-corporate-culture">The Leader’s Guide to Corporate Culture</a></li><li>Ashley Goodall and Marcus Buckingham, 2019. <a href="https://www.amazon.com.br/Nine-Lies-about-Work-Freethinking-ebook/dp/B07C3ZT28C">Nine Lies About Work</a></li><li>Gert Jan Hofstede et al., 2010. <a href="https://www.amazon.com.br/Cultures-Organizations-Intercultural-Cooperation-Importance/dp/0071664181">Cultures and Organizations</a></li><li>Todd Lombardo et al., 2017. <a href="https://www.amazon.com.br/Product-Roadmaps-Relaunched-Direction-Uncertainty-ebook/dp/B076VX53K1">Product Roadmaps Relaunched</a></li><li>Patty McCord, 2014. <a href="https://hbr.org/2014/01/how-netflix-reinvented-hr">How Netflix Reinvented HR</a></li><li>Reed Hastings e Patty McCord, 2009. <a href="https://www.slideshare.net/reed2001/culture-1798664">Netflix Culture Deck</a></li><li>David Anderson, 2018. <a href="https://resources.kanban.university/wp-content/uploads/2018/05/David-Anderson-LKNA18.pdf">First Who Then Why</a></li></ul><p>Originally published on my <a href="https://blog.eriksen.com.br/en/n26brasil-engineering-culture">website</a> on Feb 22, 2023.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=af517993721" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>