<?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 Alex Litvak on Medium]]></title>
        <description><![CDATA[Stories by Alex Litvak on Medium]]></description>
        <link>https://medium.com/@litvak?source=rss-b52ae9b85bc2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*oHtUM9joNXui4E1tBBln8w.jpeg</url>
            <title>Stories by Alex Litvak on Medium</title>
            <link>https://medium.com/@litvak?source=rss-b52ae9b85bc2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 03:32:15 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@litvak/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[Using heat-maps to track and improve your team’s engineering quality as a manager]]></title>
            <link>https://medium.com/swlh/using-heat-maps-to-track-and-improve-your-teams-engineering-quality-as-a-manager-b882660e0e2e?source=rss-b52ae9b85bc2------2</link>
            <guid isPermaLink="false">https://medium.com/p/b882660e0e2e</guid>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[management-and-leadership]]></category>
            <category><![CDATA[framework]]></category>
            <category><![CDATA[engineering-excellence]]></category>
            <dc:creator><![CDATA[Alex Litvak]]></dc:creator>
            <pubDate>Fri, 30 Oct 2020 04:46:24 GMT</pubDate>
            <atom:updated>2020-10-30T14:41:24.125Z</atom:updated>
            <content:encoded><![CDATA[<h3>Using heat maps to track and improve your team’s engineering quality as a manager</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vl9QLOwl9lEeju00xpd2lw.png" /></figure><h3><strong>The Problem</strong></h3><p>Recently, I was supporting a team @ Uber, which was working on a large number of products both in maintenance mode as well as in active development.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/422/1*VnBpKJBmmy2Uhj959eOBKA.png" /></figure><p>One of the key challenges while working on such a large portfolio of products, is keeping track and improving the quality of your team’s engineering practices as well as the technical quality of those products in production — the number of quality metrics and aspects you care about is multiplied by the number of products you wish to track which leads to an overload of information and prioritization hell.</p><h3><strong>The Solution</strong></h3><p>I have decided to adopt a similar approach to <a href="https://labs.spotify.com/2014/09/16/squad-health-check-model/">Spotify’s squad health check</a> with regards to engineering quality within the team — a further breakdown of one of the possible team health metrics you can focus on while utilizing their framework.</p><p>The idea behind this modified framework is as follows:</p><h4><strong>Define a set of metrics the team cares about</strong></h4><p>Those can be things such as testing quality and coverage, monitoring, logging, alerting, effective runbooks, documentation, correct architectural patterns, capacity utilization, p99 latency, availability — basically, anything the team finds important to track.</p><p>Note, that this can be a combination of qualitative / subjective metrics such as code quality, binary such as logging (is it there or not), or pure quantitative such as availability (# of nines).</p><p>Your team might also decide that qualitative metrics are not really concrete enough to track and improve, which is a valid decision, in which case a good approach would be to find proxy quantitative metrics which will provide an approximation.</p><p>For example possible proxy metrics for code quality might be:</p><ul><li># of bugs / 1K lines of code</li><li># of deployment rollbacks / month due to bugs in the code</li></ul><pre><strong>A note on trying to quantify quality:</strong></pre><pre>Measuring quality can be tricky, this is why it&#39;s important not to fall for the temptation to quantify everything, as well as blindly trying to optimize whichever metrics and thresholds we have defined.</pre><pre>Since by nature we will try to optimize for the things we are being measured on, and only those things, we might be tempted to &quot;game the system&quot; in some cases.</pre><pre>A classic example would be code coverage: when all we care about it being above the 90% code coverage metric success criteria, we might end up writing poor unit tests just to hit that mark.</pre><pre><strong>Ask yourself - is measuring this metric fundamentally improves quality or is it just measuring for the sake of measurement? </strong></pre><h4><strong>Define metric baselines &amp; north stars</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/313/1*mb2_OmfG6-Y9DencDktXHQ.png" /></figure><p>In order to fill out your heat map a simple 3-color coding is used. <br><strong>Yellow</strong> represents the baseline of your metric, the minimal acceptable version, <strong>green</strong> will represent where you want to be</p><p>at when you are done improving, and <strong>red</strong> means you are below your baseline.</p><p><strong>These definitions should be team-subjective, and are best done as a collaborative effort. Furthermore, these discussions can align the team around what is important and which elements of the quality culture we care about.</strong></p><p><strong>Yellow: The baseline or: the minimal acceptable version of that metric.</strong></p><p>For instance, a baseline for <em>documentation</em> would be — the existence of a product wiki page in the company engineering wiki which details the basic functionality of each component. Another example might be around <em>testing coverage, </em>a baseline for which might be set to 80%.</p><p><strong>Red: Your metric will get that scoring when it’s below the baseline which you have defined for the metric.</strong></p><p>Trivial examples might include the lack of a runbook, or code coverage below 80%, insufficient alerting on outages, etc.</p><p><strong>Green — Your north star. This is where we want to get to eventually after we iteratively improve the metric.</strong></p><p>This might include either a quantitate definition such as five nines of availability (or it’s alternative binary version of: meeting/not meeting SLAs), or a qualitative definition such as:</p><pre>The runbook contains mitigation strategies for all possible alerts in all possible service endpoints. Each mitigation strategy contains a link to the right monitoring dashboard, and a step by step guide on how to resolve the incident. </pre><p>Having said that, as nothing is ever perfect, you might decide to tune down your acceptance criteria of the north star, and define thresholds after which the metrics will get the <em>green </em>coding.</p><h3>Tracking</h3><p>After filling in the metric values for each product or service your team owns, your final heat map might look something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/562/1*gXpihy8YuoLu38-NRp7JqQ.png" /><figcaption>An example engineering quality heat map</figcaption></figure><p>The heat map provides a high level overview of how your team is doing both per product but also per metric.</p><p>Looking at <em>rows</em> will help you identify <strong>products which are neglected across many/all metrics</strong>. For example in the above heat map, we can clearly see that products 3 and 6 suffer from low quality and should be addressed.</p><p>Looking at <em>columns</em> will allow you to identify <strong>cross product issues.</strong><br>For example, in the above heat map, we can clearly see that <em>telemetry</em> and <em>testing</em> quality are pretty bad across the board.</p><p>These issues should be vertically addressed, and a strategy should be drafted on a team level.</p><h3>Improving</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/259/1*xiQGNyc8jukb7CjEn931Ug.png" /></figure><p>The heat map is helpful in tracking specific product/service quality issues, as well as quality issues which cut across many products. But how about actually improving those metrics?</p><p>There is no rigid guideline here, as each team have their own way of tackling engineering / tech debt. Some will devote 20% of their sprint time, some will run specific “tech debt sprints” once in a while, and some will also incorporate engineering improvements into their product development cadence.</p><p>In the scope of quality improvement, the tool mainly helps with <strong>prioritization</strong> and <strong>understanding where are your immediate gaps</strong> — those could be translated into tasks which will then be incorporated into a sprint / kanban board or any other work tracking method — For example, our team decided on tackling red metrics across products, meaning — identify low quality metrics and fix those for all the team’s products at once. Your team could go by fixing all red “cells” first — regardless of product or metric, and then moving on to yellows, etc.</p><h3>Final words</h3><p>This framework should act as a high level map, a visualization and a prioritization tool, and should represent holistically both the cold hard quantitative aspects of your work (i.e SLAs) but also a general qualitative feeling the team has towards their work.</p><p>Hope this will help you improve your team’s engineering quality and extract signal from noise, good luck!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b882660e0e2e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/swlh/using-heat-maps-to-track-and-improve-your-teams-engineering-quality-as-a-manager-b882660e0e2e">Using heat-maps to track and improve your team’s engineering quality as a manager</a> was originally published in <a href="https://medium.com/swlh">The Startup</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Things I learned managing engineering in a satellite office]]></title>
            <link>https://medium.com/hackernoon/things-i-learned-managing-a-remote-software-engineering-team-b8f7cd7bc58?source=rss-b52ae9b85bc2------2</link>
            <guid isPermaLink="false">https://medium.com/p/b8f7cd7bc58</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[remote-management]]></category>
            <category><![CDATA[engineering-management]]></category>
            <category><![CDATA[remote-engineering]]></category>
            <category><![CDATA[leadership]]></category>
            <dc:creator><![CDATA[Alex Litvak]]></dc:creator>
            <pubDate>Tue, 17 Jul 2018 00:28:55 GMT</pubDate>
            <atom:updated>2020-10-29T17:15:01.741Z</atom:updated>
            <content:encoded><![CDATA[<h4>Tips for the day-to-day life in a long distance (work) relationship</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wSwD4-TEP16wDeWaZiqWyw.jpeg" /></figure><h3>Introduction</h3><p>Two and a half years ago, my wife and I sold all of our stuff, said goodbye to our families and friends; we packed 4 suitcases, grabbed our dog, and moved our lives towards a new adventure across the ocean.</p><p><a href="http://www.fiverr.com/">Fiverr</a>, the company I was working for over 2 years prior to this adventure, decided to open a second, remote software engineering site in New York City, and as part of this decision, I relocated to lead the software engineering group, which was assembling there.</p><p>The company already had a pretty established software engineering organization in Tel Aviv, Israel, with tens of engineers, a robust development department, a platform engineering team and a mature engineering culture to facilitate its growth.</p><h4>Why another site?</h4><p>The reasons for opening a second software engineering office can vary, but in general, having a remote site can be a great thing, both for the company and for its employees.</p><p>Firstly, the company can tap into the local talent and enjoy a diversity of cultures, perspectives and backgrounds — something that can improve and strengthen the engineering culture.</p><p>Secondly, it can enjoy a longer working schedule. For example, in our case, a TLV + NYC team works around 16 hours a day, across 2 time zones and has one extra day (Friday) of work every week. Needless to say, that longer coverage gives the organization not just the advantage of a faster Time-To-Market, but also the ability to respond to crises on time.</p><p>Thirdly, sometimes (as it proved itself in the case of Fiverr), adding software teams to support the local efforts in the local office, can create a better synergy. Fiverr’s category management, corporate marketing and business development teams were in our NYC office from day one, and empowering those, with a software department right in their time zone, proved very efficient.</p><p>For engineers, both in the HQ, the new remote site and the ones relocated to pioneer it, a remote site offers the opportunity to experiment on a global culture of software <a href="https://hackernoon.com/tagged/engineering">engineering</a>, as well as allows one to travel and feel part of something bigger and greater.</p><p>However, as with anything good, globally distributed engineering teams have their downsides. As time passes, running 2 teams in different time zones, with the various communication challenges, overlapping responsibilities and domains and collaboration overhead, can become challenging, both to the HQ and especially the remote team itself.</p><p>In this post, I will summarize everything I’ve experienced and learnt from managing a remote software engineering team — the things you absolutely have to invest in, and the things to avoid; I hope this will be helpful to anyone in a remote leadership role.</p><h3>Tips for efficient management of a remote software engineering site</h3><h4>Brand yourself internally</h4><p>One of the first important things you have to define for yourself, but also to constantly communicate internally within the engineering organization, is what makes you special.</p><p>What is your unique positioning within the engineering team, and the different scopes and domains the teams works on. It’s important to thoroughly consider, what “chunk” of the product or tech your remote team will be responsible for — ideally, it should be something very secluded with no collaboration overhead with HQ — remember, you are just testing the waters, start small and increase the scope of your domain.</p><p>When you define this unique positioning — never stop to communicate about it and constantly remind other engineers why they have to invest the time and energy in putting out the extra effort to work with you, even when you are remote.</p><p>Internal branding is not just for engineers in HQ to know you; it’s also to give a better self-definition for the engineers in your remote site — they have to feel that their workplace is not just an “extension” of a larger organization, and that it has its own unique culture and importance.</p><h4>Brand yourself externally</h4><p>One of the biggest challenges I faced when bootstrapping a new remote site, is the clean slate I had to start with in terms of the recognition of who/what is Fiverr and why would engineers want to work here.</p><p>In Tel Aviv, although surrounded by big names such as Google, Amazon and Facebook, Fiverr is positioned as a desired and popular workplace.</p><p>Arriving in NYC made me realize, that in the US job market, Fiverr is not a familiar “workplace brand”, and a lot of the work that had to be done when hiring here, was focused around creating the right selling point, and getting the buzz going.</p><p>How to do that? There are many options to consider. Here are a few:</p><ul><li><strong>Tap into the local developers’ community </strong>— attend local meetups and mingle, possibly offer your space to host some relevant meetups as well.</li><li><strong>Encourage your developers to present in meetups </strong>— highlight some interesting key technologies you are working with and don’t forget to mention you are also hiring at the end of the presentation</li><li><strong>Create a profile in some local startup guides</strong>. Those guides are very effective in generating content about your startup, and creating a buzz. You will soon be published in articles such as “10 best startups to work for in NYC”</li><li><strong>Build the right selling point when talking with candidates</strong>. Focus on the uniqueness of working in a remote “second” site — autonomy and “get things done” atmosphere of a small startup. with the financial backup of a big company.</li></ul><h4>Think about who you hire</h4><p>Getting people to join your remote team is not enough — it is paramount to hire developers with the right mindset and attitude.</p><p>Working in a remote office brings with it lot’s of challenges for developers starting with remote communication.</p><p>A great deal of expectation matching has to be done starting the interviewing phase — explaining what will be the day-to-day of a developer in your team — how much will he/she be required to collaborate with the HQ, how many calls a day are usually required to effectively sync?</p><p>A developer onboarding a remote team must possess great communication skills, a positive attitude, and patience. I cannot stress this enough — patience is tremendously important here — things which usually can be resolved by jumping by a colleague’s desk and nudging her about a PR she has been postponing and is blocking your work will sometimes take days in an inefficient remote collaboration (but on that — in a bit).</p><p>Lastly, hire independent, self-taught and “go-get-it attitude” engineers. This is of course true in general, but being remote, also brings challenges of knowledge transfer and lack of quick problem solving — you cannot get devops to quickly fix an issue with your deployment, you will have to probably do it yourself, you probably won’t get a fast ad-hoc advice from the SRE guru of the company — you will have to resolve that service monitoring issue you are debating about, yourself as well.</p><h4>Become independent but invest in relationships</h4><p>I’m a big fan of <em>“Loosely coupled, tightly aligned squads” philosophy</em> — a term coined by Spotify to describe one of the key elements of their engineering culture.</p><p>Our structure @ Fiverr, resembles this in a lot of ways — we call our teams ‘task forces’; they are cross-functional, and are autonomous — having their own tech and product vision.</p><p>This autonomy allows our task forces to run independently as mini startups inside a larger organization. Having this autonomy, makes teams run faster, and be more motivated. You can probably imagine how this autonomy is important when talking about remote teams.</p><p>I invested a ton of my time, to draw and discuss borders, boundaries, ownership swaps, domain transfers, technical handoffs, breaking of services into separate micro-services, splitting monitoring boards and discussing product vision and mission for the various teams — all for the purpose of creating autonomy. This would allow our remote site to run fast and create impact without waiting for an approval of a co-owner on the other side of the ocean, or some technical blocks from the platform engineering team in TLV.</p><p>Achieving this is not the end goal for a remote engineering team. Simply put — you don’t want to become a technical and product island. Cross pollination is important, especially for a creative team; moreover, collaboration with the teams in HQ is important — once independence is achieved, a strive for mutual technical ownership, or development of a mutual infrastructure that is needed by teams in your remote site and in HQ can be effective in strengthening the working relationship between teams, but as said before — this collaboration should come from a choice and not the lack of it.</p><h4>Communication quality is key.</h4><p>I’ve come to the understanding, that the quality of communication, both physical — the equipment you use, and mental — the quality of the process you define between HQ and the remote site, is what will determine the day-to-day level of happiness in your team.</p><p><strong>Invest in the physical equipment you use on both ends</strong> — it’s really important for your remote team to be able to feel an equal part of any discussion or meeting they were invited to.</p><p>There is nothing more frustrating than not being able to express your thoughts and opinions in an all-hands gathering where you cannot see or hear the other side well enough. This situation impacts the will of your team to collaborate. Insist both in your office, and HQ that the level of equipment is satisfactory.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F9YOEEpWAXgU&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D9YOEEpWAXgU&amp;image=http%3A%2F%2Fi.ytimg.com%2Fvi%2F9YOEEpWAXgU%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/800591d99bb50ea35d9ab688c80c0c4b/href">https://medium.com/media/800591d99bb50ea35d9ab688c80c0c4b/href</a></iframe><p><strong>Create a remote-meeting rules of engagement</strong></p><p>Imagine a hot topic being discussed in a room full of passionate colleagues. There will probably be little to no order going on, and people will eventually start yelling their opinions, interrupting other colleagues mid-sentence and even side track to other internal discussions.</p><p>This, on its own, is not perfect, and will most often lead to zero results, action items or decisions, but you will probably not avoid unstructured discussions in a meeting all together.</p><p>The problem starts where there are 2 sides in the meeting, conversing over video chat / phone (less likely nowadays). Ever tried having an unstructured meeting like that? It’s just not possible.</p><p>An easy thing to solve this, but actually really hard to follow, is a simple rule of engagement when having a remote discussion — pick an object, could be something present in the meeting room like a whiteboard marker. From now on, only the person holding the marker is allowed to speak. If someone wishes to speak after him, they need to ask for the marker first. This creates a passable token, which allows the meeting to gain more structure. I would lie if I tell you this always works, but it’s something to try out.</p><h4>Create remote rituals</h4><p>I usually try avoiding cross-site projects, since they are hard to manage.</p><p>I believe that if a project has to be done cross-site, it was either not well-defined ownership-wise, too big or sometimes just inevitable like a company-wide initiative.</p><p>When you have to collaborate on a cross-site project, the best thing you can do is create rituals around that process.</p><p>Create daily all-hands sync meetings, like a morning standup, especially for this project- make everyone over communicate about any small details — it’s better to hear things twice than not hear them at all.</p><p>Ensure the same roles in the teams have frequent one-on-ones. For example — 2 team leads from both ends going over the detailed plan of execution, or 2 frontend engineers discussing if the integration patterns they implemented are according to the defined protocol.</p><p>Open a mutual slack/hipchat/whatever communication tool you are using in your office channel, etc.</p><h4>Celebrate Success globally</h4><p>When your team creates impact — whether a feature goes live, be it a successful AB test, a new infrastructure being implemented or you just had a very interesting user testing session with local users — make sure these successes are communicated across the company.</p><p>Here at Fiverr, we have official all-hands meetings for all of the software teams, as well as the full production team including the product managers, BI analysts, etc. This is a great opportunity for people to share victory, “brag” and discuss their success.</p><p>Celebrating success for your remote site together with the whole company will help you improve your internal brand, as well as strengthen the relationships your team members create with other remote colleagues.</p><h3>Conclusions</h3><p>As companies become more global, more engineering teams will go down the pass of expansion to remote sites, which brings a lot of advantages but, as we have seen, a lot of challenges.</p><p>Mastering the way you manage your relationships with the main site, internal and external team branding, effective communication and smart hiring are key to successful long lasting remote engineering teams.</p><p>I hope this short list of important things will be helpful to any current or future engineering leader in a remote site <a href="https://hackernoon.com/tagged/management">management</a> position .</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fupscri.be%2Fdde502%3Fas_embed%3Dtrue&amp;dntp=1&amp;url=https%3A%2F%2Fupscri.be%2Fhackernoon%2F&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=upscri" width="800" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href">https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b8f7cd7bc58" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/things-i-learned-managing-a-remote-software-engineering-team-b8f7cd7bc58">Things I learned managing engineering in a satellite office</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fiverr’s Microservices Evolution — Part 2]]></title>
            <link>https://medium.com/fiverr-engineering/fiverrs-microservices-evolution-part-2-7bbcd6ceabda?source=rss-b52ae9b85bc2------2</link>
            <guid isPermaLink="false">https://medium.com/p/7bbcd6ceabda</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[event-sourcing]]></category>
            <category><![CDATA[apache-kafka]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[cqrs]]></category>
            <dc:creator><![CDATA[Alex Litvak]]></dc:creator>
            <pubDate>Tue, 13 Feb 2018 01:58:40 GMT</pubDate>
            <atom:updated>2018-02-14T02:49:06.647Z</atom:updated>
            <content:encoded><![CDATA[<h4>From a Service-per-entity to well defined bounded contexts, Data transportation using strongly typed state change events &amp; persisted streams.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fI1FMiDqfWiho9EolsMrLA.jpeg" /></figure><h4>A Recap</h4><p>In <a href="https://medium.com/fiverr-engineering/fiverrs-microservices-evolution-part-1-ee366bd0b420">Part 1</a> we discussed how we embarked on the long journey to re-architect our backend platform from a ruby on rails monolith into an ecosystem of microservices we call chimeras — a two-headed beast for synchronous fetching of data, and asynchronous write operations using a messaging queue.</p><p>Our first evolution of the platform, as described in the first chapter, eventually looked something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/771/0*6DBPCdPtYT00Pwpy." /></figure><h3>New Challenges</h3><p>As we moved to a more scalable, decoupled, and stable architecture with the help of microservices, new challenges became evident. <br>A more complex design, with substantially more moving parts and significantly harder to grasp integration patterns, brings new problems and paradigms to the table.</p><p>Let’s dive deeper into some of the problems we encountered and their solutions.</p><h4>A-Service-Per-Entity</h4><p>After the introduction of the chimera, our version of the microservice, we started encapsulating different aspects of the system, starting with our basic entities, and created services such as <em>users_chimera</em>, <em>gigs_chimera</em> and <em>orders_chimera — </em><strong><em>a service for every entity approach.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/535/1*-_O-ptqbwOQOowCQqR0Btg.png" /></figure><p>The service-per-entity approach is natural to start with. It’s easy and intuitive to start breaking the MVC monolith but its M — the model , but with time, those services loose their cohesiveness since they start encapsulating and being coupled to, all the various features that are being introduced to the platform and the data those features require.</p><p>Furthermore, in many cases, a model can play different roles, in different domains, owned by different teams.</p><p>For example — our gig requirements entity which is <strong>defined</strong> as part of the Gig management process and owned by our sellers team, and which is being <strong>answered</strong> as part of the ordering process, owned by our buyers team.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/609/0*2JGzyJU3bcq80I78." /></figure><p>Encapsulating the gig requirements entity in a service managing it, created team coupling, lack of clear ownership of the service, and lack of cohesiveness — the service manages both contexts under it’s API.</p><p><strong>So, how should have we structured our services?</strong></p><p>Taking ideas from DDD — Domain Driven Design, and more specifically — the definition of a <a href="https://martinfowler.com/bliki/BoundedContext.html">bounded context</a>, we started adding services that were focused on business activities and well defined cohesive boundaries rather than data:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UbLQ1lrdBviTKY3d." /></figure><p>Those services had a better defined set of CRUD API, correlating to the same set of features / flows.</p><p>Structuring our chimeras around business flows and not separating them by data, made us confront a basic tradeoff — our chimeras needed to share data. As in any e-commerce platform, most of our business services had to access the holy triplet of marketplaces — the User-Order-Product data set.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*egv4D8XekqWY8ca4." /></figure><p>So, not just that each service needed access to one or more of those core entities, most of them required some sort of an intersection or union of these.</p><p>Sometimes, chimeras would require not only the shared core dataset, but actually data that is being owned byanother chimera, under a different business process — a situation that would in most cases lead to inter-team dependencies.</p><p>Imagine a situation where the recommendations team is working on a new skill based algorithm, that will recommend new services to buyers based on the skills of the sellers they previously bought from.</p><p>To accomplish this, the recommendations team will need to:</p><ol><li>Create a new route in the seller profile chimera owned by the seller team</li><li>Open a pull request for that change and wait for the sellers team to review it.</li><li>Coordinate with the sellers team indexing of the seller skills MongoDB database by skill rather then by seller id.</li><li>Monitor and cater for any performance degradations caused by the extra indexing or load on the seller skills database and seller profile services during the offline batch run of the recommender.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/796/1*ViJhIZ0bQcL5VoCnqu1EfQ.png" /></figure><h3><strong>How would we solve the data sharing problem?</strong></h3><p>We had two major goals:</p><ol><li>Find an easy way for our microservices to share data.</li><li>Keep the microservice boundaries, encapsulation of internal state, and logic.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/316/1*XkxJQPXD0IH39Jl8pOKjRQ.png" /></figure><p><strong>Sharing a database</strong></p><p>Sharing data between services could have been done by simply <strong>sharing database reads and writes</strong>, but as mentioned, this was an anti pattern we wanted to avoid, as it creates coupling between our services, just on the database level — sharing of</p><p>queries load, altering mutual data, etc.</p><p>The general approach we wanted to undertake, was that each microservice still owns its own storage.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/342/1*ijcZpT1SyUnD8023UkXdLw.png" /></figure><p><strong>Pull data, Push Commands</strong></p><p>requesting data ‘on-demand’ whenever we need it by a service call. Caching it locally if needed.</p><p>If we need to direct an operation in another chimera, we will explicitly call that chimera — “Do this!” approach.</p><p>Problems with this approach —</p><ul><li>Service A needs to change because of changes in service B.</li><li>Recovering from timeouts and transferring large amounts of data over HTTP are not easy tasks.</li><li>“Do this” instead of “Something happened” — service needs to be aware of downstream consumers.</li><li>If we cache fetched data locally — can cause data corruption over time.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/362/1*k2IG6OXuPj593NWyvaB2jQ.png" /></figure><p><strong>Event Driven</strong> — each microservice publishes the changes that are happening within it’s domain, using domain-events, and have other microservices subscribe to those events and copy the shared data to their local storage.</p><p>We already were using domain events sent from chimeras, so the approach worked naturally for us. We would pass the data in the event payload (for example the order attributes inside an <em>OrderCreated</em> event) and store it locally in the consuming chimera.</p><p>Although this solution seems like the best fit so far, it lacks a single point of truth — each service holds its copy of the data, and there is no history of the messaging throughout time — leaving room for data corruption — with no actual way to restore the state of each local data storage without querying directly the chimera which generated the data.</p><p>To demonstrate this problem, let’s go back to the CQRS scenario <a href="https://medium.com/fiverr-engineering/fiverrs-microservices-evolution-part-1-ee366bd0b420">from chapter 1</a> — when a bug is introduced to the analytics chimera code — and the order stats that are calculated are somehow corrupt — our only way to restore the data would be to run a fix script that will query our “write side” database and reconstruct our stats data locally.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/885/0*leDT6576MI65snkq." /></figure><p>Building on top of our current event driven architecture, we started looking into centralized <strong>persisted</strong> stream of events to be able to have</p><ul><li>One source of truth</li><li>The ability to have a history of all events and replay them if needed</li></ul><p><strong>The solution that inspired our next service-data integration pattern was that of a centralized stream of events with the usage of </strong><a href="https://kafka.apache.org/"><strong>Kafka</strong></a>.</p><p>Kafka’s advantage over RabbitMQ in this scenario, is that it’s a persisted pipe — all messages sent to it are stored forever, thus it stores the entire history of data sent, and acts as a single point of truth in the system — solving the data corruption issue we might encounter using RabbitMQ — events can be replayed at any given point to reconstruct the local database of a consumer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/942/0*MjSgxxerRgm--3v2." /></figure><p>The idea behind the simplicity and efficiency of using a distributed log such as Kafka for our services data integration is the following:</p><ul><li><strong>Storage + Messaging that scales without issues of mutability</strong> — imagine a queue where data is just being added, <strong>you cannot alter any historical data, but only add the last change that occurred to a model — the addition is a constant O(1)</strong>.</li><li>In addition, you get free messaging on top of that —<strong> all events that were added on a specific model are sent to the distributed log’s consumers</strong>. — All consumers (in our case, our services) have full access to all Fiverr data — in a granular way.</li><li><strong>All consumers save the shared data locally</strong>, in their own representation and according to their specific needs.</li><li><strong>Public data, Private processing </strong>— the big difference between a distributed log and a shared database, is that <strong>while the data itself is shared, operations on the data, such as complex joins, and other heavy load queries, are executed inside the scope of a single service on the internal local data storage</strong>, thus not binding its complexity and performance to the rest of the consumers.</li><li><strong>The introduction of new services into the ecosystem is easy </strong>— a new service enjoys all data without any upstream services having to change their APIs.</li></ul><h4>Can we use domain events to transport data?</h4><p>After deciding on the data integration method — using a shared immutable stream of events, we realized that using the events we are currently sending would be problematic.</p><p>Reminder — Domain events correlates to the command the chimera received, and described in past tense what has happened in the domain as a result of that command.</p><p>For example — if our command was <em>StartSellerVacation </em>the corresponding event would be <em>SellerVacationStarted.</em></p><p>Imagine a scenario where the fraud team just wants to store the changes in the price of a Gig over time. When the fraud team needs to get the information about price changes in gigs from domain events, they need to be aware of all the different domain scenarios and thus domain events which can potentially alter the gig price — and that makes it a bit unscalable to implement.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qWMrkR9cShu7A2xF." /></figure><p>What we would want the fraud team to do, is to listen specifically to an event describing a change in a specific attribute of the gig — a State Change Event.</p><h3>The Raven</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/872/1*LS-44Tyr_I_hhYcsBhVqXA.png" /></figure><p>The <strong>Raven</strong> is our name for a <strong>State Change Event </strong>— an event describing a <strong>granular</strong> change in a domain entity.</p><p>Inspired by the <a href="http://gameofthrones.wikia.com/wiki/Ravens">Game of thrones version</a> of the homing pigeon, the raven is a strongly typed centralized message written in Google’s <a href="http://Protocol buffers are a language-neutral, platform-neutral extensible mechanism for serializing structured data.">protocol Buffers</a>.</p><h4>Strongly Typed, Centralized</h4><p>A typical scenario during the development of many features would include a team having to get information about an event happened in the domain of another team / service — like in our example: the analytics team needs to subscribe to events describing the creation of orders and to calculate some stats about the sellers of those orders.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/773/1*O8U55rojfpEzhtd_ILBAXw.png" /></figure><p><strong>The problem is — the payload of those events is encapsulated in the code sending it </strong>— our analytics team now has to dig into unknown territories and make assumptions about the structure of such an event.</p><p>We wanted to improve this pain for our new state change events — the Ravens, and went implementing those using Google’s protocol buffers. <br>In their own words, Protocol buffers <em>“are a language-neutral, platform-neutral extensible mechanism for serializing structured data.”</em></p><p>For us this solution was just <strong>perfect</strong>. The idea behind ProtoBuf is that message structure is defined once, using a programming-language-agnostic syntax called <em>proto, </em>but then, using the Protobuf compiler, it is being compiled into any supported language.</p><p>An example of a message written in proto would look like this:</p><pre>syntax = &quot;proto3&quot;;<br>import &quot;raven/metadata.proto&quot;;</pre><pre>package raven.user.address;</pre><pre>option go_package = &quot;github.com/fiverr/ravens_golang/user/address&quot;;</pre><pre>message Created {<br>  raven.Metadata metadata = 1;<br>  string city = 2;<br>  string state = 3;<br>  string country = 4;<br>  string country_code = 5;<br>  float latitude = 6;<br>  float longitude = 7;<br>}</pre><p>This feature of Protobuf also caters for another important need of our platform — <strong>sharing a centralized strongly typed messaging contract between services written in a polyglot environment </strong>— in our case — Ruby and Golang for our backend services.</p><p>To centralize our messaging contract we created one git repository with a clear hierarchical structure of our aggregates as root folders, and sub folder which represent related entities.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bL0B8xtABnq1AS0BmQq0Hw.png" /></figure><p>This repository acts as a “single point of truth” for all the different messages that are being passed along in our ecosystem — a great advantage for developers requiring a reference to the messaging contract.</p><h3>Scaling the platform’s read-side</h3><p>Our initial goal for using our Ravens, was sharing data between our business activity based microservices — our chimeras.</p><p>Eventually, our first use case for those Ravens was different — sourcing our presentation data for the various pages in the platform.</p><p>Our read side suffered from 2 problems —</p><ol><li>Chimeras still served the data that they were managing to different pages of our Rails MVC</li><li>Our different pages, like our product page, or order page composed their presentation view data by fetching it from multiple chimeras and caching this data for performance reasons.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/782/1*Wp4otLOqhUM7JEmdKqlTjg.png" /></figure><h3>The Phoenix</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/866/1*MpH9hKEF7HugMA3GZZLrAw.png" /></figure><p>The <strong>Phoenix</strong> is another component/mythical creature in the Fiverr microservices architecture.</p><p>The <strong>Phoenix</strong> is a <strong>microservice</strong>, which consumes <strong>Ravens</strong> from <strong>Kafka, </strong>and constructs, using those state change events, a projection of those events into it’s local database.</p><p>The local database stores a read optimized view, serving a specific vertical in our website (i.e a user page, or an order page), or a horizontal data view that serves several verticals.</p><p>We chose to call this component a “Phoenix”, because of it’s Kafka-derived ability to replay the events it consumes, and rebuild it’s data view, in case of data corruption.</p><p>Although resembling a microservice, we felt it was important to differentiate the P<strong>hoenix</strong> from the C<strong>himera</strong> mainly because they convey different ideas and functions, and we wanted to separate them lexically as well.</p><p><strong>Projecting Ravens</strong></p><p>The phoenix has one job — <strong>project</strong> the ravens it consumes onto its read optimized data view — also called a <strong>projection</strong>.</p><p>A typical handling of an event will:<br>1. Decode the event and parse it’s type. i.e: <em>Ravens::User::ProStatusUpdated<br></em>2. Find corresponding handler class — <em>Handlers</em>::<em>User::ProStatusUpdated<br></em>3. Run the <em>project</em> method of the handler</p><p>A typical <em>project</em> method will:<br>1. extract aggregate id and related entity id— i.e. the user id<br>2. find relevant projection corresponding to the extracted ids<br>3. insert/update the relevant data carried by the raven.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-Gq0cLFHHUAnoioj." /></figure><p>Using a constantly updated read side optimized datastore, is like having a constantly updated cache layer being built previously from synchronously fetching data from chimeras, and now updated in real time without the need for sync REST calls or cache invalidation.</p><p>This move brings our entire platform to be purely CQRSed — our chimeras serve as the <strong>command side</strong> — receiving commands and translating them into Ravens (and domain events), and our phoenixes serving as the query side — optimized for fast fetching of a pre-compiled presentation data layer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/950/1*nSMKVQJTZknpZOT1deEBuw.png" /><figcaption>missing: The write side, which we will discuss in next chapters</figcaption></figure><h3>Summary</h3><p>With the help of immutable event streams, centralized strongly typed and language agnostic messaging contracts, and read optimized views, we managed to scale the read side of our platform.</p><p>In the upcoming chapters, we’ll continue to explore the interesting additions we introduced to our microservices architecture, Stay Tuned!</p><p>Chapters:</p><p><a href="https://medium.com/fiverr-engineering/fiverrs-microservices-evolution-part-1-ee366bd0b420">Part 1 — From a monolith to a chimera and beyond. The journey to architect our backend microservices.</a></p><p>Part 2 — From a Service-per-entity to well defined bounded contexts, Data transportation using strongly typed state change events &amp; persisted streams.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7bbcd6ceabda" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fiverr-engineering/fiverrs-microservices-evolution-part-2-7bbcd6ceabda">Fiverr’s Microservices Evolution — Part 2</a> was originally published in <a href="https://medium.com/fiverr-engineering">Fiverr Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fiverr’s microservices evolution — Part 1]]></title>
            <link>https://medium.com/fiverr-engineering/fiverrs-microservices-evolution-part-1-ee366bd0b420?source=rss-b52ae9b85bc2------2</link>
            <guid isPermaLink="false">https://medium.com/p/ee366bd0b420</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[cqrs]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[ruby-on-rails]]></category>
            <dc:creator><![CDATA[Alex Litvak]]></dc:creator>
            <pubDate>Tue, 05 Dec 2017 21:01:00 GMT</pubDate>
            <atom:updated>2018-01-22T01:34:34.877Z</atom:updated>
            <content:encoded><![CDATA[<h3>Fiverr’s Microservices Evolution — Part 1</h3><h4>From a monolith to a chimera and beyond. The journey to architect our backend microservices.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7OkE89xMhlztnpCLq81LrQ.jpeg" /></figure><h4>Genesis</h4><p>Microservices @ Fiverr are a fascinating thing. They truly are!<br>Spending quite a long time in the engineering team here @ Fiverr, allowed me to witness a full architecture being born, getting mature, and being replaced by another better architecture with its set of tools and paradigms more than a couple of times!</p><p>This series of blog posts, will revolve around how our journey begun, how we structured our services and databases, what challenges we faced, and what were the set of guidelines that drove us each time to a better, faster, more decoupled and resilient solution. It will also discuss general ideas around the love-hate relationship between microservices and data, event sourcing, CQRS, and how they integrate into a fully functioning platform here @ Fiverr.</p><h4>The Monolith</h4><p>In the midst of 2010, Fiverr.com was a website build as a <strong>monolithic Ruby on Rails application</strong> backed by a <strong>MySQL</strong> database.</p><p>As the site gained popularity and traffic increased, additional layer of caching had to be added, in the form of <strong>memcached</strong> and Rails <strong>Action caching</strong>, and to avoid real time calculations of data for search and catalog browsing, some <strong>cron jobs</strong> where added to the mix to warm up the cache with prefetched information.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/325/1*MxgQI-7_uCGE03-b8KGfBg.png" /><figcaption>Early Fiverr.com Architecture consisting of Rails, MySQL and Memcached.</figcaption></figure><p>As any fast paced startup, Fiverr wanted to move fast, with high cadence, and as many other companies such as Airbnb, Etsy, GitHub &amp; Shopify back then adopted Rails as it’s main platform.</p><p>But growing and scaling has its cost, and in the course of the next 3 years, <strong>increase in traffic began stressing the original architecture</strong>.</p><p>The monolithic nature of RoR meant that any bug or crash would bring the site down, while having a single database basically meant that over time, and as data grew and table joins started taking longer and longer to build for an increasing number of requests , the system became slower over time, having each user wait synchronously for fetches, updates, and page loads taking longer and longer. A mess.</p><p>In addition to the scaling problems we faced, the MVC paradigm of Rails while being fast and efficient, does not promote clean code structure. When strict rules and <a href="https://www.sitepoint.com/7-design-patterns-to-refactor-mvc-components-in-rails/">good design patterns</a> are not applied, maintaining a fairly large platform in Rails can be tough.</p><p>Adding to that a growing engineering organization, with a constantly increasing number of teams, and you get a very hard to maintain codebase.</p><h4>The Chimera</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/858/1*55Cm3Yd4I3QwYiQt-kJOnQ.png" /></figure><p>Alongside the great hype surrounding microservices, we started our baby steps in the journey to break the monolith.</p><p>When designing our first microservice, we had some important notions we wanted to promote:</p><ul><li><strong>Ease of initial development</strong> — our backend engineering team spoke <strong>ruby</strong>, and we loved it for its simplicity and developer happiness it created. We wanted to preserve ruby as our language of choice (which later evolved into adding Golang to our stack, but on that, a bit later).</li><li><strong>A viral solution </strong>— a scaling effort starts firstly from the engineering team, and we had to make sure that our platform team creates a solution that is both profoundly stable, robust and scalable, but also viral — meaning that it’s adoption across the engineering team would be easy.</li><li><strong>Asynchronous messaging between services</strong>- as our traffic increased, the need for fast, responsive site emerged, and we understood that letting the user wait for the synchronous completion of his updates, not only slowed his sessions, but also slowed the entire platform, since less requests could be handled while other users are using the session.</li></ul><p>Enter <strong>The Chimera</strong>.</p><p>Inspired by the mythological 2 headed beast, our chimera is a ruby microservice template combining:</p><ul><li><strong>READ SIDE</strong> <a href="https://github.com/ruby-grape/grape">Grape API</a> — for getting data from bounded context represented by the service — if it’s users information, the pricing of a gig, or the analytics of a specific order.</li><li><strong>WRITE SIDE</strong> <a href="https://github.com/ruby-amqp/bunny">RabbitMQ consumer</a> — listening to a messaging topic and asynchronously executing updates to the model of the service’s bounded context.</li></ul><p>The Chimera also enjoys the following 2 things:</p><ul><li>A <strong>Shared Core</strong> — since both “heads” are residing in the same repository, they enjoy code reuse and share the domain business logic, utils, etc.</li><li><strong>A Shared set of DB Connectors</strong> — The move to microservices initiated the usage of service specific databases such as MongoDB or Redis (which we now use extensively). While keeping our source of truth to be our relational MySQL cluster, we wanted to promote each service to access its own domain optimized database, and we needed utils to keep it simple to connect to all of those different data stores.</li></ul><p>A typical asynchronous update request would look like this using a chimera:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/689/1*iXV5TRupVE-CPYMOZbikZw.png" /></figure><ol><li>The user would perform a POST to create an order</li><li>The REST API would validate the request during the sessions, without saving anything to the database yet. This is performed very fast since the validation is very shallow, and included basic input validations and might also include some basic data integrity checks against the DB which are also executed without any heavy processing.</li><li>At this point, if the validation is passed, a message is being sent to the messaging broker (RabbitMQ) with a routing key pointing back to the chimera’s own worker. The message contains all the information passed in the POST command, and will be executed asynchronously without the user having to wait for it.</li><li>The User is then being returned a quick 201 status, and he/she can continue using the platform immediately.</li><li>The message is consumed by the chimera’s RabbitMQ consumer (AKA Worker) and since it has access to the same domain model, it can use it to perform the command and persist the order in the DB.</li></ol><p>Following the introduction of the Chimera, which is our variation of the microservice, our updated backend architecture now looked something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/584/1*qwqhf_g6XVKZZmKhrBwXqQ.png" /></figure><p>In reality, we spawned more then 100 chimeras over the course of the last 2 years, each owned and maintained by a different team, creating better decoupling and autonomy in the engineering department.</p><p>As pictured in this illustration, our new messaging bus was used for 2 types of events:</p><ul><li><strong>Command Events</strong> — the events being sent by a chimera internally to it’s worker (RabbitMQ consumer) in order to process updates asynchronously.</li><li><strong>Domain Events</strong> — the events being sent by a chimera in a pub sub pattern to any other chimera registered to listen to those events, informing the system that something has happened inside the bounded context of the chimera.</li></ul><p>An interesting usage we started implementing heavily using the domain events is <a href="https://martinfowler.com/bliki/CQRS.html"><strong>CQRS</strong></a> — Command Query Responsibility Segregation. <br>At it’s core, CQRS is intended to create read optimized views to improve the performance of applications.</p><p>Let’s look at one CQRS usage scenario that came in very handy for us @ Fiverr — analytics! A simple example to showcase would be the seller orders dashboard:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VKoMCnDxRyxGV755umxWVQ.png" /></figure><p>Getting the number of orders in their different stages would require a simple <em>group by </em>command in SQL. But, when going large scale, we don’t want to perform such a heavy query for each of our sellers each time they refresh their “Manage Sales” dashboard. CQRS to the rescue!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/589/1*xS5pCMvnbq9yX1oj-MitXQ.png" /></figure><p>CQRS allows us to update the orders bounded context, persist the order status change in our orders table in a relational MySQL table, then, using a <strong>domain event</strong> informing any interested component in our system about this change, we capture the change in a totally different bounded context — the analytics chimera, and update our read optimized mongoDB document by incrementing a specific bucket value.</p><p>Fetching of the order stats is now reduced from <em>o(n) </em>to <em>o(1). </em>nice!</p><p>As I’v mentioned this pattern continued defining a lot of the scaling and performance optimizations we have been conducting throughout our journey in the microservices world.</p><p>In the next chapter, we will discuss the various pains and challenges we faced using the described above architecture, and how out of those pains, evolved the next generation of our microservices architecture. Stay Tuned!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ee366bd0b420" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fiverr-engineering/fiverrs-microservices-evolution-part-1-ee366bd0b420">Fiverr’s microservices evolution — Part 1</a> was originally published in <a href="https://medium.com/fiverr-engineering">Fiverr Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>