<?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 Aviran Mordo on Medium]]></title>
        <description><![CDATA[Stories by Aviran Mordo on Medium]]></description>
        <link>https://medium.com/@aviranm?source=rss-5694bc7f5f53------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*-gns3QOkFhx2XqOU.jpg</url>
            <title>Stories by Aviran Mordo on Medium</title>
            <link>https://medium.com/@aviranm?source=rss-5694bc7f5f53------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 19:34:42 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@aviranm/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[Unlocking Tech’s Secret Sauce: How Learning Fuels Success]]></title>
            <link>https://medium.com/wix-engineering/unlocking-techs-secret-sauce-how-learning-fuels-success-45ef3364d9c4?source=rss-5694bc7f5f53------2</link>
            <guid isPermaLink="false">https://medium.com/p/45ef3364d9c4</guid>
            <category><![CDATA[learning]]></category>
            <category><![CDATA[wix-engineering]]></category>
            <category><![CDATA[culture]]></category>
            <dc:creator><![CDATA[Aviran Mordo]]></dc:creator>
            <pubDate>Tue, 04 Mar 2025 14:00:54 GMT</pubDate>
            <atom:updated>2025-04-28T07:47:12.001Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/980/0*sElZEZvu4vsQYmxU.png" /></figure><h3>How a Learning Culture Fuels Tech Success and Happy Teams</h3><p>Let’s be honest — tech doesn’t slow down for anyone. As an engineering manager at Wix, I’ve seen firsthand how fast the landscape shifts: new tools, frameworks, and customer expectations pop up almost overnight. In this whirlwind, one thing stands out as a game-changer for both a company’s growth and its people: a learning culture. A tech organization that prioritizes continuous growth doesn’t just survive — it thrives, delivering innovation while keeping its employees engaged and fulfilled.</p><p>In this post, I’ll break down why learning matters in tech, how it drives healthy company growth, why it’s a secret weapon for recruiting developers, and how it boosts employee satisfaction. Plus, I’ll share a few practical ways to make it happen. Let’s dive in.</p><h3>Why Learning Matters</h3><p>Tech evolves at warp speed. Skills that were cutting-edge five years ago can feel dated today — think of how AI has flipped the script on development. A learning culture keeps your team ahead of the curve, ready to tackle whatever’s next. At Wix, we’re all about empowering users to create standout websites; staying sharp ensures we can keep delivering on that promise.</p><p>But it’s more than just keeping up. When employees are encouraged to learn, they bring fresh ideas to the table, a team that learns can pivot fast because they’ve got the problem-solving skills to back it up in addition to the best practices and global knowledge of the entire organization to do things right.</p><h3>How It Drives Company Growth</h3><p>A learning organization isn’t just adaptable — it’s a growth engine. Teams that upskill regularly can deliver solutions faster and better than competitors. It’s a competitive edge that’s hard to beat.</p><p>It also attracts talent. Top engineers don’t just want a paycheck — they want a place where they can stretch and grow. A learning culture cuts turnover and pulls in the kind of talent who’ll push your company forward. Plus, when employees cross-train — say, a frontend dev learning some backend tricks — they can tackle broader tasks, reducing bottlenecks and boosting efficiency.</p><p>For a company like Wix, a learning team translates that into real impact. The more our people know, the bigger the impact and the quality that they will bring.</p><blockquote>Learning is a strategic investment in people. You invest time now in learning in order to move fast in the future, thus ending up saving time in the long term.</blockquote><h3>Enabling the Recruitment of Junior Engineers</h3><p>Here’s where a learning culture really shines: it opens the door to hiring junior engineers. These are bright, eager folks who might not have a decade of experience but bring fresh perspectives and a drive to grow. In a learning-focused org, they’re not a gamble — they’re an investment.</p><p>Juniors fit perfectly when growth is built into the system. With mentorship, hands-on projects, or even a quick course, they can go from tweaking code to solving complex problems in no time. A junior might start by mastering the use of our state of the art frameworks, learn how to design scalable and resilient systems and grow into a senior throughout her career at Wix.</p><p>This approach is cost-effective, too. Hiring seniors can be challenging as the competition over talent is fierce and talent is scarce, but juniors — nurtured in a supportive environment — can deliver huge value while sticking around for a long time because they feel invested in. It’s low risk, high reward and a perfect fit for a company that values innovation from the ground up. Senior engineers bring a lot of knowledge and can be productive pretty fast, but on the other hand, have also sometimes past practices from previous companies they have worked with, that do not always align with the best practices we have at Wix, this is where a learning opportunity also happens for them, unlike juniors that are a blank page that are eager to learn the best practices from scratch.</p><p>A learning culture doesn’t just benefit the company — it’s a lifeline for employees. When people feel supported to grow, whether through a workshop or a <a href="https://www.aviransplace.com/post/building-a-guild">guild day’s lecture</a>, they gain confidence and ownership over their work and increase the employee retention.</p><h3>Making It Real</h3><p>So, how do you build this kind of culture? here is what we do at Wix:</p><p>At Wix we have our Guild structure, where we invest 20% of our time for guild activities and learning.</p><p>Each developer that joins Wix undergoes a learning journey, which starts in the onboarding phase and continue throughout their first and sometimes even the second year in the company, where they undergo scheduled workshops, booster courses and special training, making sure everyone is knowledgeable and performs at the highest quality,</p><p>In addition to the schedules courses, there are other guild activities:</p><p>Guild activities include, for example, Guild day, once a week where we conduct lectures and workshops to teach new practices, technologies, design, AI and many other topics.</p><p>Guild weeks: where once a quarter a developer leaves their team and goes on to do other tasks, like join a different product team, work in the infrastructure group for a week, prepare a lecture for a guild day and many more activities they can choose from.</p><p>Learning facilities: At Wix we have dedicated a large space at our new campus to be dedicated to learning, we have many classrooms that we conduct training and workshops, large auditoriums for conducting lectures and host guild days. If you walk through “Wix Learn” any day of the week, you will find groups of people conducting educational activities.</p><p>This facility also allows us to launch recruitment and training programs for junior developers like <a href="https://www.wixkickstart.com/">Wix Kickstart</a> for juniors, <a href="https://www.wix-enter.com/">Wix Enter</a> and <a href="https://www.wixgrow.lt/">Wix Grow</a> for students or <a href="https://www.wix-boost.com/">Wix Boost</a> for more experienced developers, which reduces the organizational cost and overhead of recruiting and training. The fact that we can recruit and train cohorts of juniors, let them assimilate into the teams easily, reduces the training overhead on the teams and helps juniors to be productive much faster and with better quality training.</p><p>It is not just the facilities, we even have an organization called “Wix Academy”, which specializes in learning and supports the guilds in creating learning materials and learning activities at the highest level.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*550n4NBAOfsYp_9A.jpg" /><figcaption>Wix Engineering Conference</figcaption></figure><p>The highlight of our learning culture is demonstrated once a year on a large scale with the <a href="https://www.wix.engineering/post/the-drive-the-culture-and-the-growth-behind-wix-engineering-conference-with-aviran-mordo">WixEngineering conference</a>. On this day we take over a thousand engineers from all over the company to a full day of learning, <a href="https://www.youtube.com/watch?v=_BgRD3V5TpA&amp;list=PL_dMh3xjQSU9SoNH7-ODnrclrDh_mBi8K">lectures</a>, workshops and fun learning activities. Unlike public conferences where you need to cater to a wide range of audiences and topics, this conference is a highly technical one that focuses only on relevant topics to Wix engineers day to day work and challenges. All the speakers at the conference are Wix engineers themselves, which brings yet another dimension of learning by teaching. This conference has become a yearly tradition of Wix, and it is highly anticipated by everyone.</p><h3>Wrapping Up</h3><p>A learning culture isn’t a “nice-to-have” — it’s a must for any tech org serious about growth and people. It keeps companies agile and competitive while making employees feel valued and excited to show up. The result? A healthier organization and a happier team.</p><p>So, what’s one step you could take to spark learning where you work? I’d love to hear your thoughts — drop them in the comments!</p><p><em>Originally published at </em><a href="https://www.aviransplace.com/post/unlocking-tech-s-secret-sauce-how-learning-fuels-success"><em>https://www.aviransplace.com</em></a><em> on March 4, 2025.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=45ef3364d9c4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/wix-engineering/unlocking-techs-secret-sauce-how-learning-fuels-success-45ef3364d9c4">Unlocking Tech’s Secret Sauce: How Learning Fuels Success</a> was originally published in <a href="https://medium.com/wix-engineering">Wix Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Platform as a Runtime (PaaR) — Evolving Platform Engineering]]></title>
            <link>https://medium.com/wix-engineering/platform-as-a-runtime-paar-evolving-platform-engineering-ea78746881e1?source=rss-5694bc7f5f53------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea78746881e1</guid>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Aviran Mordo]]></dc:creator>
            <pubDate>Mon, 15 Jul 2024 09:26:17 GMT</pubDate>
            <atom:updated>2024-07-17T05:43:55.938Z</atom:updated>
            <content:encoded><![CDATA[<h3>Platform as a Runtime (PaaR) — Evolving Platform Engineering</h3><p>This article was first published on <a href="https://www.infoq.com/articles/platform-runtime-engineering/">InfoQ</a>, and I’m publishing it here for your convenience.</p><p><strong>Key takeaways</strong></p><ul><li>Large, complex systems hinder development speed. “<a href="https://www.aviransplace.com/post/platform-as-a-runtime-paar-the-next-step-in-platform-engineering">Platform as a Runtime</a>” simplifies the environment, enabling quicker development cycles.</li><li>Progressing to a platform as a runtime allows organizations to reduce the microservices footprint and cost and manage a single platform version with its own lifecycle, separate from the business microservice lifecycle and increased security.</li><li>Platform engineering goes beyond CI/CD. It streamlines the development process by simplifying code, automating integrations, and eliminating dependencies. This translates to significant developer productivity gains.</li><li>Platforms promote organizational scalability by fostering standardized development practices. By codifying methodologies, tools, and best practices, consistency is ensured across teams.</li></ul><h3>Introduction</h3><p>Many companies turn to platform engineering to help scale their development teams and increase developer experience for engineer efficiency. However, platform engineering usually stops at the CI/CD pipeline. As systems become larger and more complex we need to take the concepts of platform engineering to a higher level — to the code level — by creating platforms and abstractions that will reduce cognitive load, help simplify and accelerate software development, and allow for easy maintenance and upgrades to the platform. This will reduce cross-company tasks like fixing the infamous <a href="https://www.ncsc.gov.uk/information/log4j-vulnerability-what-everyone-needs-to-know">Log4J security vulnerabilities</a>. And while we are at that, let’s see if we can also reduce our cloud cost by reducing the footprint of each microservice. Let’s move from “platform” to “Platform as a Runtime”.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F0bYDBkx1es4%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D0bYDBkx1es4&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F0bYDBkx1es4%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/243ce19df89f581ddb577eabbef1b8a9/href">https://medium.com/media/243ce19df89f581ddb577eabbef1b8a9/href</a></iframe><h3>The impact of complex software systems on developers and organizations</h3><p>Large and complex systems can hinder a company’s ability to innovate and adapt quickly. These systems often demand that developers address large amounts of information and concerns, leading to cognitive overload. As an engineering manager, I’ve witnessed this firsthand. New feature development, regardless of its size, can be significantly slowed by the need to address a multitude of cross-cutting concerns, such as network contracts, regulations, and various non-functional requirements that exist alongside core business needs. This is especially true for Wix, you see, Wix is an open platform that exposes many APIs to 3rd party developers, being such all the services need to work in the same way, we have many guidelines on how to build a service and what are the best practices to handle scale and be part of the ecosystem.</p><p>For instance, a software platform may have a requirement that every database change operation needs to send a domain event. The fact that developers need to remember to define the domain event message and implement it on every DB operation, adds to the cognitive load, time, and complexity of their feature. In every system there are many additional requirements such as the system may require support for multiple languages and currencies, ensuring compliance with GDPR regulations, handling “delete” notifications, implementing best practices such as optimistic locking or having a version field in addition to last update date on every database schema, integrate with other sub-systems like IAM or other components of the ecosystem they are part of. This ever-growing list of considerations and “best practices”, can significantly impede the release cycle, especially as system complexity increases.</p><h3>Why software gets complicated</h3><p>Usually, software systems start small, but as they progress and become larger they become complex systems with intricate dependencies making it harder to understand how changes in one part might affect another.</p><p>Software systems are getting increasingly large and distributed across multiple servers and cloud components. Managing and maintaining these distributed systems adds another layer of complexity. Each component and feature has its own best practices and requires special knowledge. For instance, to send a domain event you need to understand how to use Kafka, to learn its APIs, its delivery guarantees (at least once) and what are the best practices of using Kafka. The same goes for databases like MySQL or MongoDB, search engines like Elastic Search, and even other internal services that you integrate with like your feature flags system. Basically, you need to understand and learn how to best use every component you use in the best way possible.</p><blockquote><em>It is almost impossible to ensure that all developers 100% comply with all the system’s non-functional requirements.</em></blockquote><p>Another point that contributes to the complexity is the lack of a standard way of developing software across teams and developers. For instance, one developer may define a database schema with a primary key as UUID, while another as Long. One developer may implement the GDPR features for “delete” and “get my data”, while another that was under pressure from the business to release features quickly only develops “get my data” but without the “delete” functionality. There can even be different implementations, for instance, one developer implements “GDPR delete” as a hard delete, another as a “soft delete”, and a 3rd as data anonymization without actually deleting the records. While these all might be valid solutions, when someone (i.e. the legal team) asks how you implement a GDPR delete, the answer should probably not be “it depends”. Systems should behave in a predicted and consistent way.</p><p>It is almost impossible to ensure that all developers 100% comply with all the system’s non-functional requirements. Even a simple thing like input validations may vary between developers. For instance, some will not allow Nulls in a string field, while others allow Nulls, causing inconsistency in what is implemented across the entire system.</p><p>Usually, the first step to aligning all developers on best practices and non-functional requirements is documentation, build and lint rules, and education. However, in a complex world, we can’t build perfect systems. When developers need to implement new functionality, they are faced with trade-offs they need to make.</p><p>In many cases, we look at trade-offs in and between three pillars:</p><p><strong>Code </strong>— When choosing how to build our system, for instance choosing between writing code in a monolith or a microservice, we face several concerns that may affect our decision. How easy it is to understand the existing code and the domain(s), can we break an API and what will be the effect on the system, how easy it is to refactor code and test and how can we scale our engineering org so multiple teams can work without or with as little dependency on other teams when writing their own features.</p><p><strong>Deploy</strong> — In this pillar we make trade-offs in relation to the release lifecycle, i.e, can multiple teams release new versions of their code to production whenever they want. How easy and quick the deployment process is. What are the risks with each deployment (the more code you deploy, the greater the chance is for a bug). Another thing to consider is keeping backward compatibility and breaking APIs. In a monolith for example it is easy to refactor and break an (internal) API because you have control over the entire code base, as opposed to a microservices environment where breaking an API can cause unexpected incidents due to its distributed nature.</p><p><strong>Run</strong> — In this pillar we consider the operational aspects of our system. What are the performance requirements, and how easy is it to scale parts of the system? When we run on production, how easy it is to understand (monitor) the system. In case of an incident, can we quickly find the owner of the part of the system that fails?</p><p>While documentation is a necessary step to define how we would like to develop software and what are the recommended best practices, in reality, developers have a lot of freedom to choose what and how to implement them. Multiple teams will have different internal libraries that implement parts of the guidelines and system contracts in different ways.</p><p>These varieties in implementations create ever increasing technical debt on the system as a whole, since every change in a cross-system requirements will need multiple teams to make changes, different bugs to be fixed in different implementations that basically do the same thing. Not so long ago we had the Log4J vulnerabilities that required almost every team to work on a fix. Making sure that 100% of the code base is fixed was a tremendous task.</p><h3>The need for standardization</h3><p>Complex environments demand standardized coding practices.</p><p>While defining these standards and consolidating technology stacks are crucial, simply documenting them isn’t enough. As I mentioned earlier, too much documentation can overload developers with information.</p><p>The solution lies in codification. We can translate these standards, guidelines, and best practices into an opinionated development platform. What we need to provide is a coding platform that developing within, will automatically take care of most of the system’s cross-cutting concerns and will make it very easy for developers to code within the guidelines, basically creating a golden path to quick product feature development.</p><p>For example, encryption of PII fields. The platform should automatically handle encryption and decryption of the fields without the developer needing to learn, understand, and even use the encryption library. For instance, just by annotating a field as @PII, the platform would automatically encrypt and decrypt the field as it is being written and read from the database, so developers don’t even need to think about it in their code.</p><p>Since the cost of developing such a robust platform is very high, we try to limit as much as possible our software stack. Granting unrestricted freedom to deviate from the standard platform increases the system’s complexity and maintenance burden, thus any divergence should be carefully evaluated considering the added complexity it introduces.</p><blockquote><em>Over 90% of the code that runs in a microservice are actually the frameworks and libraries you package and deploy. The business logic you actually write in each microservice is less than 10% of the code, at best.</em></blockquote><p>The need for standardization comes to mitigate scaling challenges. Microservices is another solution to try and handle scaling issues, but as the number of microservices grows, you will start to face the complexity of a Large-Scale Microservices environment.</p><p>In distributed systems, requests may fail due to network issues. Performance is degraded since requests flow across multiple services via network communication as opposed to in-process method calls in a Monolith. Monitoring the system becomes harder since calls are distributed across multiple services. Security becomes a bigger issue because, with every microservice we add, we increase the attack surface. And let’s not forget the human factor: It becomes harder to maintain standards, quality, and protocols across multiple teams and services.</p><p>These are the obvious shortcomings, but hidden issues that we encounter in large-scale systems are cost and maintainability. Let me explain:</p><p>When writing a microservice, you usually use some kind of framework like Spring, you also have all your internal libraries and dependencies that you need, for instance, logging libraries and JDBC drivers that you build and package into your microservice. What that means is that over 90% of the code that runs in a microservice are actually the frameworks and libraries you package and deploy. The business logic you actually write in each microservice is less than 10% of the code, at best, depending on the size of the microservice. In many cases, we even saw that the business logic is less than 1% of the code that is packaged within a microservice.</p><p>All this code is duplicated and deployed hundreds and thousands of times in your production environment, increasing the footprint with every new microservice. This, in turn, increases your cloud cost and makes it harder to align the different frameworks and library versions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nM3Uo5sVwOpzado3yunKqQ.jpeg" /></figure><p>At Wix, we operate over 4000 clusters of microservices, which is causing us some pain. So, we tried to mitigate these issues. We approached this problem by building Platform as a Runtime (PaaR).</p><p>To analyze the problem domain, we looked at how developers write code and chose the technology stacks across three pillars: code, deployment, and runtime. We split the solution into two parts: Platform and Runtime.</p><h3>Platform: Developer experience on autopilot</h3><p>The platform focuses on the developer experience, by codifying best practices, contracts, regulations, and most importantly integrations into the code middleware components of our production environment. Imagine it as a highly customized framework tailored to your company’s specific needs. It handles non-functional requirements, reduces boilerplate code, and minimizes cognitive load. When developers work within the platform, things simply “work as expected.”.</p><p>We internally called this project “Nile’’ and its focus was to streamline software development and the goal was to bring the most value to the developers focusing on the developer’s experience.</p><blockquote><em>We took platform engineering to the code level from the CI/CD level.</em></blockquote><p>This approach goes beyond traditional frameworks and platform engineering, we took platform engineering to the code level from the CI/CD level. Most companies offer frameworks that developers utilize, but they fall short of creating a platform that seamlessly integrates the framework with the organization’s operational practices.</p><p>For instance, consider GDPR compliance. To fulfill a GDPR data deletion request, you typically subscribe to a Kafka topic and listen to “delete my data” requests. A basic framework might allow you to easily subscribe to the topic, but developers would still need to code the message processing and deletion logic. A robust platform, however, would automatically subscribe to the GDPR topic, process the message, and initiate data deletion from the database — all without requiring additional developer intervention, the only thing a developer would need to do is to annotate the PII fields, and the platform would do the rest automatically.</p><h3>Runtime: Optimized service footprint and deployment</h3><p>The runtime component of PaaR focuses on optimizing service footprint and deployment strategy. Instead of bundling the entire platform and framework with your code artifact, the runtime holds the platform code and manages all network communication (incoming and outgoing). This eliminates the need to package the platform with every microservice, enabling independent release cycles of the platform separate from the “product” artifacts. Each deployed artifact simply connects to the runtime, resulting in a smaller service footprint, think of it like a runtime dependency as opposed to a build time dependency.</p><p>By reducing artifact size, PaaR allows for greater density within nodes. The footprint of a guest (i.e., your microservice) is reduced dramatically since it is not bundled with all the frameworks and common libraries. A single runtime host can efficiently serve multiple guest services, creating a virtual monolith.</p><blockquote><em>The platform brings a lot of value to the developers, we managed to improve our internal developer’s velocity by 50%-80%.</em></blockquote><p>In order to support a wide range of programming languages, we embarked on a ‘Platform as a Runtime’ initiative dubbed “SingleRuntime,” which communicates with guest services using the gRPC protocol over a local network (<a href="http://localhost/">localhost</a>). This approach will enable us to develop in multiple languages while maintaining a unified platform.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1AgDLj762n97SZIpJhEHOw.jpeg" /></figure><p>While PaaR is still a work in progress, we have experienced significant success with Nile. The platform brings a lot of value to the developers, we managed to improve our internal developer’s velocity by 50%-80%. Our developers’ experience has improved since they can now focus on building the business logic of their products, as opposed to spending a lot of time writing boilerplate code and implementing all the non-functional requirements, reducing the amount of code they have to write and test, and releasing products much faster than before.</p><p>The platform’s impact is so significant that we as a company have decided it is worth it to rewrite all our legacy services (there are hundreds of legacy services) into Nile in the next year.</p><p>Another underrated benefit of adopting a single standard platform that does a lot of the heavy lifting for you is the improved product quality. Product developers are freed from repeatedly implementing non-functional requirements, as these are now provided by the platform and implemented according to best practices, in the most efficient way by the platform team. Additionally, any new feature added to the platform is automatically available and active on all services built within the platform, saving cross-company efforts.</p><p>One example is data locality. Only a couple of services supported data locality before we moved to Nile, but as soon as we developed data locality support into the Nile platform, in a single day, hundreds of services that did not support data locality before, now have support for it, and all this without involving any product developers. Once they were compiled with the new platform, they got the data locality support “for free”. This saves the company hundreds of man weeks, had we wanted to support it without having a unified platform.</p><h3>Should you build your own PaaR?</h3><p>Developing a Platform as a Runtime (PaaR) solution is a substantial undertaking best suited for organizations facing significant scaling challenges. If your microservice environment is relatively small, in the low 100s of services, alternative, more cost-effective solutions for scaling might be preferable. You can start by enforcing standard libraries, maintaining rigid control over 3rd party dependencies, and building rules to enforce standards. One of the things we did at Wix, was to build a “generally available” (GA) enforcer that would force everyone to deploy their artifacts to production with the latest libraries and frameworks at least once every 2 weeks.</p><p>Once you scale to thousands of microservices, you could start building a platform.</p><p>For organizations ready to embark on a PaaR journey, my advice is to prioritize building the platform first. Focus on automating and streamlining the development process and integrations by taking platform engineering to a higher level of abstraction — not just infrastructure, but also the software layer itself.</p><blockquote><em>“The line of code that’s the fastest to write, the line of code that never breaks, that doesn’t need maintenance is the line you never had to write.” , Steve Jobs.</em></blockquote><p>Focusing on business logic worked for us since the platform team’s customers are our own product developers.</p><p>Building a platform involves a critical review of tens of thousands of lines of code. The way we approached it was to challenge ourselves with every line of code that we evaluated, we asked the question: “Does this line of code belong here?” The design goal of the platform is to isolate core business logic within the codebase and codify everything else into the platform, instead of the product service itself. As Steve Jobs once said: “The line of code that’s the fastest to write, the line of code that never breaks, that doesn’t need maintenance is the line you never had to write.” As naive as it sounds our KPI was the number of lines of code, we aimed to reduce as much as possible the lines of code a product developer has to write which are not business logic related.</p><p>An important lesson we learned is that we needed the platform team to be in the right mindset. We had to have a Value-Driven platform team. While this can be its own topic, I would mention one thing we discovered: the most crucial KPI for the platform team is “developer adoption”. If developers aren’t using your platform, it might not be delivering real or enough value. This kind of thinking was crucial to the team, collaboration with product developers is very helpful in the adoption of the platform since product developers are always involved in defining the platform features, and capabilities and setting requirements that actually solve their real problems.</p><p>One last thing I would like to share: The path to achieving these goals was not easy. Aside from the technological challenges, there is also the human factor. Developers can be apprehensive of abstractions and unseen functionalities. In order to win the hearts and minds of developers, consistent communication about progress and ongoing education regarding the platform’s inner workings are vital. This transparency demystifies the “magic” and empowers developers to debug and contribute effectively.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ea78746881e1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/wix-engineering/platform-as-a-runtime-paar-evolving-platform-engineering-ea78746881e1">Platform as a Runtime (PaaR) — Evolving Platform Engineering</a> was originally published in <a href="https://medium.com/wix-engineering">Wix Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Platform as a Runtime (PaaR) — Beyond Platform Engineering]]></title>
            <link>https://medium.com/better-programming/platform-as-a-runtime-paar-beyond-platform-engineering-31bf0bb7f75c?source=rss-5694bc7f5f53------2</link>
            <guid isPermaLink="false">https://medium.com/p/31bf0bb7f75c</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[monolith]]></category>
            <dc:creator><![CDATA[Aviran Mordo]]></dc:creator>
            <pubDate>Mon, 29 May 2023 10:22:29 GMT</pubDate>
            <atom:updated>2023-06-12T10:46:58.634Z</atom:updated>
            <content:encoded><![CDATA[<h3>Platform as a Runtime (PaaR) — Beyond Platform Engineering</h3><h4>Exploring approaches to organizing work and achieving better velocity and quality</h4><p>​​Platform engineering is something I’m personally very excited about, and we at <a href="https://www.wix.com/">Wix</a> have been practicing it for over a decade (before the name “platform engineering” was coined). In this article, I’ll explain some of the things that our teams at Wix Engineering have already deployed and implemented in the past couple of years, taking platform engineering to the next level.</p><p>We’ll dive into some new platform projects we’ve been working on to give some insights into our vision for the future.</p><p>To provide some context, Wix is a leading website-building platform with over 240 million registered users (website builders) from 190 countries. Our platform is deployed in three regions and has 20 more points of presence globally. At Wix, we employ over 5,000 people, about half of whom are in R&amp;D. So, it is safe to say that engineering is at the core of what we do and the core driver of our business value.</p><h3>The Need for Speed</h3><p>Successful software businesses deliver high-quality code fast. However, it comes with a lot of challenges related to size. As companies grow older and larger, the software development process becomes slower due to increased dependencies, legacy code, and complexity.</p><p>Since computer science and engineering existed, there have been multiple approaches to organizing work and finding ways to achieve better velocity and quality, where the latest trends are — Continuous Delivery, DevOps, and serverless.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*0WfB6PrDnytYQCI2.png" /></figure><p>As the popularity of methodologies changed, the tools we used also changed. These evolved to help companies deliver software faster — a push influenced much by the sheer number of tech startups and their growth. To support that growth, we saw the emergence of cloud hosting/computing providers enabling quick access to servers in vast data centers, thus reducing operational overhead and cost.</p><p>Then came the microservices philosophy, allowing companies to scale up even faster and maintain their software much “easier.” Finally, we have serverless, which takes away even more of the overhead and the need to maintain production servers. As the name implies, with serverless, you don’t need to deal with maintaining servers anymore. It removes the need to care about scaling, configuring servers, dealing with K8s, and more, thus leaving you with even less operational overhead.</p><h3>How Microservices Affect Dev Velocity</h3><p>If you’re just starting and you are building a single service (Monolith), things are fairly easy. You can use any framework of your choice and utilize all the tools at your disposal. You are able to go very quickly.</p><p>But as you scale, things tend to get more complicated quickly since you aren’t building just one service. You build something that integrates with other services and systems — and that thing now needs to connect to other services via RPC/REST, databases, message brokers, and so on. Now you have dependencies that you need to operate, test and maintain. You need to now build some framework around all of this.</p><p>And yet, with a handful of microservices, this is still a fairly simplistic architecture. As you continue to grow and succeed, you add more and more microservices and get to something like the image below. This is Wix’s microservices map; each rectangle is a microservice cluster, and the horizontal and vertical lines communicate between them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GTFoMB43BYkjO_u-.png" /><figcaption><em>Microservices communication map</em></figcaption></figure><p>As you can see, with many microservices, it also implies that many teams are working on them. Since all your microservices need to work in harmony, you need to think about the common concerns between them all — you need them to speak the same “language,” to have the same protocols and contracts. Like, how do I handle cookies and security? And how about the PRC calls, HTTP headers, and Logs?</p><p>Here’s a quick non-exhaustive list of the top things you may now have to worry about:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*iF5EkUouU6GiHtvX.png" /></figure><p>What do we do then? We create standards via a common framework, a common language, to make sense of it all. Otherwise, every developer must take care of all these cross-cutting concerns.</p><p>To make things worse, in a DevOps culture, you also expect the developers to be proficient in the following:</p><ul><li>maintaining the production environment</li><li>taking care of provision machines</li><li>looking after the databases and Kafka clusters, firewalls, and load balancers</li><li>making sure autoscaling is properly configured</li><li>building monitoring dashboards</li><li>understanding distributed systems and request flows</li><li>replicating data across regions, etc.</li></ul><h3>The Iceberg of Microservice Architecture</h3><p>Let’s look at one example service and the layers it is built upon. At the basis of it, there’s computing power — a virtual machine. It is running inside a container, and sitting on top of it is the microservice/application framework — for instance, Spring in the JVM world, Express for NodeJS, or whatever you work with. And then, on top of that, you build your trusted environment framework — a layer that makes it possible for all of your underlying services to communicate in the same way.</p><p>Via the same protocols, using the same HTTP headers, working with the same encryption/decryption algorithms, etc. That way, they can be used and trusted by all of the other services on the network.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*KRxhmOjyQ9PbZIN8.png" /></figure><p>Now, after having all these layers, next comes the actual work required from software developers. At the very top of this pyramid, you build the service that brings business value that your company sells to customers.</p><p>For us engineers, this is just the tip of the iceberg. There’s the whole bottom part of it which we need to take care of before we can even deal with the top part, which is the business logic code. Unfortunately, the overhead does not end here. In addition to the product features you need to develop, developers also need to take care of regulations, and business and legal concerns like GDPR compliance, for instance. This is not something your company sells, but you are required to develop it with each new service you build.</p><p>That was a long intro, but it explains the magnitude of developing large systems. Now, let’s take a breath and let’s talk about…</p><h3>Platform as a Runtime (PaaR)</h3><p>Usually, when building a microservice, you use your internal frameworks and libraries that are compiled with your code, giving you most of the common functionality like gRPC, Kafka client, connection pools, A/B testing, etc. However, with this approach, you end up with a distributed common framework, where you often need to update all the microservices to have (close) version parity across all your services.</p><p>It is a real challenge to update all your services to the latest framework constantly — or have semantic versioning — which brings its own set of issues (out of scope in this article).</p><h4>So, what can we do about this dependency overhead?</h4><p>One solution is to change the framework’s dependency from build time to runtime dependency. But at Wix, we have taken it a step further. There are other concerns when building an internal framework besides communication protocols and contracts, as we mentioned before. These other concerns are common business flows, common legal concerns (GDPR, PII, etc.), common tenancy models, permissions, identity management, etc.</p><p>So, we took all these business concerns and flows and added them as runtime dependencies, ending up with a Platform as a Runtime (PaaR).</p><p>Let me explain what it means by adding them to the PaaR.</p><blockquote>It means that now every microservice that is running in the PaaR gets these concerns handled automatically for them, without any development needed to be done in each service. For instance with GDPR, all services automatically handle GDPR requests to get my data and “forget me,” saving precious development time in each service.</blockquote><p>How did we do it?</p><p>We started with our very own serverless platform. At its core lies NodeJS, supporting the entirety of the application framework. Why Node.js? It is lightweight, supports dynamic code loading, and is easy to learn.</p><p>Step one: We took that and coded our entire framework into the Node.js server with an integration layer with GRPC / REST / Kafka (including a discovery service) and made it the “runtime server.”</p><p>So, now we have a cluster of identical “runtime” servers that have the same functionality (the frameworks).</p><p>Step two: We added another layer for data services, allowing developers to easily and quickly connect with databases (the runtime handles all the connection strings, connection pools, JDBC, etc.)</p><p>We ended up with a “smart” container that can handle ingress traffic and have all the common concerns embedded into it without much business logic.</p><p>What happens now is that developers can build the business logic using the runtime dependency (serverless) while not having the framework compiled and packaged with their code since it is provided to you as you deploy your code into the running process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*1xoC6IphUVqVc-mI.png" /></figure><p>As developers work on the code locally, a time comes when it is ready to be deployed. In the serverless ecosystem, you don’t need to worry about Node.js or containers. You deploy your TypeScript file(if it is a single function) or bundle, and that file gets dynamically loaded into the platform’s runtime!</p><p>Since we already have the service integration layer in the runtime, you don’t need to do lookup/discovery when you need to call another service. You declare what you need, and the platform provides the right client to connect to your dependent service.</p><p>Since all the integrations are done via the “runtime,” it also saves you the integration tests since the integration is done via the “runtime,” and you get a client library to use in your code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*jLJ6hTWjBBUv5p27.png" /></figure><blockquote>A major benefit is that you deploy just the code you need, without having to bundle it with common libraries and node.js runtime, which makes deployables extremely small, because it only contains the actual business logic you write (usually less than 100Kb in size).</blockquote><h4>Separating project structure from deployable topology</h4><p>Up until now, what I have described resembles standard lambda functions (however, with Lambda functions, you need to bundle your framework with your deployable). But what happens when you want to add another function? Well, with lambda, you would need to have another instance of the whole setup or package the two together, but since we are running on a trusted environment, we can run multiple functions inside the same process.</p><p>Basically, we can develop as independent microservices or even nano services (functions) but deploy all the functions to run as a monolith into the same process. However, we can also split the functions deployments to different PaaR (Platform as a Runtime) hosts, mimicking microservices, instead.</p><p>We can also do it the other way around. Develop the software as a microservice or a monolith, but deploy parts of the service to different PaaR hosts.</p><p>A classic example is when you have a service that has two endpoints. One is an RPC endpoint that needs to react to a user’s request, and another that listens to Kafka topics. We can develop the two functions in the same project so that the developer thinks about these endpoints together as part of the same “logical” service but deploy the RPC function to one host and the Kafka listener to a different host.</p><p>This will result in enabling different scaling strategies. We could autoscale the “customer-facing” RPC function differently than the Kafka service without the developer having to handle the cognitive load of separating these into two different services with all the framework overhead that comes with it.</p><p>At Wix, we built the system so that deploying a function is very fast and easy. After a developer pushes their function to a GitHub repository, it takes about a minute for that code to deploy to and run on production since it is only a small portion of the code (only the business logic, without boilerplate and bundled common libraries)</p><h3>Platform Engineering Mindset</h3><p>What did we achieve by doing this?</p><ul><li>Integrations became very easy — a developer can declare which functions/microservices they want to call, and they “automagically” get a client library to work with it.</li><li>There is less code to test — no integration tests for glue code are needed.</li><li>Developers can write and deploy very small functions focused on the essence of their business logic.</li><li>The deployment is fast — the code is small, and no framework/common libraries packaging is required.</li><li>There is zero boilerplate — all integrations are preconfigured and provided for a developer to use by declaration only.</li></ul><h3>Vision for the Future</h3><p>Next, how can we use what we have so far and build on top of that? Say we want to give separate teams the responsibility of managing their own runtimes. We can do that by cloning the setup I described above so that, for example, ecom and blog teams could each have their own cluster of runtimes to work with. That way, if needed, code from different teams isn’t pushed to the same runtime. All the while, you are still able to call functions between runtimes.</p><p>In this context, one thing we want to have at some point is to optimize the affinity of a given function based on its runtime. What do I mean by that? Let’s say we have the following two runtimes, each containing several functions:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*8pPxLbJwTMxzdZOU.png" /></figure><p>As you can see from the diagram above, Function 2 and Function 5 frequently interact. But since they are deployed on different runtimes, the network calls are slowing down. What if we could have the system automatically deploy Function 5 to the first runtime and Function 2 to the second one so that, in the end, we would get a picture like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*YTVHJawKeih6ihLy.png" /></figure><p>This way, by organizing and optimizing the functions in runtime instead of build time, we can have a highly optimized runtime environment with minimal network calls between microservices. This contrasts today, where we couple the domain design and the development environment with the runtime topology.</p><h3>The Future Is Here With “Single Runtime”</h3><p>Another future development we are excited about is expanding into other programming languages.</p><blockquote>In my opinion, this would require a paradigm shift, though — to not build a polyglot system and not to build the same framework as many times for as many tech stacks you support in your company. But instead, use a single runtime that would actually support <strong>any</strong> language.</blockquote><p>We work on achieving that by splitting the “Iceberg” in two, separating the single runtime framework, service integration, and the data services layers on the one hand. We call this the “Host.” Integration layer to the host + business logic as the “Guest.” The idea is to be able to develop the application framework only once instead of constantly trying to achieve feature parity between frameworks in different programming languages. An obvious advantage to this approach is running framework updates only on the host, not duplicating the framework/runtime for every language/dev stack you support, and only having to do it once.</p><p>The disadvantage is that we will not run the actual business logic (guest) in-process, but the host and guest communicate out of the process (on the same localhost). We are still experimenting with GraalVM to see if we can run multiple Guests (different languages) in-process with the host, but for now, we had an easier time and an actual working system by having two different processes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*bvIC3aX2RNeG1-wY.png" /></figure><h3>The Road So Far</h3><p>The success of this approach is evident in how much our developers love it. At the core, there is the platform engineering mindset, where we took a lot of complex concerns and made them easy. Wix developers can now develop things in a matter of hours that used to take them days and even weeks.</p><p>We took platform engineering from a low-level developer’s portal to a full-blown PaaR, along with a lot of the cognitive load of production low-level maintenance. Stay tuned for more as we detail the Wix “Single Runtime” project.</p><p>To learn even more, watch “Beyond Serverless and DevOps”:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fk3w0PZURa4c%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dk3w0PZURa4c&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Fk3w0PZURa4c%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/4e7d687d1ee6b3bebff101ec0b8a760a/href">https://medium.com/media/4e7d687d1ee6b3bebff101ec0b8a760a/href</a></iframe><blockquote>Original Article: <a href="https://www.aviransplace.com/post/platform-as-a-runtime-paar-beyond-platform-engineering">https://www.aviransplace.com/post/platform-as-a-runtime-paar-beyond-platform-engineering</a></blockquote><p>Follow me on LinkedIn: <a href="https://www.linkedin.com/in/aviran/">https://www.linkedin.com/in/aviran/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=31bf0bb7f75c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/better-programming/platform-as-a-runtime-paar-beyond-platform-engineering-31bf0bb7f75c">Platform as a Runtime (PaaR) — Beyond Platform Engineering</a> was originally published in <a href="https://betterprogramming.pub/">Better Programming</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[8 Tips for Getting your First Job — The Junior Dilemma]]></title>
            <link>https://medium.com/wix-engineering/8-tips-for-getting-your-first-job-the-junior-dilemma-41ec45d7b225?source=rss-5694bc7f5f53------2</link>
            <guid isPermaLink="false">https://medium.com/p/41ec45d7b225</guid>
            <category><![CDATA[jobs]]></category>
            <category><![CDATA[junior-developer]]></category>
            <category><![CDATA[tips]]></category>
            <category><![CDATA[interview]]></category>
            <dc:creator><![CDATA[Aviran Mordo]]></dc:creator>
            <pubDate>Thu, 20 Oct 2022 07:18:11 GMT</pubDate>
            <atom:updated>2022-10-20T07:18:11.904Z</atom:updated>
            <content:encoded><![CDATA[<h3>8 Tips for Getting your First Job — The Junior Dilemma</h3><p>The job market in the IT industry is boiling hot, with a huge shortage of tech workers. But this shortage of tech workers is not absolute. Some people claim that there are plenty of software engineers that are looking for a job, but they are not experienced and it is very difficult for them to find jobs because they are not given a chance.</p><p>This is precisely the problem. The IT shortage is actually for experienced software engineers. You see, companies are trying to solve many difficult problems and to solve them they need experienced people to lead these efforts, people who know how to avoid problems, that saw a thing or two in their career, that can lead projects and have the intuition of what can work and what can’t.</p><p>These skills can only come from real life experiences, these are not things you learn in universities.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/630/0*lBBnttrnIXZAvyS6.png" /></figure><p>But now you can claim that everybody needs somewhere to start and that the seniors of today were the juniors of yesterday, and the juniors of today will become the seniors of tomorrow. This is all true, however it does not help companies to solve their current problems. They need someone today because if they can’t solve the problem today these companies will not exist tomorrow. So the claim that there are enough engineers out there to fill most of the positions is not true, because they are not the people with the skills that companies are looking for. In order to recruit juniors, you need seniors to train them.</p><p>Having said all that, it is important for a company to have a healthy balance of seniors to juniors. There is a lot of value in having juniors at your company since they ensure the future of the company, some that stay will become seniors. Juniors are also hungry to learn and come with a lot of passion to succeed. The success of having successful juniors is to have a seniors mentor, teach and support them in their journey.</p><p>If you are just starting your journey in the IT industry you know how hard it is to start, the competition is stiff as there are many juniors competing for the same positions, and the question arises, how can you stand up from the pack ?</p><p>Grades are not enough: As a junior who is just starting your way, there isn’t much recruiting managers can rely on. While grades are an indicator, the fact that you can learn in an academic institution is not necessarily an indication that you are going to be a good employee. You see, companies invest a lot in training a junior engineer and you need to show them that you are the one they should be betting on.</p><p>As a manager who recruited and interviewed hundreds of people here are some tips that might help you get a foot in the door.</p><ol><li><strong>Experience means a lot</strong>. While you are just starting out, it does not mean you should have zero experience. Hiring managers looking for something more, show them what you can do. Find ways to do extracurricular work and gain some experience in the real world. Contribute to open source projects, create your own projects for family and friends and also for fun, try to find internships, start looking for student jobs or do some voluntary work for non profits or your community.</li><li><strong>Passion</strong>: Especially in juniors, managers are looking for passion. The best candidates are the ones who have a lot of passion and are hungry to learn: Participate in hackathons in your area of interest, keep updated with the latest trends and news. Read technology blogs and whitepapers, listen to podcasts, go to tech conferences or and online talks; many conferences publish <a href="https://www.youtube.com/user/WixTechTalks">tech talks videos</a> after the conference that you can watch and learn (you can also try to get a job at a tech conference and get in for free).</li><li><strong>Get your foot in the door</strong>: When you are looking for a starting job you have several paths you can go:<br>Get the job you want at the company of your dreams. This is probably the hardest one to get. I want to be a developer at Google/Facebook/Wix. — <strong>You nailed it!<br></strong>Get the job you want at any other company. I want to be a developer, gain a couple of years of experience and then try my luck at the company of my dreams.<br>Get a different job at the company of your dreams. While I want to be a developer at Microsoft, I can start as a QA or support and get into the company I want. After a year or two I can apply for a developer position within the company. For most companies internal candidates are preferred and have advantage over external candidates so you increase your chances of getting hired from within the company.<br>Get a different job at any other company, but also with a chance of getting promoted after a while to the job you actually want. Then you gain some experience which will help you in the future to seek the job you want at the company you want. And who knows, maybe you will actually like the place you went to and don’t want to leave after all :-)</li><li><strong>Prepare for the test</strong>: During a technical interview, many times you will be asked technical questions. Prepare for such questions and how to solve them. There are plenty of interview questions, websites and books you can learn from. Here is one example for a well known interview question book, <a href="https://amzn.to/3G7jdrC">Cracking the coding interview</a> you can try out.</li><li><strong>Learn how to interview</strong>: Doing the job and getting the job are two different skills. Impressing someone at an interview takes practice. Do some mocked interviews and practice your answers. If you didn’t interview before, cast a wide net, go to many interviews, even at companies that you are not interested in (maybe you’ll get lucky and you will like the place. If not you can always politely decline the offer). Gain experience interviewing, know what to expect in an interview. Once you feel comfortable in an interview you can now target companies on your short list. And who knows, you might get other offers on the way.</li><li><strong>Be active in the community: </strong>Create LinkedIn and Twitter profiles, participate in discussions on social networks and engage with people in the industry. Write blog posts, participate in meetups.</li><li><strong>Look for junior programs</strong>: Many companies have junior programs where they recruit many junior developers for a centralized training effort. For instance Wix has such a program called <a href="https://www.wixkickstart.com/">Wix Kickstart</a>. Look for these programs at companies websites, follow them and once they open try to get into one.</li><li><strong>Internal reference:</strong> If you can get a reference from a friend who works at a company, her word and recommendation can give you an advantage over other candidates. Since you are being evaluated together with other candidates, a warm recommendation from a person within a company goes a long way, since usually they are more trustworthy than any external reference you can bring.</li></ol><p>One last piece of advice, don’t be discouraged, finding your first job may take a long time but it will eventually come. Landing a job takes both skills and luck. Yes luck !!</p><p>You see timing is everything, companies have different job openings for different positions and types of people. Especially for junior positions, companies have many candidates to choose from. It is not only how good or impressive you are, it also matters who you compete against for the same position. So don’t be discouraged if you don’t nail the job, it could be just bad luck because there was simply someone else that is better qualified than you, it doesn’t mean you are not qualified (although it can also be the case).</p><p>In case you didn’t get the job, you can ask for a feedback, but know this, that not all companies will give you a genuine feedback if at all, this is because there were cases where they got a lawsuit because candidates did not like/understand or agree with the feedback, so some companies may simply not give feedbacks because they don’t want to take the risk of a lawsuit. Another reason for companies to refuse to give feedback, is because it can be overwhelming and cost a lot of money (time) to give feedback to all candidates, especially for popular companies who get thousands of candidates and it is simply too costly for them.</p><p>However if you can get feedback you are in luck, take notes and apply them towards your next interview.</p><p>And remember, since timing and luck are a big factor, don’t be afraid to apply again after a while for the same company you got rejected before, maybe you’ll get lucky next time.</p><p>Good luck !</p><p>Original post: <a href="https://www.aviransplace.com/post/8-tips-for-getting-your-first-job-the-junior-dilemma">https://www.aviransplace.com/post/8-tips-for-getting-your-first-job-the-junior-dilemma</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=41ec45d7b225" width="1" height="1" alt=""><hr><p><a href="https://medium.com/wix-engineering/8-tips-for-getting-your-first-job-the-junior-dilemma-41ec45d7b225">8 Tips for Getting your First Job — The Junior Dilemma</a> was originally published in <a href="https://medium.com/wix-engineering">Wix Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Safe Database Migration Pattern Without Downtime]]></title>
            <link>https://aviranm.medium.com/safe-database-migration-pattern-without-downtime-9b5810aad3c3?source=rss-5694bc7f5f53------2</link>
            <guid isPermaLink="false">https://medium.com/p/9b5810aad3c3</guid>
            <category><![CDATA[database]]></category>
            <category><![CDATA[migration]]></category>
            <dc:creator><![CDATA[Aviran Mordo]]></dc:creator>
            <pubDate>Wed, 10 Mar 2021 08:53:27 GMT</pubDate>
            <atom:updated>2021-03-10T08:53:27.974Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>This post was originally published on my <a href="https://www.aviransplace.com/">personal blog</a>.</blockquote><p>I’ve been doing a <a href="http://www.slideshare.net/aviranwix/road-to-continuous-delivery-wixcom">continuous delivery talk</a> for a while now and during my talk I describe a pattern of how to <a href="https://www.aviransplace.com/post/safe-database-migration-pattern-without-downtime">safely migrating one database to another database without downtime.</a> Since many people contacted me and asked for more details about it, I will describe it here in more details as promised.</p><p>You can use this pattern to migrate between two different databases, for instance between MySQL and MongoDB or between two schemas in the same database.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FuI0C10iIwp0%3Fstart%3D673%26feature%3Doembed%26start%3D673&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DuI0C10iIwp0&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FuI0C10iIwp0%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/92ed39762066c29ed2a1e5a99ff8f695/href">https://medium.com/media/92ed39762066c29ed2a1e5a99ff8f695/href</a></iframe><p>The idea of this pattern is to do a lazy database migration using <a href="https://www.aviransplace.com/post/continuous-delivery-part-3-feature-toggles">feature toggles</a> to control the behavior of your application and progressing through the phases of the migration.</p><p>Let’s assume two databases you want to migrate from the <em>“old” </em>database to the “<em>new”</em> database.</p><p>Step 1 <strong>Build and deploy the “new” database schema onto production.</strong> In this phase your system stays the same, nothing changes other than the fact that you have deployed a new database which you can start using when ready.</p><p>Step 2 <strong>Add a new DAO to your app that writes to the “new” database.</strong> You may need to refactor your application to have a single (or very few) point(s) in which you access the database. At the points you access the database or DAO you add a multi-state feature toggle that will control the flow of writing to the database. The first state of this feature toggle is “use old database”. In this state your code ignores the “new” database and simply uses the “old” one as always.</p><p>Step 3 <strong>Start writing to the “new” database but use the “old” one as primary.</strong> We are now getting into the distributed transaction world because you can never be 100% sure that writing to 2 databases can succeed of fail at the same time. When your code performs a write operation it first writes to the “old” database and if it succeeds it writes to the “new” database as well. Notice that in this step the “old” database is in a consistent state while the “new” database can potentially be inconsistent since the writes to it can fail while the “old” database write succeeded.</p><p>It is important to let this step run for a while (several days or even weeks) before moving to the next step. This will give you the confidence that the write path of your new code works as expected and that the “new” database is configured correctly with all the replications in place.</p><p>At any time you decide that something is not working you can simply change the feature toggle back to the previous state and stop writing to the “new” database. You can make modification to the new schema or even drop it if you need as all the data is still in the “old” database and in a consistent state.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/357/1*jw2JQb39oSV5k66KySjJ8Q.jpeg" /></figure><p>Step 4 <strong>Enable the read path. Change the feature toggle to enable reading from both databases.</strong> In this step the it is important to remember that “old” database is the consistent one and should still be treated as the authoritative data.</p><p>Since there are many read patterns I’ll describe just a couple here but you can adjust it to your own use case.</p><p>In case you have immutable data and you know the record id you first read from the “new” database and in case you did not find the record you need to fall back to the “old” database and look for the record there. Only if both databases don’t have the record you return a “not found” to the client. Otherwise if the record is found you return the result preferring the “new” database.</p><p>If your data is mutable you’ll need to perform the read operation from both databases and prefer the “new” one only if the timestamp is equal to the record in the “old” database. Remember in this phase only the “old” database is considered consistent.</p><p>If you don’t know the record id and need to fetch unknown number of records you basically need to query both databases and merge the results coming from both DBs.</p><p>Whatever your read pattern is, remember that in this case the consistent database is the “old” one, but in this phase you need to read and use the “new” database read path as much as you can, in order to test your application and your new DAO on a real production environment. In this phase you may find out that you are missing some indices or need more read replicas.</p><p>Let this phase run for a while before moving to the next phase. Like in the previous phase you can always turn the feature toggle back to the previous states without a fear of data loss.</p><p>Another thing to note that since you are reading data from two schemas you will probably need to maintain backward and forward compatibility for the two data sets.</p><p>Step 5 <strong>Making the “new” database the primary one. Change the feature toggle to first write to the new database (you still read from both but now prefer the new DB).</strong> This is a very important step. In this step you already run the write and read path of your code for a while now and when you feel comfortable you now switch roles and making the ”new” database the consistent one and the “old” as a not consistent. Instead of first writing to the “old” database first you now write to the “new” database first and do a “best effort” writing to the old database. This phase also requires you to change the read priority. Up until now we considered the “old” database as having the authoritative data but now you would prefer the data in the ”new” database (of course you need to consider the record timestamp).</p><p>This is also the point where you should try as much as you can to avoid switching back the feature toggle to the previous state as you’ll need to run a manual migration script to compare the two databases as writes to the “old” one may not have succeeded (remember distributed transaction). I call this “the point of no return“.</p><p>Step 6 <strong>Stop writing to the “old” database (read from both).</strong> Change the feature toggle again to now stop writing to the “old” database having only a write path with the “new” database. Since the “new” database still does not have all the records you will still need to read from the “old” database as well as from the new and merge the data coming from both.</p><p>This is an important step as it basically transforms the “old” database to a “read-only” database.</p><p>If you feel comfortable enough you can do step 5 and 6 in one go.</p><p>Step 7</p><p><strong>Eagerly migrate data from the “old” database to the “new” one.</strong></p><p>Now that the “old” database is in a “read-only” mode it is very easy to write a migration script to migrate all the records from the “old” database that are not present in the “new” database.</p><p>Step 8</p><p><strong>Delete the “old” DAO.</strong></p><p>This is the last step where all the data is migrated to the “new” database you can now safely remove the old DAO from your code and leave only the new DAO that uses the new database. You now of course stop reading from the “old” DB and remove the data merging code that handle merging data from both DAOs.th DAOs.</p><p>This is it you are done and safely migrated the data between two databases without downtime.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/460/1*2Fp3avqPwSSI_hjnwdSVaw.jpeg" /></figure><p>Side note: At Wix we usually run steps 3 and 4 for at least 2 weeks each and sometimes even a month before moving on to the next step. Examples for issues we had encounter during these steps were: On the write path we were holding large objects in memory which caused GC storms during peak traffic. Replications were not configured/working properly. Missing proper monitoring.</p><p>On the read path we had issues like missing index. Inefficient data model that caused poor performance which let us to rethink our data model for better read performance.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9b5810aad3c3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[We Have Completely Lost Our Privacy]]></title>
            <link>https://aviranm.medium.com/we-have-completely-lost-our-privacy-on-the-web-58b2e06eb873?source=rss-5694bc7f5f53------2</link>
            <guid isPermaLink="false">https://medium.com/p/58b2e06eb873</guid>
            <category><![CDATA[privacy]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[google]]></category>
            <dc:creator><![CDATA[Aviran Mordo]]></dc:creator>
            <pubDate>Wed, 27 Apr 2016 07:45:25 GMT</pubDate>
            <atom:updated>2016-04-27T07:46:34.232Z</atom:updated>
            <content:encoded><![CDATA[<p>Few years ago, before the social networks explosion everybody knew that it is important to keep your identity hidden and not to reveal any personal information about yourself. People used nick names and not shared personal information on the web. But as time passes where more and more services were being used in the cloud and social networks became popular we have lost all control of our privacy and personal information.</p><p>Lets take for instance Google and see just how much information Google know about us.<br>It started with email services like Gmail where Google knows all about our personal correspondence. Even if you didn’t fill any personal information when you signed up for Gmail just by reading your emails the information there is priceless.<br>Then we use Google calendar, where Google can learn about who we meet, what is our schedule and routine and significant dates and events in our lives.</p><p><strong>Other people reveal information about you and you don’t even know it.</strong></p><p>Even if you are not using Gmail Google knows a lot about you. People who do use Gmail have you in their contact and fill in your email, address, phone number, birthday and even your picture, and you have no control or knowledge that they did.</p><p>Even if you do try to keep private by using nick names on the internet, well in order to register to message boards like Google groups you fill in your email, and there you go Google and cross your nick name on the internet with your real identity.</p><p>The use of cell smart phone now puts a location tracker in our pockets, so now in addition to all the other vast information Google have on us, it also knows exactly where we are at all times. Adding Google wallet lets Google also know what we buy from whom and when. Not only what we are looking for in a search but potentially what we also buy offline (given cell phone payment will take off in the next couple of years).</p><p>Adding other services like note taking — Google knows out thoughts, YouTube and play — our taste in movies music books and what we like to play.</p><p>Given all these “Free” services we use Google know anything and everything about us, our lives, our friends and relatives. Adding Google+ and circles to the equation Google knows our relationships to other people interest, how we look like, what we like on the web and our hobbies.</p><p>The last piece of information is Google voice where Google knows who we speak with about about what.</p><p>While Google knows anything and everything about us, it is not just Google. Cloud services and social networks like Facebook hold a lot of information about us too. While we use these services more and more and rely on them in our daily lives we basically pay these “free” services with our privacy and no matter how much you try to keep information out of the web you have no control about what information your friends and family are sharing about you.</p><p>What do you think, is loosing your privacy a small price to pay for free services?<br>Can you trust commercial companies to keep this information safe ?</p><p>Originally posted: <a href="http://www.aviransplace.com/2013/09/05/we-have-completely-lost-our-privacy-on-the-web/#ixzz470j6rKtB">http://www.aviransplace.com/2013/09/05/we-have-completely-lost-our-privacy-on-the-web/#ixzz470j6rKtB</a></p><p>Follow: <a href="http://ec.tynt.com/b/rw?id=cY8Gd0XPGr4y9Tacwqm_6l&amp;u=aviranm">@aviranm on Twitter</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=58b2e06eb873" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Evolution of a Guild]]></title>
            <link>https://aviranm.medium.com/the-evolution-of-a-guild-a6c7d1927610?source=rss-5694bc7f5f53------2</link>
            <guid isPermaLink="false">https://medium.com/p/a6c7d1927610</guid>
            <category><![CDATA[guild]]></category>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[engineering]]></category>
            <dc:creator><![CDATA[Aviran Mordo]]></dc:creator>
            <pubDate>Tue, 22 Dec 2015 05:33:48 GMT</pubDate>
            <atom:updated>2015-12-22T05:33:48.078Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<p>A lot of people heard about <a href="https://www.spotify.com/">Spotify</a> company structure of Guilds and tribes. We at <a href="http://www.wix.com/">Wix.com</a> have a similar structure that has evolved over time and influenced by their ideas (we actually started naturally evolving into this structure even before we discovered the Spotify paper), however we have our own interpretation of the structure and the role of the Guild.</p><p>In this article I will try to walk down memory lane and describe my experience in building the first Guild (back-end JVM Guild) in Wix, which is now the role model of all the other Guilds at the company, and how it has evolved from the time I joined Wix when we had one back-end team of 4 developers to around 100 back-end engineers in the back-end guild.</p><p>The Guild model did not start right away, when you are a relatively small startup all you have is teams, and this is exactly what we had. We had one server team (4 engineers) that was basically responsible for all the back-end development at Wix. As there was a demand for more back-end engineers the team grew very slowly. As with a small startup the recruitment process was very picky and we were only looking for the best engineers. At the course of a year I have only recruited 4 senior engineers. While this is very slow at this stage of the company it was very important to pick only the best engineers you can find, as these are the core engineering team that will help to build and shape the Guild and the engineering culture at the company in the future.</p><p>At this point where we had around 10 engineers we were pretty much functional teams, where everybody knew almost everything and I could move people from project to project according to the company’s priorities.</p><p>As we continue to grow (doubling the number of people every year) we saw that we are very good in focusing our efforts in some areas where are that point the company decided to invest, but were neglecting other existing products that had to compete on shared engineering resources but without any priority.</p><p>At this point we realized that we need dedicated engineers for each product group (at least for the big ones). We still didn’t have a name for that but I had essentially assigned some developers to be dedicated on some products while the other still remained shared resources.</p><p>As Wix continued its growth we had different groups of people who worked on different projects and were less engage with each other. So what we started to do is to formalize our engineering culture. While we always had a strong ownership and DevOps culture we started more and more being involved in knowledge sharing activities in order to keep our engineering teams on the cutting edge and learn from each team’s experience.</p><p>At this point we started to have discussions about how to structure the company. We looked around and found the Spotify paper. We realized that while we don’t have a name for our current structure it resembled to what Spotify had. So we adopted some of the naming and agreed that we should be working at a form of Guilds that are defined by a profession; and Gangs, which are the product teams.<br>Initially we only had the engineering Gangs who were dedicated to a product with all the other as shared resources across products.</p><p>This was the point where the role of the Guild had started to form.</p><p>The Guild is the one who is responsible for the person’s profession thus the Guild has the following responsibilities:</p><p>Recruitment (Hiring and firing)<br>Assignment to product teams according to the company’s priorities.<br>Setting the professional guidelines.<br>Training.<br>Set the engineers compensation (salary, bonuses etc’).<br>Create an engineering brand for the company.<br>Be responsible for the professional development / career of the engineers.</p><p>As Wix continued to grow we started to have more and more projects and product teams. What we realized then is that while having dedicated engineering teams (Gangs) is not enough because there was a bottleneck on the other shared resources. Also we had multiple products that had a common domain. What we wanted to do is to give as much independence to each product domain / vertical.</p><p>So once more we had to evolve and created what we call now a “Company”. A company is like a startup within Wix, it has all the resources it needs (developers, product manages, analysts, UX engineers, marketing etc’) in order to progress fast and create the best product they can do regardless if, the other products at Wix.</p><p>At this point the Guild also had to take on more responsibilities. While we want the “Companies” to progress as fast as they can, the “Companies” also has to keep alignment with Wix as a whole. Another issue is that we expect these “Companies” to create products that compete in the free market with other startups and big companies, but with limited resources.</p><p>The Guild now needs to play a big role in enabling the success of the “Companies” within Wix. If each “Company” had to develop everything on their own, for instance the frameworks, deployment, taking care of the infrastructure, monitoring etc’ they would not stand a chance to compete with whole companies that are doing the same product with more resources. So the Guild now took another responsibility in taking care of all the infrastructure, deployment pipeline, and core services that all the “Companies” share. For instance is we see a service that is needed in more than two companies (for example mailing service), we develop it in the Guild (which has its own core services teams) and all the other “Companies” can use this service, thus focusing only on the product itself and not having to worry about the infrastructure.</p><p>In order to keep alignment with the other “Companies”, and make it easier for engineers to move between “Companies”, share knowledge and best practices, all the “Companies” share the same infrastructure and methodologies. This is a tradeoff between freedom and velocity. You loose some freedoms but gain a lot of velocity as many of the things you need for your service are already there for you.</p><p>Now a “Company” may decide (in coordination with the Guilds) that using the existing infrastructure is the wrong solution for the product they own, and they want to develop on a different stack. They can do that, however they will need to take full responsibility over the whole application lifecycle, deployment, monitoring and integration with the other Wix echo-system. This is a lot of work and usually time to market will be very long, having to develop all the infrastructure on their own, so almost every “Company” opt-in to use the current infrastructure, although we have several cases where it was the right decision to develop some products on a different stack .</p><p>So if I was to describe the line of responsibility between a “Company” and a Guild is that the “Company” decides what to do, and the Guild say how to do it.</p><p>So now that we have “Companies” and Guilds, the Guild needs to assume more responsibilities in addition to the above:</p><p>Align between “Companies”. The Guilds are horizontal while “Companies” are verticals.<br>Support the engineers working in the “Companies”<br>Review and guidance<br>Develop shared infrastructure<br>Improving development velocity<br>Temporary help “Companies” in need with additional resources from the Guild.</p><p>Guild masters:<br>Guild masters are senior engineers that part of their responsibilities is to support engineers in different “Companies”. Guild masters conduct reviews, training, mentoring and also since they are horizontal and working with many companies they identify common issues, duplication of code between companies, understand the development bottlenecks and are trying to solve them. Also because of that they also pollinate “Companies” by bringing best practices and lessons learned from other “Companies”</p><p>Guild activities:<br>In order for the Guild to be able to take on these responsibilities it needs developer’s time so at Wix 20% of the engineering time is dedicated to the Guild activities.</p><p>Every Thursday we have a Guild day in which the Guild is conducting training activities and Guild tasks. All the engineers from all the “Companies” are assembled at one place for the Guild day.</p><p>Here is the back-end guild day schedule:<br>10:00–11:00 — Guild retrospective in which we discuss engineering dilemmas and lesson learned from across “Companies”.<br>11:00–11:15 — Break<br>11:15–11:30 — Project spotlight — where someone is presenting a new project that is being worked on, some lesson learned and challenges they have faced<br>11:30–13:00 (usually not the whole 1.5 hours is needed) — Tech talk, which if it does not contain any sensitive information is also open to the public at a meetup.<br>13:00–EOD — Guild tasks. (The guild tasks are called “Games of Gangs”, you can read more about<a href="http://www.aviransplace.com/2015/08/14/games-of-gangs/">“Games of Gangs” in this post</a>).</p><p>Originally posted: <a href="http://www.aviransplace.com/2015/08/10/building-a-guild/#ixzz3v1ZLSv9x">http://www.aviransplace.com/2015/08/10/building-a-guild/#ixzz3v1ZLSv9x</a> <br>Follow: <a href="http://ec.tynt.com/b/rw?id=cY8Gd0XPGr4y9Tacwqm_6l&amp;u=aviranm">@aviranm on Twitter</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a6c7d1927610" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>