<?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[Zsoft Engineering Blog - Medium]]></title>
        <description><![CDATA[A community of passionate people who promise excellence as delivery - Medium]]></description>
        <link>https://medium.com/zsoft-engineering-blog?source=rss----ecfc153513a1---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Zsoft Engineering Blog - Medium</title>
            <link>https://medium.com/zsoft-engineering-blog?source=rss----ecfc153513a1---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 05:36:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/zsoft-engineering-blog" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[a PACT Teams Should Adopt to Hire Great Software Engineers]]></title>
            <link>https://medium.com/zsoft-engineering-blog/a-pact-teams-should-adopt-to-hire-great-software-engineers-3917f4dbde5c?source=rss----ecfc153513a1---4</link>
            <guid isPermaLink="false">https://medium.com/p/3917f4dbde5c</guid>
            <category><![CDATA[management-and-leadership]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[craftsmanship]]></category>
            <category><![CDATA[hiring]]></category>
            <category><![CDATA[digital-transformation]]></category>
            <dc:creator><![CDATA[MH LEKMITI]]></dc:creator>
            <pubDate>Mon, 10 Jan 2022 22:04:23 GMT</pubDate>
            <atom:updated>2022-01-10T22:03:40.242Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>An interview is an opportunity for both sides to get to know each other. It should be an enjoyable experience driven by delight and willingness to learn.</blockquote><figure><img alt="Hiring great software engineers" src="https://cdn-images-1.medium.com/max/640/1*K7z5Ll9svNBZZNqI754_Dg.jpeg" /></figure><p>Companies and teams look ahead to acquire talented engineers. Yet, this is not within everyone’s reach. Finding the right person for the job can be difficult and expensive. <strong>PACT</strong> is an opinionated model based on our experience to help teams overcoming this challenge.</p><blockquote>Hiring is not only about technical skills. Collaboration between humans calls for soft and communication skills.</blockquote><p><strong>PACT</strong> is a container of five aspects that should be evaluated during interviews:</p><ul><li><strong>Personality / Mindset</strong></li><li><strong>Potential</strong></li><li><strong>Agility</strong></li><li><strong>Communication skills</strong></li><li><strong>Technical skills</strong></li></ul><p>PACT focuses on setting out a framework to hire great engineers. It comes with guidelines and principles. <strong>Every thought is questionable and adaptable. Apply it according to your context.</strong></p><h3><strong>1. Personality / Mindset</strong></h3><figure><img alt="Evaluate the personality of the candidate" src="https://cdn-images-1.medium.com/max/640/1*Gl67b18w4W4huShNrukwoQ.jpeg" /><figcaption>Evaluate the personality of the candidate</figcaption></figure><ul><li><strong>Values should be your first concern. </strong>Every beautiful story starts with common values<strong>.</strong> Regardless of their technical skills, people with non-compatible values will not collaborate together. Your first challenge is to <strong>find individuals who match the values of your team</strong>. Being said, getting to know people is difficult in itself. Having a brief discussion regarding non-technical subjects (such as social events) may flat many thoughts about one’s values and thinking.</li><li><strong>Do not tolerate ego</strong>. Ego destroys relationships. On the opposite, humbleness sets out a conducive environment for work.</li><li><strong>Focus to build a collaborative team not individual heroes. </strong>No one should be greater than the team. <a href="https://www.inc.com/jim-schleckser/why-netflix-doesn-t-tolerate-brilliant-jerks.html">Brilliant jerks can rip your team apart from the inside</a>.<strong> Look for team players with collaborative thinking</strong> <strong>to establish harmony</strong>. Sharing, helping and other social qualities are some main keys for this sake.</li><li><strong>Owning the project and feeling responsible for it are very powerful attributes. </strong>They enhance trust and promote transparency within the team.</li><li><strong>Look for value oriented engineers</strong>.<strong> </strong>A great engineer should know how to overcome the trade-off between code quality and delivering value.</li><li><strong>Avoid simple executors. </strong>They will be seeking numbers rather than valuable outputs.</li><li><strong>Great engineers care to understand the business</strong>. They address the code from a business perspective and feel what is right or wrong for the client.</li><li><strong>Great engineers think product not project</strong>. They care to learn practices to create and maintain a product not just to write clean code.</li><li>Talented developers are often full of pride. <strong>Great Engineers are not dogmatic. They seek the truth and feel no attachment to their code. </strong>They<strong> </strong>softly accept others’ approaches which proved to be better, and move to the next issue.</li><li>Any team may go through conflicts and difficult moments. <strong>Empathy and the ability to put oneself in the shoes of the other </strong>are keys to overcome these challenges safely.</li><li><strong>Autonomy is important, asking for help is a quality.</strong> Great engineers have to be autonomous, but they know when they should ask for help.</li><li>Technology shifts fast. <strong>Talented engineers are not afraid of learning new things. </strong>They know the software industry and understand its tendencies.</li><li>Curiosity is the quality of great people. <strong>It is a powerful hint of excellence.</strong></li><li>Consider how mature the candidate is. <strong>Maturity is uncommon among technical profiles.</strong> Yet, it is necessary for a solid professional relationship.</li><li><strong>Greatness cannot be obtained without hard work</strong>. Look for people who work hard.</li><li><strong>You should not depend on soldiers of fortune. </strong>They<strong> </strong>can let you down at the most critical phase of your project.</li></ul><h3>2. Potential</h3><figure><img alt="Consider the potential of junior candidates" src="https://cdn-images-1.medium.com/max/640/1*sB_kUVM1onEJR3Za6Obclg.jpeg" /><figcaption>Consider the potential of junior candidates</figcaption></figure><ul><li>New graduate software engineers are supposed to know <strong>how to solve problems, not to code</strong>. Challenge them accordingly. Solving algorithms with pseudocode is a good means at this level.</li><li><strong>Learning ability, motivation and commitment </strong>are a package of three attributes to hire excellent junior and new graduate engineers. A motivated individual who learns fast and puts the needed effort will exceed your expectations in no time.</li><li><strong>Hire</strong> <strong>people who seek growth. </strong>A personal-development aware candidate may become the ultimate collaborator you are dreaming of.</li><li>When it comes to senior developers, we should not talk about potential anymore. <strong>Assert the credibility of their experience.</strong></li></ul><h3><strong>3. Agility</strong></h3><figure><img alt="Consider agility when hiring software engineers" src="https://cdn-images-1.medium.com/max/640/1*jdctf-mOGis6jv-6xEvngQ.jpeg" /><figcaption>Consider agility when hiring software engineers</figcaption></figure><ul><li>Clients love technology. But at the end of the day, <strong>they pay for value. </strong>Technical skills are just basics to deliver value. Agility comes with practices to maximize delivery. A craft developer seeks for better code,<strong> an agile engineer looks to deliver added value. Hire agile mindsets.</strong></li><li>Today’s world changes fast and in a continual manner. <strong>Great engineers should have an ability to shift and adapt quickly.</strong></li><li>Agility is not about SCRUM rituals. <strong>Challenge the why behind using real-life situations.</strong></li></ul><h3><strong>4. Communication skills</strong></h3><figure><img alt="Communication skills are mandatories in collaborative jobs" src="https://cdn-images-1.medium.com/max/640/1*D5cq25u9pjiyVECSNDc4lA.jpeg" /><figcaption>Communication skills are mandatories in collaborative jobs</figcaption></figure><ul><li>Alone you go faster, together we go further. “Together” calls for communication skills. <strong>Being part of a team requires an ability to listen and soft-skills to argue</strong>.</li><li>Code is the golden source of truth. Seek for developers with the ability to communicate this truth. Great engineers may talk code with each other, <strong>but should talk business with management.</strong></li><li>Great engineers have the ability to <strong>make abstractions and to simplify the complex ideas </strong>to the business.</li></ul><h3><strong>5. Technical skills</strong></h3><figure><img alt="Excellent technical skills are the minimum required" src="https://cdn-images-1.medium.com/max/640/1*GGs7Le4Q86hM1f-1uNaubw.jpeg" /><figcaption>Excellent technical skills are the minimum required</figcaption></figure><ul><li>Excellent products require crafts profiles<strong>. Your software engineers should care about clean code and its best practices.</strong></li><li><strong>Test cognitive ability over code knowledge. </strong>Look for problem solvers, not just developers.<strong> </strong>The interview should focus on the practices and the reasoning, less on pure knowledge.</li><li><strong>Straight Q&amp;A is not the best way to assert the credibility of an experience</strong>. Most questions are shared on the internet. Unqualified developers can easily make their way without being really challenged.</li><li>The candidate’s code should talk on behalf of him. Jump as fast as possible into the code<strong> to get a fast impression on how he performs in real life.</strong></li><li><strong>Peer programming</strong> <strong>gives you a glimpse about applicant’s dailies.</strong> Collaborating to solve a given problem makes the interview joyful and helps both sides to get to know each other faster.</li><li>Bear in mind that excellent engineers seek for challenging environments. <strong>The level of your technical interview should live up to their expectations.</strong></li><li>Professional and educational backgrounds are very powerful hints. <strong>But keep your interest in what the candidate can put on the table.</strong></li><li><strong>Testing and delivery practices reflect how mature the applicant is. </strong>It<strong> </strong>tells you a lot about his previous experiences.</li><li><strong>Domain modelling, data-structures and design patterns</strong> are details that you should go through.</li><li>Your questions should remain relevant to the project you are hiring for. <strong>Asking questions about knowledge you do not use leaves the impression that you want to break the person down</strong>. Questions-like: “ what are the strategies of the garbage collector in Java ? ” does not make a lot of sense, unless you really call for this knowledge in your project.</li><li><strong>Great engineers opt for the simplest solutions.</strong> A complex solution does not mean the candidate is out of the box. Look for engineers who get to the dirty solution first and refine after.</li><li><strong>Great engineers never reinvent the wheel</strong>. Avoid developers who are not comfortable with the idea of working on others’ code. Those who seek to refactor anything they did not write themselves.</li></ul><p>Keep in mind those are non exhaustive guidelines to help you with your recruitment journey. Unless you already did, you will not find an individual who brings together all the qualities mentioned above. <strong>Most of the time, you need to find trade-offs based on your context.</strong></p><h3>Interested in working at Zsoft-Consulting?</h3><p>We’re currently hiring excellent engineers from all over the world who respect science, have passion for technology, and want to evolve and deliver excellence.</p><p>We promise win-win relationships where people grow safe, while pushing the wheel of the business to scale.</p><h3><a href="https://zsoftconsulting.hiring-master.com/">Positions offered by Zsoft-Consulting</a></h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3917f4dbde5c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zsoft-engineering-blog/a-pact-teams-should-adopt-to-hire-great-software-engineers-3917f4dbde5c">a PACT Teams Should Adopt to Hire Great Software Engineers</a> was originally published in <a href="https://medium.com/zsoft-engineering-blog">Zsoft Engineering Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[15 Keys to Achieve Predictability Within your Team]]></title>
            <link>https://medium.com/zsoft-engineering-blog/15-keys-to-achieve-predictability-within-your-team-92781ff159c1?source=rss----ecfc153513a1---4</link>
            <guid isPermaLink="false">https://medium.com/p/92781ff159c1</guid>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[agility]]></category>
            <category><![CDATA[deadlines]]></category>
            <category><![CDATA[digital-transformation]]></category>
            <category><![CDATA[engineer]]></category>
            <dc:creator><![CDATA[MH LEKMITI]]></dc:creator>
            <pubDate>Thu, 16 Dec 2021 21:26:07 GMT</pubDate>
            <atom:updated>2021-12-20T11:01:35.843Z</atom:updated>
            <content:encoded><![CDATA[<p>In a high concurrency IT world, predictability is a game changer for any organization. Being able to meet deadlines lays companies at the pyramidion of their business.</p><figure><img alt="How to become predictable and estimate better" src="https://cdn-images-1.medium.com/max/640/1*TtssWCXYj0CeeOXbCRv2WA.jpeg" /></figure><p>A couple of days ago, our new manager organized a meeting to praise the predictability of the team. This meeting came based on stakeholders request who found the squad predictable.</p><p>By the same event, they wanted feedbacks on the main keys allowing this team to meet their deadlines.</p><p>To quote his words , he asked:</p><blockquote>“ How come that you are comfortable with estimating? and what are the actions you have put in place to achieve this level of predictability ? ”</blockquote><p>Following are the answers often heard in this meeting :</p><h3>1. It is about Hiring</h3><p>At a given time we started giving more attention to non technical aspects. We put more focus on the candidate’s mindset, his soft and communication skills, and whether he is <a href="https://agilemanifesto.org/">agile</a> or not.</p><p>For us, a good engineer should take the lead on his feature from development to production. This cycle includes dev, testing, communication, delivery and sometimes monitoring once released.</p><p><strong>Excellent technical skills on their own do not guarantee that you make through dev-prod cycle within deadlines.</strong></p><h3><strong>2. Look for harmony</strong></h3><p>Once we hired the right people with the required values, we set out to achieve harmony. People need time and stability to reach their best versions. For many <a href="https://scrumguides.org/scrum-guide.html#the-sprint">sprints</a> we were looking for our parameters.</p><p>As any other team, we went through periods where we could not achieve the objectives of our <a href="https://scrumguides.org/scrum-guide.html#the-sprint">sprints</a>. We walked through conflicts as well.</p><p>Yet, the team was in a continuous development process and positive thinking. This allowed us to keep the focus on our targets. Team members often called for their soft skills and broad mindedness to overcome those challenges.</p><p><strong>Once we got to know each other better, our performance increased in a remarkable manner.</strong> <strong>This allows us to meet our objectives and to estimate with confidence.</strong></p><h3><strong>3. Invest time learning agility</strong></h3><p>Agility comes with powerful practices to achieve predictability. Being said, a lot of teams claim to be agile, but few actually are.</p><p>We saw agility as an opportunity to enhance our performance. We invested time learning about it. We tested various practices and configurations to find our rhythm toward performance.</p><p>The organization went in the same direction. They provided excellent agile coaches who made our leaning curve fast and easy.</p><p><strong>Today, agility is granted by every of the team members. This agile mindset helped us to achieve our objectives.</strong></p><h3><strong>4. Stabilize team velocity</strong></h3><p>The team adopts <a href="https://scrumguides.org/">SCRUM</a> as a development process. Within this framework, we care to know the complexity of the features a team can handle over a <a href="https://scrumguides.org/scrum-guide.html#the-sprint">sprint</a>. we know this as team <a href="https://www.agilealliance.org/glossary/velocity/#q=~(infinite~false~filters~(postType~(~&#39;page~&#39;post~&#39;aa_book~&#39;aa_event_session~&#39;aa_experience_report~&#39;aa_glossary~&#39;aa_research_paper~&#39;aa_video)~tags~(~&#39;velocity))~searchTerm~&#39;~sort~false~sortDirection~&#39;asc~page~1)">velocity</a>.</p><p>It is mandatory to stabilize the velocity of the team if you want to achieve predictability. A team that estimates in a relevant manner, having a stable velocity, is predictable.</p><p>Consider this example:</p><p>- Given:</p><ul><li><em>Sprints of 2 weeks</em></li><li><em>A feature holding 10 user stories.</em></li><li><em>Each user story has been given a complexity point from 1 to 5 as estimation</em>.</li></ul><p>-<em> When the sum of points gives a global complexity of 80 points</em>.</p><p>-<strong> <em>If team velocity is stable at 10 complexity points per sprint: you should finish the feature within 8 sprints (2 months).</em></strong></p><p><strong><em>- If your velocity is fluctuating up and down, you can not foresee the end line.</em></strong></p><h3><strong>5. Estimating against a reference feature</strong></h3><p>When estimating features we may need a reference. It is a user story whose real complexity is known and experienced by all dev members. This user story is used as reference to estimate any other feature.</p><p><strong>Having a reference feature helps developers to converge toward the same estimations.</strong> We often come back to this user story to explain our estimation when the last seems to be not relevant.</p><p>Example: In a hiring management system</p><ul><li>You may consider that displaying a list of candidates to the end-user has a complexity of 2 points.</li><li>Based on that, affecting a candidate to a recruiter and sending related notifications is a more complex feature and may be estimated to 3 points.</li></ul><h3><strong>6. Technical study sessions</strong></h3><p>When we have to estimate a complex subject we often call for a technical study session. We apply it on subjects for which we do not have enough visibility. This is very common when dealing with legacy projects.</p><p>Before estimating, devs may take some hours to jump into the code. <strong>This helps to uncover the traps the feature may involve, making estimation more relevant.</strong></p><p>Whenever we did that we were fine and very collected with our estimation.</p><h3>7. Cultivate a value oriented mindset</h3><p>Overtime, we cultivated a mindset of delivery. Every single member of the team developed a value oriented thinking.</p><p><strong>Delivering value was our first occupation</strong>. Technical excellence and craftsmanship were means and not targets on their own.</p><h3><strong>8. Code quality makes estimating easier</strong></h3><p>Having a code of quality is another keyword to meet predictability. When the code is well written, the risk is uncovered and flat on the table.</p><p><strong>A complex code hides a lot of traps that you may not be aware of during estimation sessions. This gives rise to extra work during development and so missing deadlines.</strong></p><p>We have experienced that with two different projects. The pink one is complicated and does not follow the best development practices. The green one is a clean code architecture that adheres to the best practices of code.</p><p>When estimating the pink features we do it very hard. Even if we do technical study sessions before estimating, we often miss things.</p><p>Green features are simple to estimate. The fact that Green is well written does not bring in a lot of refactoring. It keeps the efforts and the focus on the feature under development. Moreover, it is easy to identify risks before starting development.</p><p>Designer provides models with HTML and even CSS classes. This makes front-end development a piece of cake.</p><h3>9. Using microservices</h3><p><a href="https://medium.com/zsoft-engineering-blog/overview-on-microservices-over-monolithic-architecture-d87b477fe975">Microservices</a> architecture allows the codebase to remain small. This helps developers to keep control over estimation.</p><h3><strong>10. Estimate wide</strong></h3><p>legacy projects are very common in software industry. When estimating feature in a legacy, think to estimate wide to be able to handle the unexpected issues.</p><p><strong>Predicting a margin of time is a good practice to meet deadlines.</strong></p><h3><strong>11. Prioritization should not be address carelessly</strong></h3><p>Agility meets its limit when hitting V cycle projects.</p><p>Sometimes the feature under development depends on other teams . Even if you do the job, the feature is still not releasable as soon as the contract is not met from the other side. This is a common use case causing teams to miss deadlines.</p><p><strong>Stop starting features until their dependencies are resolved. This is a matter of priority.</strong></p><p>Think to adopt concepts such as <a href="https://www.agilealliance.org/glossary/invest/">INVEST</a> when prioritizing features.</p><h3><strong>12. Set up a good onboarding process</strong></h3><p>You can not prevent people from leaving.</p><p>The turnover impacts predictability. Yet, if you manage to shift smooth and to set up a good onboarding process, you can reduce this impact.</p><p>We set up an onboarding process that promotes helping and sharing. We never let new joiners in their corners on the ground that we are observing their autonomy.</p><p>pair programming sessions are good means to integrate the team in no time.</p><h3><strong>13. Approach features from various angles</strong></h3><p>According to SCRUM, the product owner comes with spec. It is up to the development team to decide about the solution to put in place.</p><p>This practice is fine as a standard, but it should not turn into a rigid rule above everything.</p><p>We experienced situations where the product owner proposed better technical solutions. Others where developers came up with easier and more suitable business proposals.</p><p><strong>In a team every profile has a different angle of vision. The game is to consider all points of view to find the best solution.</strong></p><h3><strong>14. Development team is not only developers</strong></h3><p>A software project does not turn only about developers. <strong>Having excellent UX designers and Business Analysts accelerate development.</strong></p><p>Excellent business analysts dispose of both technical and functional understanding. This allows them to bridge devs to requirements in an efficient manner.</p><p>Excellent designers provide models with HTML and even CSS classes. This makes front-end development a piece of cake.</p><h3>15. Humility</h3><p>keep in mind achieving a given position is difficult. Maintaining the same level is of a bigger challenge.</p><blockquote><strong>“ consistency is what transforms average into excellence ”</strong></blockquote><blockquote>Tony Robbins</blockquote><p>We are not the best team of the organization. It is very easy to regress if we claim we are.</p><p>Humility is the keyword to avoid this trap. So keep working forward!</p><h3>Interested in working at Zsoft-Consulting?</h3><p>We’re currently hiring excellent engineers from all over the world who respect science, have passion for technology, and want to evolve and deliver excellence.</p><p>We promise win-win relationships where people grow safe, while pushing the wheel of the business to scale.</p><h3><a href="https://zsoftconsulting.hiring-master.com/">Positions offered by Zsoft-Consulting</a></h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=92781ff159c1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zsoft-engineering-blog/15-keys-to-achieve-predictability-within-your-team-92781ff159c1">15 Keys to Achieve Predictability Within your Team</a> was originally published in <a href="https://medium.com/zsoft-engineering-blog">Zsoft Engineering Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Overview on Microservices over Monolithic Architecture]]></title>
            <link>https://medium.com/zsoft-engineering-blog/overview-on-microservices-over-monolithic-architecture-d87b477fe975?source=rss----ecfc153513a1---4</link>
            <guid isPermaLink="false">https://medium.com/p/d87b477fe975</guid>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[digital-transformation]]></category>
            <category><![CDATA[zsoft-consulting]]></category>
            <dc:creator><![CDATA[MH LEKMITI]]></dc:creator>
            <pubDate>Sun, 05 Dec 2021 12:13:02 GMT</pubDate>
            <atom:updated>2021-12-05T11:56:39.237Z</atom:updated>
            <content:encoded><![CDATA[<p>… or Microservices vs Monolith, or what do you need to consider to shift to Microservices architecture</p><figure><img alt="Big Monolith as Microservices" src="https://cdn-images-1.medium.com/max/1024/1*TG2ebQQMNS8_FH5MVKjq9w.jpeg" /><figcaption>Big Monolith as Microservices</figcaption></figure><p>Technology decisions are about trade-offs. Microservices over monoliths concern does not make any exception. To know what suits you better, why and when, you need to have a good understanding of both architectures and an insight of how they perform regarding software engineering aspects.</p><p>Being said, when talking about big structures and complex IT platforms such as the Amazon ecommerce website, monoliths are showing major drawbacks that hold back the organizations to move forward with their business. The tight coupling within a monolith architecture is at the source of these holdbacks and needs to be treated.</p><p>Migrating to a different architecture was conclusive for organizations in order to be able to maintain the existing applications and to keep scaling within an agile world that changes continuously. With the aim to reduce time to market and to enforce value delivery, companies are shifting toward agile practices and so, adopting new architectural styles that fall in with agility.</p><p>Microservices is an architectural style that attempts to reduce coupling within monoliths by breaking the complex system apart into loosely coupled components, providing thereby solutions to monolith problems. Nevertheless, microservices are not silver bullet; as any other concept they come with a cost and have their own challenges that need to be addressed.</p><p>This article provides a brief overview of how microservices and monoliths are dealing with different software aspects such as delivery, scalability, reliability, performance, data consistency, and so others. Along this review, we promote microservices as an evolution to deal with complex systems, we explain how they operate to solve monolith problems, and we highlight some of the big challenges related to this style of architecture that should be considered.</p><h4>From monolith to microservices</h4><p>Adopting a microservices architecture since the early days has not always been the recommended approach to embrace an application. When the application is relatively small, a monolithic architecture may prove to be more efficient, straightforward and comes with a lot of benefits: simple to develop, to test, to deploy, to scale, and so time to market is fast. Over time, when the product is successful the small unit starts to grow in terms of modules, teams and code base. The so-called ‘ities’ aspects (scalability, testability, maintainability, availability, predictability) become hard to handle and even impossible at a given point, eventually pulling a rewrite of the code base.</p><p>Some organizations attempt to control and maintain monolith complexity by advocating craft efforts and practices, such as continuous refactoring, clean architecture, XDD, multi-modules and so on, which gives good results to some extent. But the drawbacks of a monolithic have become so impacting and strong that we need to address them at a higher architectural level.</p><figure><img alt="Hexagonal Architecture, Clean Code" src="https://cdn-images-1.medium.com/max/960/1*y2CAk0f-BKXhWqeRD7nJMw.png" /><figcaption>Clean Code Achitecture (Hexagonal)</figcaption></figure><p>Microservices architecture promises solutions to monolith problems and stands in the software industry as the today and next generation architectural style. Software references have given many definitions to what microservices are, but none of them would disagree that they are a set of stateless, domain based, loosely-coupled, datasource-independent and delivery-independent services, each handles a sub-domain of the big system and communicates with the others in both modes: synchronous using APIs (such as REST, GraphQL), or/and asynchronous using a message broker (such as RabbitMQ, Kafka).</p><h4>How Microservices differ from SOA ?</h4><p>Microservices is not a new concept, it is an extension of the Service Oriented Architecture, known in the software community as SOA, that has been used for decades as an alternative to monoliths. When companies started to adopt microservices architecture, it was some kind of a controversial subject. Some did not find how microservices differ from SOA since both see the application as a set of services. This debate is warranted considering the similarity of the two architectures. However, when we deep dive into it, we can find significant distinctions.</p><p>The major difference between the two architectures is that services of SOA, in comparison with microservices, are not completely independent of each other. They use a global domain model, run under the same infrastructure and share the same database. This is considered to be an anti-pattern of loosely-coupling concept and does not lend an effective helping hand against monolith problems.</p><p>Another key difference between the two styles is the way to decouple the application services. While SOA focuses on achieving reusable components, microservices tends to decouple its services based on functional bounded contexts, this allows a better loose coupling and goes with the basic idea to maintain fully independent domains.</p><p>Unlikeness could be noticed as well in the technology stack adopted in both architectures. SOA uses a smart pipe and heavy protocols for communication such as ESB (Enterprise Service Bus) and SOAP. Microservices architecture in the hand tends to use more lightweight protocols such as REST APIs and simple message brokers.</p><figure><img alt="Three Tiers application vs Service Oriented Application vs Microservices Architecture" src="https://cdn-images-1.medium.com/max/960/1*hU6O4QgWcXeaA3FYjJs17w.png" /><figcaption>Three Tiers application vs Service Oriented Application vs Microservices Architecture</figcaption></figure><h4>How big is a microservice</h4><p>One of the debates around microservices is how big a microservice is. Amazon.com shares their vision about the subject with the Pizza Team rule: the whole team can be fed by two pizzas<strong>. </strong>This matches with the scrum team number rule which is about 7 plus or minus 2. However<strong>, </strong>out of team number static rules<strong>, </strong>microservices are functionally split components. As a result, how big your team is will depend on the functional subdomain the microservice handles. When strangling a monolith into several services, some subdomains may still be relatively big compared to others. How big microservices should be driven by how big the resulting subdomains are.</p><h4>Delivery</h4><p>Monolith applications come with a lot of drawbacks but their main problem may reside in delivery. When working within a monolith, teams are strongly dependent on each other making the edit-build-test-deliver process complicated, error prone and extremely heavy. In such projects, teams are not allowed to deliver whenever they want. To bring some changes to production, they have to do it on specific days scheduled by months (each three months for instance). To ensure the delivery package is good, all the teams that are working on the project need to synchronize with each other weeks ahead. In such process, teams are more likely to miss delivery deadlines. Moreover, if a delivery contains an error, they have either to wait for the next delivery or to communicate again with all the teams for a tactical delivery. Broadly speaking, monolith is a headache when it comes to delivery and goes against the most basic concept of agility: delivering value incrementally.</p><p>On the other side, microservices are in harmony with agility. Since the services are completely independent, each team can go to production whenever they feel ready. A feature can be developed, tested and delivered in the same day. Amazon.com -which is one of the first microservices adopters- deployed a change into production each 11.6 seconds without impacting their clients ( Yes. You have read it well, 11.6 seconds!) . That is why from an agile perspective, microservices are a driving element to achieve continuous delivery.</p><p>However, continuous delivery in the context of microservices requires reliable delivery practices and pipes. Therefore, significant efforts should be put to support teams with their frequent delivery processes, this is part of what we know today as DevOps.</p><h4>Scalability</h4><p>monolith modules called for different requirements depending on their responsibilities. In an ecommerce application, the module which handles product recommendation may feel necessary for CPU intensive calculation to run recommendation algorithms, whereas a product catalog module may need extra memory to cache aggregated products data. When scaling the application to many instances, each instance will require a high performance CPU as well as large memory size to be able to undertake both responsibilities.</p><p>Another example showing monolith limitations as for scalability could be based on data. We can imagine that only a small subset of data asks for expensive physical resources, this a common business feature to provide high quality service for premium users. It is hard to implement such use cases when dealing with only one unit, and even If we can we will not achieve high cost optimization. Therefore scaling in monoliths is difficult and needlessly expensive.</p><p>This is completely the opposite for microservices. To optimise physical resources we can split the product recommendation and the product catalog modules to two distinct microservices, each scales according to its needs. Otherwise, if we want to provide high quality service for some users, we can run specific instances dedicated for those users on extra-resources servers.</p><h4>Availability and reliability</h4><p>Software without bugs does not exist. In the case of a monolith, a bug that crushes the process at any given module of the monolith -such as memory leaks- brings down the application instance by instance making the whole system unavailable. Now because teams are delivery dependent, bug resolution takes a lot of time to find its way to production, which makes the system unavailable for a long period of time. As an overall result, the application becomes unreliable from an end user perspective.</p><p>Microservices are doing much better regarding availability. The bug that brings down a process does not necessarily make all the system unavailable. When a given microservice is down or manifests high latency behaviour, only the upstream microservices are being impacted in a cascading manner. At this level, we can apply the Circuit Breaker and Fallbacks patterns to prevent the failure propagation throughout the upstream microservices, which makes the big system more resilient and highly tolerant. In addition, the fact that the team owning the unavailable microservice is delivery-autonomous accelerates bug resolution that can be applied within hours or even minutes, reducing thereby the time of unavailability.</p><p>Sometimes the monolith breaks down because of the high throughput against a given functionality. In a microservices architecture, it would be easy to isolate that functionality and provide enough instances to ensure fault tolerance.</p><h4>Performance</h4><p>Except for some extreme use cases, monoliths are doing very well against performance by default, this is not the case for microservices architectures. While Microservices provide solutions for the so-called ‘ities’ aspects (scalability, testability, maintainability, availability, predictability), it comes with its own challenges, performance stands as one of the top of these challenges.</p><p>The fact that data is distributed over many services gives rise to performance issues during fetch and calculation operations. For instance, a calculation process may have to call many microservices to prepare the inputs required for calculation. Nevertheless, performance issues in microservices architectures does not mean we have to go back to monoliths, the software community has provided patterns to deal with those problems, such as CQRS and caching solutions.</p><h4>Data consistency</h4><p>Data consistency is not a big challenge with reference to monolith applications. The coherence of data is preserved by a shared relational database that respects ACID (Atomicity, Coherence, Isolation and Durability) properties.</p><p>When it comes to microservices architecture, data consistency is one of the biggest and hardest challenges of this architectural pattern. The distributed nature of data in microservices among different databases brings in data consistency problems. In this architecture, cross services features are very common, such use cases may apply changes to multiple databases giving rise to some kind of distributed transaction. At the opposite of a monolith that relies on ACID transactions, if a given service fails to save changes locally, data that has been already stored in the upstream microservices will not be rolled back, which creates data consistency issues across the big system.</p><p>Another common use case in the context of microservices is that end-users do not get the updates they make in a real time manner, they need thereby to do a refresh to be able see it. This is a very annoying issue for user experience and may be even dangerous for functional decision making which is in this case applied based on inconsistent screens. To illustrate it with a simple example, your screen is handled by a service ‘A’ who depends on a downstream service ‘B’. When service ‘B’ is updated by another process, your screen is not aware of it till a refetch by the end user is done.</p><p>Many patterns such as Event-driven, Saga and Event-Sourcing have emerged and combined together to address data consistency issues within microservices, but none of them comes with a full solution that radically eradicates data consistency problems. That is why In the context of microservices we talk about eventual consistency: data is eventually consistent.</p><h4>Testing</h4><p>The huge amount of use cases that a monolith encapsulates makes testing suite heavy, the complexity of the code makes the tests difficult to write and pulls a lot of integration and end-to-end tests, those are hard to write and time consuming. Furthermore, it is more likely for a developer to skip some tests when the scenarios combinations are so many, affecting thereby test coverage. Sometimes, tests are even manually applied making the testing process heavier. As an overall result, application build is not only heavy, but teams are not very collected as for delivered increments, the impact of changes is not fully understood and bugs may easily leak to production.</p><p>Testing a microservice is straightforward and easy when the feature under test concerns only that microservice. Contrary to monolith, we can easily achieve a high percentage unit tests coverage for every microservice, this tolerates a small integration, end-to-end tests coverage within each microservice. However, the fact that microservices are distributed by nature introduces extra cross microservices testing efforts to test how they perform together. Since two microservices may be owned by two different teams, the contract (the API) of a provider microservice might change or not be well communicated causing the consumer microservice to fail. To avoid this type of bugs in production the two microservices need to share out a contract. This agreement is going to be covered by relevant tests on both sides which should fail at build time whenever the contract is broken. We know this testing practice as contract-testing.</p><p>Testing contracts allows validating the integration of two microservices. Nevertheless, a microservices architecture may be composed of tens or hundreds of services working all together. To ensure they are performing well, cross microservices end-to-end tests may be written for the basic use cases.</p><h4>Security</h4><p>In a monolith application the security implementation is generally injected in the application as a separate module.</p><p>Security in a distributed context should be treated differently. Since microservices are distributed, a request coming from the end user may cross many microservices. Each microservice encapsulates a bounded context, so he needs to know the identity and the permissions of the end-user in order to allow access to aked resources or not. Therefore, we need a dedicated service to handle authentication and authorization. This service will be requested by other microservices to validate the identity of a given user and to attest whether he has access to a specific resource or not. Token based protocols such as Oauth2 is a good implementation to achieve authentication and authorization.</p><p>During authentication a user token holding the user context (name, email, permissions…etc) is delivered by the security microservice. If we are adopting a gateway pattern, the gateway microservice will take responsibility to ask for that token during the first call. The generated token is then appended to the requests headers when making calls across microservices APIs in a cascading manner, which allows each service to get access to the user context.</p><h4>Code complexity</h4><p>Monolith<strong> </strong>complexity overwhelms developers understanding. When the application reaches a certain complexity, it becomes beyond the developer’s control. Adding new features becomes complex, time consuming and errors prone. Moreover, the Dev team estimations lack relevance which negatively affects predictability.</p><p>code complexity in the context of microservices is scattered among the services. Each microservice holds one responsibility of the big system, which makes the code base relatively small and understandable. Adding a new feature is easier because we bring to change the concerned components only -generally only one if we have managed to functionally distribute the system-. Developers know what every of their owned microservices does, they have a good understanding of their code base. As a result, they are more precise when it comes to features estimations, which helps the company to be predictable as for its objectives.</p><h4>Code quality</h4><p>The code base of a monolith requires a lot of refactoring, which is generally not the priority of stakeholders and managers who pull the cord to deliver business value. Trading off refactoring against business value impacts code quality which gradually declines over time.</p><p>On the opposite side, the code base of a microservice is not too complex, the edit-refactoring process is simpler and feasible, developers can easily adhere and commit to the boy scout rule and the best development practices while delivering value, thereby quality is preserved and enhanced over time.</p><h4>Dev team experience</h4><p>When talking about monolith, we are generally talking about a big multi-module application written using an old technical stack. Dev teams find themselves often forced to work on technologies that are becoming obsolete, which not only makes their daily life a nightmare, but kills every sense of motivation and inspiration they have. Migrating the code base to new frameworks and versions is not an option because it pulls a big part of the monolith to be rewritten. As a result, dev teams are stacked with the early technology choice they made, and talented people leave the project and maybe the company.</p><p>Those problems do not apply to microservices architecture. We can use different technology stacks for every single microservice. Even if a given technology becomes obsolete we do not have to rewrite all the application, we can do it just for the service in question. Furthermore version migrations are not very complicated and easy to do since the code base is small.</p><p>This kind of environment is game changers in the eyes of talented people who will get the ability to express their full potential on various technologies while keeping their life stable. As a result, the turnover will be reduced, which allows the teams to achieve their targets.</p><h4>Logging</h4><p>Logging is important for any application to be able to trace users activity and to know how your system behaves. Monoliths do not face any challenge of logging, logs can be registered using text files on the server running the application.</p><p>This does not go for microservices. If every single microservice registers its logs in a specific text file, we need to open up all the log files of the concerned services in order to manually trace a simple user request. I ‘ll let you imagine how difficult and time consuming the process can be if we run more than one instance for every service. As a result, a centralized solution to mutualise logs which are distributed across different servers is a must in order to handle all logs coming from the different microservices. One of the most used solutions in the software industry to centralize logs is ELK stack.</p><h4>Monitoring and debugging</h4><p>Splitting a monolith application into microservices may result in a lot of services, when the application is big we probably talk about more than one hundred services collaborating all together. This triggers a challenge to monitor all the running instances individually and how they are doing together. For instance, we probably need monitoring dashboards that display if an instance is down, broker queues with unconsumed events or even a way to be able to track a user request downstream the microservices. Effort has been done on this subject, resulting in many tools for monitoring such as ELK stack, APM, Grafana, Zipkin and so forth.</p><h4>Interested in working at Zsoft-Consulting?</h4><p>We’re currently hiring excellent engineers from all over the world who respect science, have passion for technology, and want to evolve and deliver excellence.</p><p>We promise win-win relationships where people grow safe, while pushing the wheel of the business to scale.</p><h4><a href="https://zsoftconsulting.hiring-master.com/">Positions offered by Zsoft-Consulting</a></h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d87b477fe975" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zsoft-engineering-blog/overview-on-microservices-over-monolithic-architecture-d87b477fe975">Overview on Microservices over Monolithic Architecture</a> was originally published in <a href="https://medium.com/zsoft-engineering-blog">Zsoft Engineering Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>