<?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[ServiceRocket Engineering - Medium]]></title>
        <description><![CDATA[Stories from the engineering teams at ServiceRocket. Ready to do the best work of your life? Join us! https://www.servicerocket.com/join-us - Medium]]></description>
        <link>https://medium.com/servicerocket-eng?source=rss----c567919ded3f---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>ServiceRocket Engineering - Medium</title>
            <link>https://medium.com/servicerocket-eng?source=rss----c567919ded3f---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 13:33:25 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/servicerocket-eng" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Increasing Next.js Performance with Bundle Analyzer: A Case Study]]></title>
            <link>https://medium.com/servicerocket-eng/increasing-next-js-performance-with-bundle-analyzer-a-case-study-0418f40aa5c1?source=rss----c567919ded3f---4</link>
            <guid isPermaLink="false">https://medium.com/p/0418f40aa5c1</guid>
            <category><![CDATA[bundle-size]]></category>
            <category><![CDATA[nextjs]]></category>
            <dc:creator><![CDATA[Eugene Chiang]]></dc:creator>
            <pubDate>Mon, 02 Sep 2024 01:38:32 GMT</pubDate>
            <atom:updated>2024-09-02T01:38:32.411Z</atom:updated>
            <content:encoded><![CDATA[<p>In the world of web development, speed is king. How would you feel when an app loads and stares back at you with a glistening blank or white loading screen for just a tad few awkward seconds too long? Chances are, you will immediately feel that the app is clunky or worst: failed to load. It might not seem like it at first glance but bundle sizes can contribute to these experiences.</p><p>Large bundle sizes; especially in your Next.js applications, can slow down your apps which leads to a poor user experience. Coincidentally, the Next.js bundle analyzer provided from Next.js is able to help us keep our bundle sizes in check. It is a powerful tool that helps you visualize and optimize your app’s bundle, ultimately improving its performance.</p><h3>Why Bundle Size Matters</h3><p>Your Next.js app’s bundle is essentially a collection of all the JavaScript, CSS, and other assets needed to run your site. A bloated bundle means more data to download, resulting in slower initial load times and potential performance bottlenecks. By reducing the bundle size, you directly improve your app’s speed and overall user experience.</p><h3>Our Starting Point: A Bloated Bundle</h3><p>Before we started our optimization journey, we noticed that our Next.js app was taking awhile to load. We took a few preemptive steps on how we could approach this: optimizing our endpoints, reducing the total API calls, refactor our component compositions and logic and yet it still feels somewhat slow when booting up the app. Then, we caught onto something else while the app was building: our bundle sizes, they were in the reds! Now, our suspicions point to our larger than normal bundle sizes. To help aid our investigation, we turned to the Next.js bundle analyzer tool to find out whats happening inside.</p><h3>Running the Bundle Analyzer</h3><p>The bundle analyzer is a simple yet powerful tool. You can learn more on how to setup the analyzer using the documentation available <a href="https://nextjs.org/docs/app/building-your-application/optimizing/bundle-analyzer">here</a>. Once it is installed, its time to get our hands dirty. Running the analyzer now will allow your app build and generate a tree map within the next/analyze folder. You can then open the interactive tree map in your browser, visualizing your bundle&#39;s contents and their sizes.</p><h3>Analyzing the Results</h3><p>The initial bundle analysis was eye-opening. We found several culprits contributing to our large bundle size:</p><ul><li><strong>LoadingDots Component (Framer Motion):</strong> A seemingly simple component was surprisingly large due to its dependency on Framer Motion.</li><li><strong>Luxon:</strong> This date library, while powerful, was adding unnecessary weight to our bundle.</li><li><strong>Misplaced Imports:</strong> Some imports within our router file were contributing to the bundle size when they could have been moved to the individual pages.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*97V_oV-PWWQSEzDUN2pAUg.png" /></figure><h3>Optimization Strategies</h3><p>Armed with the analyzer’s insights, we implemented the following optimizations:</p><ul><li><strong>Replace LoadingDots:</strong> We replaced the Framer Motion-based LoadingDots component with a lighter-weight, CSS-based alternative.</li><li><strong>Swap Luxon for Day.js:</strong> We replaced Luxon with Day.js, a smaller library with similar functionality.</li><li><strong>Refactor Imports:</strong> We moved some imports from the router file to the specific pages where they were used, reducing unnecessary dependencies.</li></ul><h3>The Results</h3><p>After implementing these changes, we re-ran the bundle analyzer. The difference was significant:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*-8RLucdVbIuA8P9h0b98yg.png" /></figure><p><strong>Old Bundle</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/503/1*we9K2AR0uOXSzz4YX3ZD3Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/832/1*5SoXgDmmToE6RqcWhtl3mw.png" /></figure><p>Our bundle size was reduced by a third (33%) from 1.95 MB down to 1.3 MB! This resulted in a noticeable improvement in our app’s loading time and overall performance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/505/1*ZyHYznnK63UbyjKumU2auw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/777/1*CPKJPh6kGDJY_8U6IFKgOQ.png" /></figure><p>Our bundle size was reduced by a third (33%) from 1.95 MB down to 1.3 MB! This resulted in a noticeable improvement in our app’s loading time and overall performance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9eoBC4CNn-Z5cjnDZV-CNw.png" /></figure><p>As of today, we strive to continue monitoring our bundle size using the bundle analyzer tool. With regular inspections and clean ups, we are able to ensure that our app remains fast and responsive.</p><h3>Conclusion</h3><p>The Next.js bundle analyzer is an indispensable tool for optimizing the performance of your Next.js applications. By understanding your bundle’s composition and implementing targeted optimizations, you can significantly reduce its size, leading to faster load times, happier users, and a better overall user experience. A few tips on what you can do to optimize your bundle size are:</p><ul><li>Replacing libraries with light weight alternatives.</li><li>Be aware when code splitting and avoid unnecessary imports.</li><li>Lazy load or dynamic imports when using non-critical components.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0418f40aa5c1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/servicerocket-eng/increasing-next-js-performance-with-bundle-analyzer-a-case-study-0418f40aa5c1">Increasing Next.js Performance with Bundle Analyzer: A Case Study</a> was originally published in <a href="https://medium.com/servicerocket-eng">ServiceRocket Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Imposterism, Continuous Learning & Bean Bags — Reflecting on my First Year as a Software Engineer]]></title>
            <link>https://medium.com/servicerocket-eng/imposterism-continuous-learning-bean-bags-reflecting-on-my-first-year-as-a-software-engineer-540d761b8750?source=rss----c567919ded3f---4</link>
            <guid isPermaLink="false">https://medium.com/p/540d761b8750</guid>
            <category><![CDATA[careers]]></category>
            <category><![CDATA[junior-developer]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[humor]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Samir Musaev]]></dc:creator>
            <pubDate>Thu, 29 Aug 2024 00:14:00 GMT</pubDate>
            <atom:updated>2024-08-29T00:14:00.700Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Imposterism, Continuous Learning &amp; Bean Bags — My First Year as a Software Engineer</strong></h3><p>A year of professional experience marks the first of (hopefully) many significant milestones of my career. A lot has happened in these first 12 months, so I figured I’d share four of my biggest takeaways and hope that they offer some form of insight, or at least entertain you for the next 3 minutes.</p><h3>I’m not good enough to have imposter syndrome</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/569/1*vw_cE7YKSbrxn8n_HasmbA.png" /><figcaption>How stand-up felt for the first few weeks</figcaption></figure><p>Being a novice dev is often accompanied by a nagging reminder that you probably aren’t cut out for any of this anyway. And while (I believe) most would agree that imposterism at this phase of one’s career is not only understandable, but also expected, allowing it to go unchecked only serves to hold you back.</p><p>Now I won’t pretend to understand the phenomenon, but we can make a few guesses as to why the syndrome is so prevalent among novice devs. For one, the field as a whole is an ever-growing, ever-changing pit of lore. Staying up to date with all the changes and innovation can be overwhelming for senior engineers, let alone fresh devs who aren’t even aware where their knowledge gaps lie. Add to that the arguably high expectations — being fluent in a language or two, striving for stereotypes of 10x engineers, preparations for DSA interviews, intense competition, and you’ve got yourself the perfect recipe to skyrocket your self-doubts to the moon. At times I felt like a fraud because I hadn’t been blessed with the kind of smart gene that’d enable one to port <a href="https://www.popularmechanics.com/science/a33957256/this-programmer-figured-out-how-to-play-doom-on-a-pregnancy-test/">Doom to a pregnancy test</a>; at my worst, I felt like I’d conned my way into a job I wasn’t cut out for, like I’d made all the wrong career decisions. Then I’d do a double take on a line of code, fix a bug, and feel like the smartest person in the world. It’s all very weird, but I digress.</p><p>Imposter syndrome has done far more harm than good for me. Aside from your regularly-scheduled creeping insecurity, in the worst of it, it stopped me from asking questions because I felt like I had to resolve things on my own; that if I couldn’t figure a task out and needed help, I’d be wasting other people’s time (in addition to proving to them that I’m really stupid, of course). The irony here is I’d instead waste hours on something that could’ve been resolved in mere minutes. Thankfully, after a handful of months, much of the initial anxiety had worn off and I felt gradually more confident in asking questions, irregardless of how seemingly dumb they were. I think the biggest thing that helped me here was working with other engineers on tasks. Seeing a senior developer be completely clueless when faced with a problem inadvertently eased the stress of the unknown, reinforcing the idea that the goal isn’t to have all the answers, but to develop the skill-set to be an effective problem solver.</p><p>In all honesty, I don’t think imposterism goes away; I’m sure it fades as one gains experience, but I reckon a sense of incompetence will forever haunt me (but hopefully in a cool, motivating kinda way). So my plan really is to not fret, and gradually get those <a href="https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4662388/#:~:text=Throughout%20his%20book%2C%20Gladwell%20repeatedly,at%20least%2010%20000%20hours">10,000</a> hours in.</p><h3>Death, taxes &amp; change</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*HteOOF1hmTxBXBTM" /><figcaption>Credit: <a href="https://xkcd.com/927/">xkcd</a></figcaption></figure><p>In the time it took you to read up to this point, 5 new JavaScript frameworks have been released and each one promises to revolutionise the way you write SPAs. The ever mutable nature of software means that change is the one constant, forcing us to embrace the fact that there’s no end in sight to the learning that comes along with staying competitive in this field. On one hand, this can definitely be overwhelming. But on the other, if this doesn’t excite a junior dev in the slightest, I’d question why they’re in this field in the first place.</p><p>The amount of learning that’s gone on for me in the past 12 months is incredible, and it’s often only in hindsight that it’s actually obvious.</p><p>I was fortunate that my company, <a href="https://www.servicerocket.com/">ServiceRocket</a>, engages all new devs in a company ritual — having them embark on quarter-long onboarding projects where they can build practically anything they deem of value to the team or the company. This helped me gain familiarity with how our teams’ products (which at the time was mainly Atlassian apps) were built from the ground up. It gave me the space to really fall on my face — learn and explore the technologies independently, gradually gaining insight into our own codebases, practices and norms.</p><p>A massive chunk of learning was done simply through pairing/mobbing with other teammates. It not only helped me learn the ins and outs of my job faster, but taught me dozens of quick quality of life improvements, debugging skills, and best practices that I probably would not have learned on my own as effectively or as quickly. It also taught me the importance of not jumping headfirst into a problem — it’s far more effective to take a step back and ensure that you fully understand what the requirements are, and preemptively spot some possible obstacles.</p><p>And of course, I’d be lying if I said that 99% of my knowledge didn’t come from me Googling something. The internet is an amazing place, full of fantastic people that will teach you absolutely anything for free. The same goes for staying up to date — there are dozens of excellent email newsletters, YouTube channels, and Instagram pages that help me stay immersed in the environment even in my off hours.</p><p>So really, as a novice dev, you aren’t short of avenues to learn from — it’s accepting the fact that you have to, and putting in the effort that’s the real tough bit.</p><h3>Yapping is heavily underrated</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1021/0*I_ddcHLlBI-SSPZB.jpg" /></figure><p>It feels as though half my day is spent communicating with people, while the other half is spent communicating with machines (which mostly looks like begging the TypeScript compiler for mercy). Needless to say, I think one overlooked aspect of this field is the extent to which we rely on our interpersonal skills.</p><blockquote><em>“How well we communicate is not determined by how well we say things but how well we are understood.” — Andrew Grove</em></blockquote><p>Programming is rarely, if <em>ever</em>, a solo gig. Even as a freelancer, you’ll find yourself sweet-talking your way through meetings, perhaps desperately trying to convince the client that the “quick lil feature” they want is in fact a massive overhaul of their system. Likewise, in regular teams, you’ve got your engineers, designers, maybe a product manager. Trying to navigate that dynamic without proper communication skills is trying to insert a circle in GIMP — definitely doable, but not without wanting to rip your hair out. Sure, you might all be building the same piece of software, but everyone is coming in with varying perspectives and priorities, which inevitably presents some trade-offs to be weighed and negotiated for. Without effective communication and persuasion skills, differing viewpoints could lead to deadlock, or worst of all — sow seeds of resentment. So while the project manager may have the final say, their decisions are (dear God, hopefully) shaped by the input of the entire team.</p><p>Communication abilities don’t seem to be indicative of seniority either. Take documentation, for instance; it’s typically written by domain experts, so you’d expect it to be really easy to follow and understand — but being a domain expert <a href="https://en.wikipedia.org/wiki/Pedagogy">does not</a> automatically mean you’re a good communicator or teacher. Experts can easily fall into the trap of taking their own context and understanding for granted, and find themselves being unable to ‘come down’ to the level of novices, and you end up with something like AWS’ docs.</p><p>What I guess I’m trying to say is that communication is an inescapable aspect of the job — it’s deeply intertwined with individuals and teams’ efforts. Having the ability to understand interpersonal dynamics, express complex ideas concisely, and foster discussions is possibly just as essential as your technical proficiency. So yap away — but do so with purpose and cohesion.</p><h3>Culture beyond bean bags &amp; pizza parties</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6dPeaDk4lu6OfmFn.jpg" /></figure><p>I’m not sure to what extent I have <a href="https://www.youtube.com/watch?v=dcz8JE32Sss">pop culture</a> to blame here, but I used to dismiss the idea of company culture entirely. Bean bags in offices, bi-annual pizza parties and being called ‘family’ all seemed like fronts for UN violations taking place in broad daylight. It took me working for ServiceRocket to realise just how important culture is, and what <em>culture done well</em> looks like.</p><p>Company culture in its definition can be difficult to pinpoint because on one level — the surface level — it’s simply the values and norms that an organisation practices. But really, culture is the merit of those values, the extent to which they permeate throughout the organisation, and whether they are done so in a healthy and productive manner. Good culture is far beyond quarterly bonuses and a dart board in the office, and is certainly desirable as it acts as a lingua franca; in the face of constant change, culture can be the gooey constant that holds it all in place.</p><p>Some things I’ve noticed at ServiceRocket that are indicative of a successful culture include:</p><ul><li>Actual work-life balance — you can’t be productive if you’re burnt out.</li><li>The ability to ask tough questions, have open conversations without the fear of being offered as a sacrifice in an open bonfire.</li><li>Having a manager that facilitates your improvement, from helping you come up with career plans, to encouraging your up-skilling.</li><li>High employee retention. If people are constantly leaving, there’s probably a good reason for it.</li></ul><p>If you’d like to actively evaluate the company’s culture, my best piece of advice would be asking questions that elicit how those values are practiced. For instance, most employers will claim to champion work-life balance, but what does that actually look like on a day-to-day basis? Here at ServiceRocket, one of my favourite things that engineers have are Play Days. On Fridays, we don’t work on any sprint items. The day is dedicated solely to tinkering; be it Kaizen, a new language or framework you’ve been dying to try out, or whipping up a prototype of one of the ideas from our innovation funnel. This not only varies the work that we do, but incentivises collaboration, creative thinking and allows for ample experimentation.</p><p>All of this is to say that culture is not to be understated and is something I’m not willing to compromise on — the whole ‘a job is just a job’ argument is a tough sell considering we spend half our waking hours doing it.</p><p>Well then, that concludes my little semi-coherent rant, but I thank you for getting this far, and hope this has been in some way useful to you. I’m sure I’ve missed out a fair bit, so do feel free to add your experiences or thoughts below. Cheers</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=540d761b8750" width="1" height="1" alt=""><hr><p><a href="https://medium.com/servicerocket-eng/imposterism-continuous-learning-bean-bags-reflecting-on-my-first-year-as-a-software-engineer-540d761b8750">Imposterism, Continuous Learning &amp; Bean Bags — Reflecting on my First Year as a Software Engineer</a> was originally published in <a href="https://medium.com/servicerocket-eng">ServiceRocket Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[3 quick tips for both web designers & developers]]></title>
            <link>https://medium.com/servicerocket-eng/3-quick-tips-for-both-web-designers-developers-1fd250cf04a7?source=rss----c567919ded3f---4</link>
            <guid isPermaLink="false">https://medium.com/p/1fd250cf04a7</guid>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[LongYC]]></dc:creator>
            <pubDate>Wed, 17 Apr 2024 01:01:41 GMT</pubDate>
            <atom:updated>2024-04-17T01:16:28.437Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="A man sitting at a desk, gesturing with a laptop in front of him." src="https://cdn-images-1.medium.com/max/1024/1*VF-7EdsyPFs3RX30Adrb4Q.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@headwayio?utm_content=creditCopyText&amp;utm_medium=referral&amp;utm_source=unsplash">Headway</a> on <a href="https://unsplash.com/photos/black-smartphone-near-person-5QgIuuBxKwM?utm_content=creditCopyText&amp;utm_medium=referral&amp;utm_source=unsplash">Unsplash</a></figcaption></figure><p>Web development topics are broad, ranging from visual design to backend architecture and optimising browser networking. A casual search without being specific could land you on a sea of content to start from scratch, while others emphasise higher-level strategies. What if you already know web developments and just want to learn some techniques to up your game? Here are three tips that can be easily integrated into your day-to-day workflows, and they are useful to both web designers and web developers too.</p><h3>1. Be intentional with image types</h3><p>Usage of images is pretty common so it’s very useful to know the differences between raster and vector images plus when to use them — raster for complex texture details with shading, and vector for clean lines and shapes that can be scaled up without losing quality. It’s best to start with the source from designers and supply the assets with the proper image types accordingly while developers should know when to request or look for the correct formats. A special note for raster images, using modern formats like WebP can give you a better quality-to-file size ratio. Either designers or developers can optimise the SVGs exported from a design tool, there are online guides and tools (e.g. <a href="https://jakearchibald.github.io/svgomg/">SVGOMG</a>) available. Even with these handy tools, we should still beware of base64 encoded raster images sitting inside SVG, it usually happens when a raster image is inserted into a vector-based design, the result is an image with unnecessary bloat.</p><h3>2. Be lazy with loading</h3><p>You probably know that there’s no need to load everything immediately when serving a web page, perhaps we could consider that right from the design phase. Designers could include loading screens or animation as part of the design, especially for heavy pages or components, which then can be implemented with mechanisms like <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import">dynamic imports</a> and <a href="https://react.dev/reference/react/Suspense">React Suspense</a> (or the equivalent from other libraries).</p><p>Developers could also easily add the loading=”lazy” attribute to non-critical images or even iframes so that they load only when they are about to enter the browser’s viewport. The <a href="https://web.dev/articles/browser-level-image-lazy-loading#improved_data-savings_and_distance-from-viewport_thresholds">distance from the viewport threshold</a> to trigger lazy-loading assets is something designers can consider in the design phase to optimise “above the fold” experience if needed; do note that the threshold can change based on browsers and even connection speed.</p><h3>3. Be collaborative with each other</h3><p>This one is not exactly a technical tip, but it could be the most important one. A product could be best implemented if designers and developers can work together around the platform and technical limitations, or capture the opportunities to enhance the product. While there’s no one-size-fits-all way to collaborate, one way to start is by asking each other for one pain point with the current process. Maybe the units for dimensions in the design are not inconsistent, maybe the margins in the implementation are always off, or maybe the assets in Figma library and the npm package are not in sync, it can be anything but pick only one pain point that you could work on to address. Once you’ve done that, maybe try another one, as long as designers and developers are communicating instead of being in silos, we’ll be able to improve from there.</p><p>There, no grand visions or genius strategies here but don’t underestimate the impacts these seemingly simple tactics could have when they are included as part of the delivery process. As the saying goes — “Success is the sum of small efforts, repeated day in and day out”.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1fd250cf04a7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/servicerocket-eng/3-quick-tips-for-both-web-designers-developers-1fd250cf04a7">3 quick tips for both web designers &amp; developers</a> was originally published in <a href="https://medium.com/servicerocket-eng">ServiceRocket Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building Miro Apps at ServiceRocket]]></title>
            <link>https://medium.com/servicerocket-eng/building-miro-apps-at-servicerocket-afb128440d35?source=rss----c567919ded3f---4</link>
            <guid isPermaLink="false">https://medium.com/p/afb128440d35</guid>
            <category><![CDATA[apps]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[softare-development]]></category>
            <category><![CDATA[miro]]></category>
            <dc:creator><![CDATA[Jerome Rodrigo]]></dc:creator>
            <pubDate>Thu, 21 Dec 2023 05:47:33 GMT</pubDate>
            <atom:updated>2023-12-21T05:47:33.414Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><em>Beginning our journey into the world of apps in Miro, the visual workspace for innovation</em></blockquote><p>Recently at ServiceRocket, many squads have started delving into new app development on the Miro platform. At a high level, Miro provides a <a href="https://developers.miro.com/docs/miro-web-sdk-introduction"><strong>Web SDK</strong></a> for simple apps that run while a user is present and a <a href="https://developers.miro.com/reference/api-reference"><strong>REST API</strong></a> for offline interactions.</p><p>Our quarterly engineering hack weeks have also seen many ideas built on the Miro platform. If you’re curious about how we run remote hack weeks at ServiceRocket, check out this article <a href="https://medium.com/servicerocket-eng/running-a-successful-remote-hack-week-e07bfd44d749">here</a>.</p><p>Additionally, we have also kick-started a new <a href="https://www.servicerocket.com/apps/co-innovator-program">Co-Innovator Program</a> which aims to help us gather feedback from potential users and customers about new apps we have in the pipeline. Miro apps are also part of this journey, so feel free to join us if you’re interested!</p><h3>Getting started</h3><p>So how does one start building on Miro?</p><p>Firstly, I’d recommend visiting Miro’s <a href="https://developers.miro.com/">developer portal</a>. Once you’ve signed in to your account, you should see this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h0ACGZCWlsuKgvWZRFgvqg.png" /></figure><p>This landing page is a great place to get started and should be quite intuitive to follow with various guides and documentation created by Miro.</p><p>For those of you who prefer to get your hands dirty or <em>“just show me the code”</em> you can check out the app examples repository on GitHub: <a href="https://github.com/miroapp/app-examples">https://github.com/miroapp/app-examples</a></p><p>After getting acquainted with the basics of the platform, you can follow along with this step-by-step guide here: <a href="https://developers.miro.com/docs/build-your-first-hello-world-app">https://developers.miro.com/docs/build-your-first-hello-world-app</a></p><h3>Tech stack</h3><p>Here at ServiceRocket, we’re passionate about our tech stack. So much that we actually track it! Check out <a href="https://servicerocket.github.io/tech-radar/">https://servicerocket.github.io/tech-radar/</a> to see what we use.</p><p>That said, we didn’t stray too far from what most developers are familiar with, so we decided to stick with <strong>TypeScript</strong> as the main language to develop the app. It’s hard to beat TypeScript since you can develop the full stack in a single language (sorry, Java and Scala lovers).</p><p>We also wanted an opinionated web framework and decided to build it with <a href="https://nextjs.org/"><strong>Next.js</strong></a>. Why Next.js? Well, it has a well-defined structure in place, so you don’t need to reinvent the wheel for many trivial things, e.g, routing. An added benefit of adopting Next.js is that we can choose to make use of SSR (server-side rendering) to boost performance when needed.</p><p>Another important aspect of our stack is CSS for styling. We went through many iterations with various things, like <strong>Tailwind</strong> and <strong>Chakra UI</strong>. However, we ended up scrapping most of it and settled on plain <a href="https://nextjs.org/docs/app/building-your-application/styling/css-modules"><strong>CSS modules</strong></a> and <a href="https://www.mirotone.xyz/css"><strong>Mirotone</strong></a>. Mirotone is a key component in building Miro apps to ensure that your app fits into the general look and feel of Miro.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*7T2z10sGzDasLM1SAYMyfQ.png" /><figcaption>An example on how to apply Mirotone styles @ <a href="https://www.mirotone.xyz/css">https://www.mirotone.xyz/css</a></figcaption></figure><h3>Hosting the app</h3><p>Shortly after building out an early prototype, we soon realised that we hadn’t figured out how to host the app!</p><p>Since we adopted Next.js, the primary option is to host on <a href="https://vercel.com/">Vercel</a>. However, this wasn’t possible, as we don’t really use Vercel to host stuff at ServiceRocket. So we had to figure out how to host the app with AWS instead.</p><p>After many discussions, we came up with an internal RFC that listed 3 options (the main criteria being that it supports AWS):</p><ul><li><strong>AWS Amplify</strong> — <a href="https://aws.amazon.com/amplify/">https://aws.amazon.com/amplify/</a></li><li><strong>Serverless Framework</strong> — <a href="https://www.serverless.com/">https://www.serverless.com/</a></li><li><strong>SST</strong> — <a href="https://sst.dev/">https://sst.dev/</a></li></ul><p><strong>AWS Amplify</strong> didn’t make the cut. Although it has an out-of-the-box setup with Next.js, most of the stacks it creates can’t be customized. In addition, you have to connect your GitHub repository to AWS Amplify to get the CI/CD integration working.</p><p><strong>Serverless Framework</strong> was a close win, as we have shipped many of our apps with this framework. However, it only takes care of the backend stack by default. Although the frontend stack can be supported via AWS CloudFormation templates, we wanted a framework that could cover the full stack of the application without much configuration.</p><p>Finally, we have <strong>SST</strong>. We were quite new to this framework, but after using it for a few days, we were satisfied with how easy it is to deploy full-stack apps. Once an app is set up, it is just one command away from a full deployment in AWS with sst deploy.</p><p>Another powerful feature of SST is that it is built on top of <strong>AWS Cloud Development Framework</strong> (<a href="https://aws.amazon.com/cdk/">CDK</a>). AWS CDK lets us write our infrastructure stack configurations in pure TypeScript or JavaScript, further reducing the cognitive load on engineers by avoiding switching to different languages within a project. SST also leverages the CDK by introducing its own constructs, like <a href="https://docs.sst.dev/constructs/NextjsSite">NextJsSite</a> that packages an out-of-the-box stack ready for deploying Next.js apps.</p><pre>const site = new NextjsSite(stack, &quot;site&quot;, {<br>  path: &quot;packages/web&quot;,<br>  warm: getWarmingConfig(stack.stage),<br>  environment: {<br>    APP_BASE_URL: APP_BASE_URL as string,<br>    APP_ENV: APP_ENV as string,<br>    MIRO_CLIENT_ID: MIRO_CLIENT_ID as string,<br>    MIRO_CLIENT_SECRET: MIRO_CLIENT_SECRET as string,<br>    MIRO_REDIRECT_URL: MIRO_REDIRECT_URL as string<br>  },<br>  customDomain: getCustomDomain(stack),<br>  cdk: {<br>    distribution: {<br>      priceClass: getCfPriceClass(stack.stage)<br>    }<br>  }<br>});</pre><p>Above is a snippet of an Next.js site stack configuration in SST. With a few lines, we can spin up a full-stack Next.js site with CloudFront CDN, custom domains, and various other customisations.</p><h3>Challenges</h3><p>We consider ourselves quite new to Miro app development, and therefore had a few challenges while building out new apps:</p><ul><li>Miro apps are <strong>self-hosted</strong><br> — Coming from something like <a href="https://developer.atlassian.com/platform/forge/">Atlassian Forge</a> which doesn’t require self-hosting, we needed to find ways to host a new infrastructure stack for Miro apps</li><li><strong>Extension points and APIs are limited</strong><br> — We felt the extension points provided e.g. Web SDK and REST API are still quite limited compared to other platforms<br> — Regardless, the Miro team iterates very quickly so new APIs and extension points are progressively being added as experimental features so that developers can try them out and provide feedback</li><li><strong>Monetization</strong> not built in yet<br> — The Miro app ecosystem has a <a href="https://miro.com/marketplace/">marketplace</a> where customers can find apps and install them<br> — However it is up to app vendors to integrate into their own payment and pricing systems</li><li><strong>Automated end-to-end (e2e) app testing</strong><br> — Our squad has attempted to spike into building out e2e tests on Miro, however faced a few issues<br> — Canvas elements are hard to test<br> — Lacking a proper testing framework</li></ul><h3>Pros</h3><p>Despite having some challenges while starting out in the Miro ecosystem, there are a few things that make Miro app development great:</p><ul><li><strong>Great documentation</strong><br> — The documentation site has many code snippets, and even allows you to test API requests<br> — App examples repository</li><li><strong>Easy developer on-boarding process</strong><br> — Spin up a new Miro app in 5 minutes with <a href="https://www.npmjs.com/package/create-miro-app">https://www.npmjs.com/package/create-miro-app</a></li><li>Local app runs on localhost without need to deal with CORS!</li><li><strong>Discord!</strong> Many Mironeers are happy to answer questions and queries in the various channels on the Discord server</li><li><strong>Developer Community Forum</strong><br> — The forum is a great place to ask questions and find answers to common issues: <a href="https://community.miro.com/developer-platform-and-apis-57">https://community.miro.com/developer-platform-and-apis-57</a></li></ul><h3>Wrapping up</h3><p>This is just the beginning of our journey into the world of Miro apps. We’re committed to building great experiences for customers will continue to work with Miro to enrich their platform and ecosystem.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=afb128440d35" width="1" height="1" alt=""><hr><p><a href="https://medium.com/servicerocket-eng/building-miro-apps-at-servicerocket-afb128440d35">Building Miro Apps at ServiceRocket</a> was originally published in <a href="https://medium.com/servicerocket-eng">ServiceRocket Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Chapters help Software Engineers break silos]]></title>
            <link>https://medium.com/servicerocket-eng/chapters-help-software-engineers-break-silos-f550065c8e5b?source=rss----c567919ded3f---4</link>
            <guid isPermaLink="false">https://medium.com/p/f550065c8e5b</guid>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[squad]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Jonathan Appel]]></dc:creator>
            <pubDate>Fri, 08 Dec 2023 06:36:27 GMT</pubDate>
            <atom:updated>2024-01-08T06:17:54.962Z</atom:updated>
            <content:encoded><![CDATA[<p>By modifying chapters from the Spotify Squad model, Software Engineers at ServiceRocket can build connections across multiple offices and teams.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_CGPBI08m-dnSX8E" /><figcaption>Photo by <a href="https://unsplash.com/@tamasp?utm_source=medium&amp;utm_medium=referral">Tamas Pap</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>ServiceRocket has long benefited from the principles of the Spotify squad model of scaling agile. Our Engineers work in groups of approximately five engineers supported by an Engineering Manager (read ScrumMaster), a Product Manager, and a Designer who form the squad. We run chapters in areas of interest or specialization including Architecture, SecOps, Platform Engineering, and <a href="https://medium.com/servicerocket-eng/long-and-ux-chapter-3790880a6077">UX Design</a>.</p><p>This structure has enabled us to create autonomous and accountable teams that scale our development efforts across three continents.</p><p>But all models come with drawbacks, and we initially faced challenges implementing chapters (not dissimilar to those described in <a href="https://www.chameleon.io/blog/spotify-squads#1-the-lack-of-engineering-managers-hindered-communication-with-pms">this Chameleon blog</a>)</p><blockquote>Each chapter has a leader who acts as a formal line manager. This structure enables people to jump from one squad to the next and work on different initiatives without losing their manager and leader.</blockquote><p>In our case, having members of a squad reporting to different managers made it difficult to keep the team accountable for its commitments. Chapter Leads would assign quarterly objectives to their members, distracting them from the commitments of their squads. This also had the side effect of discouraging engineers from joining chapters in the first place (because who wants to work two jobs but only get paid for one?).</p><p>With some changes to our chapter leadership, we were able to keep the benefits of a matrix structure while making reporting structures clearer. Our teams began to collaborate more and improve the inefficiencies that naturally follow from the siloed nature of a squad. In our case, these changes were to:</p><ul><li><strong>Remove the formal line manager</strong> from Chapters encouraging Chapter Leads to instead act as technical mentors in their area of specialization. Engineers now report to an Engineering Manager who also forms part of their squad.</li><li><strong>Keep Chapter members within an assigned squad</strong>. No more scheduled rotation,<strong> </strong>unless there is a compelling reason to do so<strong>. </strong>We also spend time thinking about <a href="https://www.youtube.com/watch?v=oi6e_on6xVc">Tuckman’s stages of team formation</a>.</li><li>Ensure Software Engineers know their <strong>main responsibility is to their squad</strong> and its backlog. They should focus on delivering value for Product Managers.</li><li>Encourage Chapter Leads to <strong>treat members like volunteers</strong> (who have full-time jobs with their squads). Chapters have become more like internal user groups or communities of practices that run once or twice a fortnight.</li><li>Lowering the barrier for those interested in starting a chapter. <strong>Enabling new leaders to grow their influence</strong> within the Engineering culture.</li></ul><p>If you’re looking to learn more about the Spotify model for scaling agile, Atlassian has a helpful write-up to get you started — <a href="https://www.atlassian.com/agile/agile-at-scale/spotify">https://www.atlassian.com/agile/agile-at-scale/spotify</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f550065c8e5b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/servicerocket-eng/chapters-help-software-engineers-break-silos-f550065c8e5b">Chapters help Software Engineers break silos</a> was originally published in <a href="https://medium.com/servicerocket-eng">ServiceRocket Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understand and Managing Software Vulnerability as a Software Engineer]]></title>
            <link>https://medium.com/servicerocket-eng/understand-and-managing-software-vulnerability-as-a-software-engineer-ce1e6a9fdccc?source=rss----c567919ded3f---4</link>
            <guid isPermaLink="false">https://medium.com/p/ce1e6a9fdccc</guid>
            <category><![CDATA[compliance]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[engineering-culture]]></category>
            <category><![CDATA[software-security]]></category>
            <dc:creator><![CDATA[Kai Ming, Chow]]></dc:creator>
            <pubDate>Wed, 06 Dec 2023 12:30:39 GMT</pubDate>
            <atom:updated>2023-12-06T12:30:39.325Z</atom:updated>
            <content:encoded><![CDATA[<h3>Understanding and Managing Software Vulnerability as a Software Engineer</h3><h3>Software Engineer plays Critical Role in Secure Software Design</h3><p>You are a software engineer, not a security expert. Why the need for you to care for security vulnerability? The straightforward answer is software vulnerability can be exploited by attackers which can lead to identity theft, fraud, monetary loss, loss of reputation and trust from customers, and other dire consequences.</p><p>Imagine you have a smart home system, and you have other IoT devices connected to it. Everything is working fine until you buy a new smart TV and set it up. Without you knowing, an attacker exploited your TV’s vulnerability to hack into other smart devices on your network.</p><p>One day, you receive a dubious email with pictures of you and your home attached. The sender says they have spied on you. You realize that the pictures were taken from your smart home devices, such as robot vacuum and CCTV.</p><p>You try to return the TV for a warranty claim, but the manufacturer refuses to fix it. They say the TV is working as expected and do not consider security to be their responsibility. What do you think of a manufacturer that refuses to fix a security vulnerability in their product, even though it could harm their customers?</p><p>Software engineers have a responsibility to help protect their customers from harm by understanding software vulnerability, designing secure software, and writing secure code.</p><h3>Understanding Software Vulnerability</h3><h4>Definition</h4><p>A software vulnerability is a weak spot in the form of design, implementation, and operation of the software that allow attackers to gain unauthorized access to software and data, as well as disruption to software<br>operation.</p><p>Using the scenario above, the smart TV has a software defect that causes a security breach on the user’s smart home system.</p><p>Software vulnerability is a defect or bug in the software. What makes it different from other bugs is the risk impact it made:</p><blockquote><em>Malicious actors can exploit their unintended behavior to gain unauthorized access to the software and data, and disrupt the software’s normal operation.</em></blockquote><h3>Software Always Delegate. They Don’t Work Alone.</h3><p>Most software doesn’t run independently. It relies on many other software components, such as runtimes and APIs, to provide features and functionality to end users. For example, a smart home system requires various IoT devices to be connected to give a seamless smart home experience to the user.</p><p>Regardless of the tech stack (NodeJS, Python, Java, etc) and runtime (v8/libuv, cpython, JVM, etc), the runtime always abstracts the underlying OS interaction in the form of core library API. When software performs any operation such as file access, network access, and memory access, the runtime will delegate the operation to the operating system. The operating system will then coordinate with the underlying hardware (via driver) and other software components to carry out the operation.</p><p>Example of Operating System operation that happens for each software use case.</p><ul><li>A web application running with a bundle web server will delegate the task of opening a port and listening for incoming connections to the web server</li><li>When an application sends an HTTP request to a web server, the operating system will perform DNS/IP lookup, open a socket, connect to the server, send the request, and receive the response.</li><li>A GUI application will delegate the task of opening a window, drawing a button, receiving a click event, and rendering the UI to the operating system.</li><li>A CLI application that performs multithread downloads of a file will delegate the task of starting a new thread, opening a socket, sending a request, receiving a response, and writing a file to the operating system.</li></ul><h3>Exploit Chaining: Software Vulnerability Working Together</h3><p>Given the intertwined nature of software, a software vulnerability that seems harmless on its own can have a compounding effect when combined with other software vulnerabilities. This is known as exploit chaining (or vulnerability chain). It is a technique/strategy where multiple software vulnerabilities are coordinated together to achieve a specific goal.</p><p>For example, in a smart home scenario earlier, multiple vulnerabilities could exist across smart home IoT devices (e.g., router, smart TV, robot vacuum, CCTV, smart speaker). A threat actor could then perform an exploit chain by first gaining unauthorized access to smart TV. Then he exploits vulnerabilities in the CCTV and robot vacuum to take pictures of you and your home. Smart TV could simply provide an internet gateway for threat actors to hack into your whole smart home system.</p><p>Exploit chaining attack is hard to detect because:</p><ul><li>We don’t know where all the weak points in the software are. What is detected by SAST and DAST is the only known weakness. What about unknown weakness (zero-day vulnerability)?</li><li>We are not wearing the attacker hat. We don’t know how the attacker is strategizing the attack, and what their mindset is.</li></ul><p>Example of real-world exploit chaining attack:</p><ul><li><a href="https://github.blog/2021-03-24-real-world-exploit-chains-explained/">https://github.blog/2021-03-24-real-world-exploit-chains-explained/</a></li><li><a href="https://blog.google/threat-analysis-group/spyware-vendors-use-0-days-and-n-days-against-popular-platforms/">https://blog.google/threat-analysis-group/spyware-vendors-use-0-days-and-n-days-against-popular-platforms/</a></li><li><a href="https://www.microsoft.com/en-us/security/blog/2021/03/25/analyzing-attacks-taking-advantage-of-the-exchange-server-vulnerabilities/">https://www.microsoft.com/en-us/security/blog/2021/03/25/analyzing-attacks-taking-advantage-of-the-exchange-server-vulnerabilities/</a></li><li><a href="https://www.bitdefender.com/blog/businessinsights/technical-advisory-proxyhell-exploit-chains-in-the-wild/">https://www.bitdefender.com/blog/businessinsights/technical-advisory-proxyhell-exploit-chains-in-the-wild/</a></li></ul><p>Exploit chaining attacks can be mitigated by patching software vulnerabilities regularly and by using security solutions that can detect and block exploit chains. Therefore, it is important that we put in process and practice to keep our application and system patched all the time.</p><h3>Managing Vulnerability</h3><p>With the lower entry barrier to access security testing (checking tools) such as Github Dependabot, OWASP ZAP, AWS Inspector, etc, we are now much more capable of detecting vulnerabilities in our applications. There are also a lot of big tech companies providing incentives for security researchers (or white hat hackers) to report such vulnerabilities to fix it.</p><p>However, it always requires a manual intervention to patch existing running software systems. This will become a conflicting work when a team is having timeline trying to ship features. Of course, there’s a multitude of ways to tackle this. For now, let’s focus on what you can do as an individual.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DNUVl1HyHvUFHmpQO-rvjQ.png" /></figure><p>Figure 1: Chart depicting example of handling a security vulnerability</p><h3>Address Critical, High Risk, and RCE (Remote Code Execution) Vulnerability First</h3><p>Always prioritize addressing critical and high-risk vulnerabilities. Whenever there is a critical or high-risk vulnerability reported, regardless of whether it’s a direct or indirect dependency, we need to quickly assess the likelihood of the vulnerability being exploited in our application.</p><p>How to assess it? You will need to gather enough information for you to assess it:</p><p><em>Note: If there is a quick way to stop the security loophole by making configuration changes, perform it first. You can perform impact or breach assessment after closing the loophole.</em></p><ol><li>You need to understand how the vulnerable software fits into your application stacks in the big picture. What role does software play in your application environment? At which point does the software is executed or triggered?</li><li>The CVE reports will usually include what is the behavior of the vulnerability, and what are the circumstances to trigger the unintended behavior. Look for any information that can be used as proof of exploitation. If there is none, as an engineer, you will have to work out a way to validate it.</li><li>Based on #1 and #2, you need to look for the right logs to search for evidence of compromise.</li></ol><h4>Examples:</h4><p>Here are some real-world examples that happened, and how we manage it, following the steps above:</p><p><strong>log4shell (References: </strong><a href="https://nvd.nist.gov/vuln/detail/CVE-2021-44228"><strong>CVE-2021–44228</strong></a><strong>)</strong></p><ol><li>Log4j is used in our web application and its application runtime dependencies. We used it to create our application log. Identify which project is using it by doing a code search for application dependencies.</li><li>The vulnerability happens when JNDI features in Log4j are used. Check for direct or indirect usage of JndiLookup class, and its relevant configuration.</li><li>Finding evidence of compromise:</li></ol><ul><li>Analyze web traffic logs and application logs.</li><li>Analyze any possible unknown process executed in the server.</li></ul><p><strong>RCE vulnerability for </strong><strong>git(References: </strong><a href="https://github.com/git/git/security/advisories/GHSA-475x-2q3q-hvwq"><strong>CVE-2022–41903</strong></a><strong> , </strong><a href="https://github.com/git/git/security/advisories/GHSA-c738-c5qq-xg89"><strong>CVE-2022–23521</strong></a><strong>)</strong></p><ol><li>git is used in the build server, development machine, and production docker container.</li><li>To identify the impacted project, the vulnerability can be easily triggered with git log — format=… and indirectly using git archive via export-subst mechanism.</li><li>Finding evidence of compromise:</li></ol><ul><li>Check if git really used for production features.</li><li>Check if git is accessible from your production application.</li><li>Check web traffic to look for any suspicious traffic that could trigger the vulnerability.</li><li>Check for any git related logs for suspicious activity.</li><li>Check for any shell history looking for suspicious command execution.</li><li>Check for any weird processes in the server.</li></ul><h3>Always Have Firewall and IDS (Intrusion Detection System) in Place</h3><p>Firewall and IDS are always the most critical line of defense when it comes to vulnerability exploitation. We make sure that firewall or IDS logging is well configured. This will allow us to perform an assessment of intrusion and post-mortem. It gives us visibility of what is going in and out of our system. It is important to keep firewalls and IDS up to date with the latest security patches to protect against the latest threats.</p><h3>Build Process to Ease Patches, Stop Ignoring Vulnerability</h3><p>It is important to patch software vulnerabilities as soon as possible to reduce the risk of being exploited by attackers. However, it is unrealistic to expect to patch all vulnerabilities immediately, especially given the high volume of vulnerabilities that are discovered every day.</p><p>One way to address this challenge is to build a process to ease the effort of patching vulnerabilities. For example, you could:</p><ul><li>Improve your CI/CD pipeline so that every deployment includes a check for an upgrade to the latest versions of all dependencies.</li><li>Add a cronjob to schedule regular package upgrades for non-critical servers.</li><li>Write automated tests to allow for the quick merging of Dependabot pull requests.</li></ul><p>It is also important to note that not all Dependabot alerts are relevant or correct. It is therefore acceptable to ignore false alarms. However, it is important to have a process in place to identify and validate the impact of vulnerabilities so that they can be patched promptly. You may consider using “rate of closing Dependabot issue” vs “rate of new Dependabot issue” to get an idea how well you are performing in patching the vulnerability.</p><h3>Don’t Forget the Obligation To SLA</h3><p>For an organization that has compliance requirements, there is usually a requirement to fulfill the SLA in handling security vulnerability.</p><p>Please be warned that SLA that required by compliances only makes sense when no successful exploitation is happening yet. Under circumstances where there’s an attempt to exploit the vulnerability, it must be immediately escalated and resolved.</p><h3>Keep Your Application Dependencies as Little as Possible</h3><p>As much as dependencies save us time to get a project to get started quickly, there will be a point in time when the benefits of dependencies start to dimmish, especially when we start to consider software maintenance costs across the period of software ownership.</p><p>So, when should we start thinking about reducing the number of dependencies? It’s when the maintenance cost for the software is too high, yet the software is not being actively developed or used.</p><ul><li>There’s always a contextual and learning cost with every usage of the library.</li><li>Reducing the chances of working on the project increases the contextual and learning costs.</li><li>Reducing the number of dependencies reduces the need to update dependencies, both willingly and unwillingly.</li></ul><p>What about criteria to remove dependencies? There isn’t a general rule that can be applied, as it heavily depends on the team’s situation and capabilities at that point in time.</p><p>The rule of thumb is to get a balance between ease of maintenance and ease of development. Here are some of the example criteria:</p><ul><li>Application is using a small subset of features for a library, and those features can be replaced by features in core library, or they are not complex and can be implemented in the application.</li><li>Features of the library used are simple, and replicable within the application. It is not complex and can be merged into the application code.</li><li>The rate of change to the library is too high, yet the library is not used very much in the application.</li><li>The library always has a substantial number of CVEs reported, and there’s a better alternative.</li></ul><h3>Only Keep Necessary Software in a Production Environment, Purge Otherwise</h3><p>This suggestion is part of a topic related to <a href="https://en.wikipedia.org/wiki/Hardening_(computing)">security hardening</a>. This is similar to the principle of least privilege. Both goals are to reduce the attack surface available to the threat agent.</p><p>As much as we tried to rely on the provided default software configuration to have a sensible configuration, in some scenarios, they might be insecure. So rather than leave it to chance, it might be better that we take some proactive measurements:</p><p>Remove unused software from our production environment, especially those that has capability to perform network communication. Some examples of software that should be removed from the production environment include network tools such as wget, curl and telnet.</p><h3>Be Creative When No Patches Are Available</h3><p>Under a situation where there are no patches available, but you need to reduce the risk posed by the vulnerability, you must be creative to look for a workaround. There is no one-size-fits-all solution.</p><p>The solution is very dependent on a lot of factors such as software architecture, kind of vulnerability, how tightly coupled the software is, etc. It is important to take note that we need to balance the risk of vulnerability with the impact of the workaround, as some workarounds may introduce new risks or have a negative impact on performance.</p><p>Some examples of solutions when patches are unavailable:</p><ul><li>Feature flag it and temporarily disable the features. This can be useful for temporarily disabling a vulnerable feature until a patch is available.</li><li>Whitelist specific IPs for access to the vulnerable service. This can prevent threat actors from exploiting the vulnerable service, while allowing dependent service to function normally until a patch is available.</li><li>Hide the service in private VPC and build a proxy layer that isn’t vulnerable. This provides the same benefits as the solution above.</li><li>Clone the software or libraries and create the patch yourselves. You can proactively create the patch yourself rather than waiting for others. However, please do weigh up the maintenance effort of the cloned software and libraries.</li><li>Create firewall rule to block out specific request data. This will immediately block threat actors&#39; access to your service.</li><li>Remove the vulnerable software or library. This will immediately improve the security of your software system.</li></ul><h3>Summary</h3><p>It can be difficult to build a security management process from scratch within an organization when there isn’t the right incentive to do so. It requires understanding from multiple stakeholders to build the process.</p><p>Despite these challenges, engineers should take proactive measures like what has been discussed in this article. In fact, software engineers should start being more proactive in software security and encourage other engineers to do the same. This will help us to develop more capable engineers with ethics, accountability, and integrity. Such engineers will be able to help the organization to withstand the impact of security vulnerability and safeguard the company’s reputation as a trustworthy organization.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ce1e6a9fdccc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/servicerocket-eng/understand-and-managing-software-vulnerability-as-a-software-engineer-ce1e6a9fdccc">Understand and Managing Software Vulnerability as a Software Engineer</a> was originally published in <a href="https://medium.com/servicerocket-eng">ServiceRocket Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Developing for NetSuite — Our road through Hackweek’s Goals Management Bot]]></title>
            <link>https://medium.com/servicerocket-eng/developing-for-netsuite-our-road-through-hackweeks-goals-management-bot-310901825e5d?source=rss----c567919ded3f---4</link>
            <guid isPermaLink="false">https://medium.com/p/310901825e5d</guid>
            <category><![CDATA[bots]]></category>
            <category><![CDATA[hackathons]]></category>
            <category><![CDATA[servicerocket]]></category>
            <category><![CDATA[workplace]]></category>
            <category><![CDATA[netsuite]]></category>
            <dc:creator><![CDATA[Ricardo Césped]]></dc:creator>
            <pubDate>Mon, 15 May 2023 23:40:28 GMT</pubDate>
            <atom:updated>2023-05-15T23:41:20.771Z</atom:updated>
            <content:encoded><![CDATA[<h3>Developing for NetSuite — Our road through HackWeek’s Goals Management Bot</h3><h3>Introduction</h3><p>ServiceRocket is known for its <a href="https://www.servicerocket.com/post/together-we-grow-the-tree-and-share-the-fruit">Grow the Tree</a> program, allowing the company to be strong and provide more to everyone by Sharing the fruit. One of its approaches to accomplish this are <a href="https://docs.oracle.com/en/cloud/saas/netsuite/ns-online-help/article_159542637440.html">NetSuite Goals</a>, which are a set of goals each quarter for the continuous improvement of people, their teams, and their ways of working. It’s not rare that sometimes, a team gets organized to work on the same goal, or goals, which helps the team build stronger relationships, better teamwork, and many other benefits.</p><p>Having shared goals could be nice in many ways, but it also has some issues in how teams collaborate to complete these goals, for example, updating and sharing their status with the rest of the team, reporting and commenting on them, managing and monitoring them, etc. This process is error-prone and time-consuming, besides, each member of the team has to do these tasks every week for their own goal.</p><p>During the 2022 Hack Week, the RAD Squad worked on the idea of simplifying the management of goals for a team through a simple but powerful chatbot for <a href="https://www.workplace.com/">Workplace</a> which will enable you with the ability to build a team, create a ‘Shared Goal’, and assign a driver that will update status every week for the rest of the team, so everyone is aware of its status without using third-party tools. This article is intended to go through our journey and highlight some of the issues we ran into while developing on NetSuite.</p><h3>The Goals Management Workplace chatbot</h3><p>One of the main things we needed for the project was a Workplace chatbot, which, the team already had experience in building, so this was the easier part of the whole project. The team was split so we could have progress on both sides, one being the work in the chatbot and the other, the NetSuite scripts to manipulate the data.</p><p>First, we focused on the commands that would be available to be used with the bot, commands like creating the goal for the tagged people, getting the status of the goal, commenting on the goal, and modifying the status of the goal for everyone, which were the actions that we usually have to do manually on NetSuite.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/883/1*nYlRtRkfDFbPxoMHdfR1uQ.png" /></figure><p>The second part of the chatbot was to link the commands we made with NetSuite to do the things that the commands were intended to do. At first, because the NetSuite part wasn’t ready at the time of development we made dummy calls with hardcoded data to simulate the NetSuite scripts behaviors so we could keep developing without blockers. After the NetSuite scripts were ready we just had to replace the dummy data and calls with the actual endpoints for the scripts.</p><h3>Enabling the chatbot’s NetSuite connection</h3><p>NetSuite doesn’t seem to have a direct API to manage things granularly like goals, but it allows the creation of scripts to extract, create and modify data. While searching through NetSuite’s documentation on how to interact with records like goals, we found two types of scripts, which were SuiteScripts and RESTlet scripts.</p><p>SuiteScripts is a NetSuite’s platform built on JavaScript that acts like a library that is available on most parts of the site, if not every part of it. It enables the customization and automation of processes allowing access and manipulation of business records and user information via scripts that are executed at pre-defined events. For example, page access, field change, form submission, before read, before write, etc. They can also be scheduled to run at specific times.</p><p>RESTLet scripts are server-side deployed scripts that interact with NetSuite data following RESTful principles. RESTlets extend the SuiteScript API to allow custom integrations with NetSuite. They offer ease of adoption for developers familiar with SuiteScript and support more behaviors than SOAP-based web services, which are limited to those defined as SOAP web services operations.</p><p>With these scripts, we would be able to create, read and update the content of the goals, and even add more detailed logic to the scripts to fit our needs.</p><h3>Dealing with SuiteScripts</h3><p>We started our development for NetSuite with SuiteScripts because it was the first type of scripts that we found information about, and because the documentation was somewhat decent for the basics. When we found out about RESTLets we decided to keep experimenting with SuiteScripts mainly because they use the same syntax and it was easier to test due to SuiteScripts running on the NetSuite’s site directly while the user was logged in.</p><p>Here is where things started to get a bit difficult. We were able to read certain records on NetSuite, like Contacts, User information, Events, etc… but the records related to goals were failing when the scripts were executed. We didn’t know why.</p><pre>var receivedGoal = record.load({<br>  type: record.Type.GOAL,<br>  id: goal.id,<br>});</pre><p>While we were working on this issue, someone else was investigating about RESTLet scripts, because we knew at this point that we would need them to be able to integrate the chatbot with the NetSuite scripts on behalf of the user, and besides, it uses the same syntax as ScriptLets. At some point, someone decided to try the code we already had, but with the RESTLet script he was developing, and to our surprise, it worked without any problems.</p><pre>Some of the documentation:<br><br><a href="https://nlcorp.app.netsuite.com/core/media/media.nl?id=51416823&amp;c=NLCORP&amp;h=c7cecd8e1180e6076aca&amp;_xt=.pdf">SuiteScript Developer &amp; Reference Guide</a><br><br><a href="https://docs.oracle.com/en/cloud/saas/netsuite/ns-online-help/article_163726005075.html">SuiteScript Overview</a><br><br><a href="https://docs.oracle.com/en/cloud/saas/netsuite/ns-online-help/section_4618431823.html">Getting Started with RESTlets</a></pre><p>For protecting the available endpoints NetSuite offers three types of authentication:</p><ul><li><a href="https://docs.oracle.com/en/cloud/saas/netsuite/ns-online-help/section_156337186044.html">Three-Step TBA Authorization Flow</a> which offers a redirection-based authorization flow with token-based authentication where users enter their credentials into one of the following login forms as a part of the flow: A trusted NetSuite login form; SAML SSO identity provider’s login form; OIDC OP provider’s login form.</li><li><a href="https://docs.oracle.com/en/cloud/saas/netsuite/ns-online-help/section_157780218434.html">OAuth 2.0</a> which is based on the authorization code grant flow for the generation of access tokens and refresh tokens, or the client credentials flow. These alternatives are more straightforward than the three-step TBA authorization flow, because they do not require the signing of requests.</li><li><a href="https://docs.oracle.com/en/cloud/saas/netsuite/ns-online-help/section_4623992425.html">Using User Credentials</a> with which you can authenticate by providing a user ID and password. With this approach, you use an NLAuth authorization header. NLAuth is a NetSuite-specific authentication approach that is used for RESTlets only.</li></ul><h3>Connecting the chatbot with NetSuite</h3><p>Given the three ways of securing the endpoints, we opted for OAuth, mainly because it&#39;s one of the most common ways of authentication.</p><p>The first step was to make an endpoint available so we could link a workplace user to a NetSuite user. This is where OAuth 2.0 method comes into place. You can check more information about how to achieve this in the <a href="https://docs.oracle.com/en/cloud/saas/netsuite/ns-online-help/section_157780218434.html">documentation</a>.</p><p>After obtaining and storing the required tokens for the NetSuite connection, we just had to use them to request access tokens so the bot could act on behalf of the user and authenticate them for the API calls to the RESTLet scripts.</p><p>Now that we had the authentication problem sorted out, we just had to bind the chatbot commands to the functions that would manage the logic to, for example, create goals for each user, making calls to the NetSuite RESTLet on behalf of each one of the users involved.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/710/1*4fU4n4pG0l0_-lBo-G-BQg.png" /></figure><h3>To conclude</h3><p>NetSuite offers a big degree of freedom when it comes to customization, allowing you to control most things in detail thanks to their JavaScript API, making it possible to automate simple tasks to the more complex ones, and even integrate your own apps into it.</p><p>Working with NetSuite’s JavaScript API was a challenge, especially because finding the right documentation was a bit difficult, and then, understand it and making it work was another obstacle that we had to overcome, but once we got the hang of it, everything else became a lot easier.</p><p>As always, the better the documentation on a system, the easier it gets to work with it and achieve the desired outcome.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/909/1*7r1nf1G2kp7iA_aF_K8JQg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=310901825e5d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/servicerocket-eng/developing-for-netsuite-our-road-through-hackweeks-goals-management-bot-310901825e5d">Developing for NetSuite — Our road through Hackweek’s Goals Management Bot</a> was originally published in <a href="https://medium.com/servicerocket-eng">ServiceRocket Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Long and UX Chapter]]></title>
            <link>https://medium.com/servicerocket-eng/long-and-ux-chapter-3790880a6077?source=rss----c567919ded3f---4</link>
            <guid isPermaLink="false">https://medium.com/p/3790880a6077</guid>
            <category><![CDATA[servicerocket]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Kai Fung Chong]]></dc:creator>
            <pubDate>Thu, 06 Apr 2023 06:44:20 GMT</pubDate>
            <atom:updated>2023-04-06T06:44:20.142Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>… a senior engineer working in a product squad but often sneaks off to run a UX chapter when the product manager is not looking.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*meZGk2zhKsAlLSMqDnmZtw.jpeg" /><figcaption>Long - first row, second from left</figcaption></figure><p><strong>Q: What is your name, and how long have you been at ServiceRocket?</strong></p><p>I usually introduce myself by surname — Long, to keep it short and easy to pronounce. It has been 8 years since I first joined ServiceRocket.</p><p><strong>Q: What is your current role in ServiceRocket and how did you transition into it?</strong></p><p>I’m a senior engineer working in a product squad which build apps for Confluence Cloud but I often sneak off to run a UX chapter when the product manager is not looking.</p><p>As for how I transition into the role, I might need to go back to as far back as when I first joined, I was given a brief talk about Agile by my then-manager after my interview. I was then introduced to automated testing which was inspiring and eye-opening for me who had limited exposure to modern practices. Starting as one of the junior members, I was fortunate to work with more experienced colleagues and was given the opportunity to grow in a couple of teams working on a variety of technologies. Along the way, I found myself drawn to the then UX guild. With the encouragement from my mentor and manager, I took the role of a chapter lead. There is no doubt that these years in ServiceRocket are formative for my career and will be a memorable period of my life.</p><p><strong>Q: What is a Chapter in ServiceRocket?</strong></p><p>There is a bit of a journey from how we started what we now call a chapter in ServiceRocket. As you may have guessed from the terms used, we first explored the idea of a chapter based on the popular Spotify model. It looked promising as a framework for team formation. We formed tribes around product platforms, each tribe with multiple squads, and chapters that spanned across squads from different tribes. After some time, we realized that this created some overheads in reporting structure and source of work because chapter members had to juggle between squads and chapters. So we reformed chapters into something that resembled more of user groups with the primary goal to drive knowledge sharing and practices across squads, while still allowing engineers to specialize in a particular domain.</p><p><strong>Q: What are the focus areas of UX Chapter?</strong></p><p>UX Chapter focuses on areas that have direct impact on the overall user experience. We work closely with designers on implementations and keeping up with modern frontend development, plus an eye for design system components and standards. One of the main goals is to bridge the gaps between design and engineering by building a common understanding.</p><p><strong>Q: Did you always want to specialize in UX?</strong></p><p>I have always been interested in creating a good experience and have always regarded good user experience as a hallmark of great products. However, I didn’t know much about the domain or even knew the term “UX” until several years ago. Not that I’m an expert now but ever since I discovered what goes beyond UI design, I’ve been trying to learn more about the field and be the advocate of the human aspect of software development that often gets overlooked.</p><p><strong>Q: What are the challenges that you have faced along the way and how did you overcome them? Any experience or lessons to share?</strong></p><p>The roads were quite bumpy for me to lead a UX Chapter. For starters, UX design is relatively new compared to other disciplines like operation and security. It is less involved in terms of the technicality which most software engineers are interested in. As mentioned earlier, we were experimenting how to run chapters. It was difficult for the chapter to create significant direct impacts. Chapter members were struggling prioritizing responsibilities between squad and chapter. What helped, for me at least, is to be more intentional in energy management, and eventually the aforementioned reforming the expectations and purpose of chapters. It’s not all sunshine and rainbows now but it’s more manageable and we’re still learning.</p><p>As for experience or lessons, I used to answer these questions with something technical. However, as my experience grew and our engineering team expanded, I found out that there are other aspects of software engineering that are more challenging to scale. One of them is alignment and effective communication, especially when teams span across multiple platforms and timezones, more so when working remotely becomes common since the recent pandemic. Sharing best practices through influence and learning by proxy don’t work as well in these situations. I find taking a balanced approach between communicating through systemizing for scalability and empathizing through personal interactions for effectiveness depending on circumstances eases the gaps.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fTGL-fgbTivnNyA1vDxeTw.jpeg" /></figure><p><strong>Q: Can you also talk about study groups that you have organized?</strong></p><p>While Chapters meetings are useful for broad knowledge sharing and building influence for best practices, I have been organizing study groups as a more structured mechanism to help the chapter members to upskill in more specific topics. We’ve done one for browser networking and are currently going through one for React. What separates our study groups from available online courses is that we get to inject usage context around our own problem and solution domains. We have the flexibility to adjust the pace and scope to better suit the skill levels of attendees according to feedback received.</p><p><strong>Q: What are your hobbies? Or what can we find you doing outside of work?</strong></p><p>I tend to fill up my free time learning about technology in general, not confined to those in software engineering only and more often than not are related to consumer electronics. There is a sense of wonder in seeing them getting more advanced and how the reach of these technologies influences us at individual, community, or even societal level. But other than that, I’m not beyond the common hobbies of playing video games and reading books, maybe writing a couple blog posts or publishing podcasts with friends (who I came to know through ServiceRocket) when the stars align.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3790880a6077" width="1" height="1" alt=""><hr><p><a href="https://medium.com/servicerocket-eng/long-and-ux-chapter-3790880a6077">Long and UX Chapter</a> was originally published in <a href="https://medium.com/servicerocket-eng">ServiceRocket Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Role and responsibilities of an Engineering Manager at ServiceRocket]]></title>
            <link>https://medium.com/servicerocket-eng/role-and-responsibilities-of-an-engineering-manager-at-servicerocket-5d0298a349be?source=rss----c567919ded3f---4</link>
            <guid isPermaLink="false">https://medium.com/p/5d0298a349be</guid>
            <category><![CDATA[engineering-culture]]></category>
            <category><![CDATA[servicerocket]]></category>
            <category><![CDATA[engineering-manager]]></category>
            <dc:creator><![CDATA[Choong Pak Wai]]></dc:creator>
            <pubDate>Mon, 13 Feb 2023 01:46:15 GMT</pubDate>
            <atom:updated>2023-02-13T01:46:15.734Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ekG9YN6rGq18v0t2tQGEog.jpeg" /><figcaption>In a serious brainstorming session</figcaption></figure><p>As Engineering Managers (EM) at ServiceRocket, we play an important role in leading and managing teams of engineers to ensure smooth day-to-day operation and career progression for those we support.</p><p>The aim of this article is to help Individual Contributors (IC) to better understand the role of an EM. Ultimately, taking the leap to open up new opportunities for what a management track can offer. If you’re one of those still contemplating the move, read on.</p><p>The biggest misconception engineers have when thinking about moving into management is they think it’s a promotion. <a href="http://fractio.nl/2014/09/19/not-a-promotion-a-career-change/">It’s a career change, not a promotion.</a></p><blockquote>If you have a technical degree in particular, this can be especially jarring; working with other people, and moving into leadership requires an entirely different set of skills.</blockquote><blockquote>- The Manager’s Path by Camille Fournier</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JLZxHp_Uu9ssvc57" /></figure><p>The right culture and mindset for the role is someone who resonates deeply with ServiceRocket’s 5 core values:</p><ul><li>Delight the customer</li><li>Share the knowledge</li><li>Build process to drive outcomes</li><li>Think team</li><li>Talk straight</li></ul><p>and 10 Leadership behaviors</p><ul><li>Team builder</li><li>Develop Rocketeers</li><li>Empower others</li><li>Good listener</li><li>Stable confident</li><li>Servant leader</li><li>Deliberate &amp; Decisive</li><li>Smartly anticipates</li><li>Proactive and responsive</li><li>Accountable</li></ul><p>If any of these comes naturally to you, you’re already halfway there to succeed in the role.</p><h3>People and Process First</h3><blockquote>When you become a leader, you must transition from being responsible for the job, to being responsible for the people who are responsible for the job.</blockquote><blockquote>- Simon Sinek</blockquote><p>This is the management philosophy we strongly believe in. We leverage our wisdom and experience to help our team members to succeed. It can be taking care of the well-being and the development of the team member by creating a learning and supportive environment for the team to collaborate, and build (and experiment) with processes to improve the effectiveness of our operations.</p><p>Think Kaizen. A Japanese term that refers to the continuous improvement of processes. The goal for us is to create a culture of continuous improvement, where every team member is encouraged to identify and implement changes that will improve efficiency and quality.</p><h3>Become the glue</h3><blockquote>Effective managers tend to become the glue in their team, filling any gaps. That means sometimes doing things you don’t really want to do in order to set a good example.</blockquote><blockquote>- Elegant puzzle by Will Larson</blockquote><p>We’re not necessarily the ones who need to do the dirty (technical) work anymore. They can be delegated, and that is what we need to do to succeed. Nevertheless, we still need to maintain a certain degree of hands-on and discussion group to stay relevant to support the team, filling in any gaps and also dealing with stakeholders that come along. Eg. the ability to build a mental model of how things work and connect them together.</p><h3>A day at work</h3><p>Not forgetting, the usual stuff that we do as a manager is also part of our responsibility. They are the vital heartbeat to keep the business running.</p><p>That said, it is much easier for us to run down a day at work, just to share a high-level gist of it.</p><ol><li>Manager — doing all the administrative work that the management needs.</li><li>Mentor/coach — provide career guidance for your direct team members.</li><li>Scrum master (or agile coach) — facilitate and coach the team, to ensure that we stay on track with the rituals and development work.</li><li>Advisor — provide advice and oversight such as the best practice, industry and compliance standards, etc during the development.</li><li>Hiring manager — assists in the recruitment process and helps bring like-minded people to the team.</li></ol><h3>Why should you consider</h3><p>Foremostly, management offers tremendous opportunities for career growth and advancement. As you gain experience and develop your leadership skills, such as:</p><ol><li>Opportunity to lead and mentor. Through 1:1 and other mediums, you’ll be shaping your career and growth plan.</li><li>Another way to bring impact. As you’ll have a more significant impact on the success of the project and the overall business. Delivering impact is not limited to solving technical work, but rather by setting the direction and enabling others.</li><li>Broaden your skillset. EM requires a broad set of skills, including technical knowledge, leadership, project management, and communication. By taking on this role, you’ll have the opportunity to broaden your skills and develop new competencies.</li></ol><h3>Conclusion</h3><p>We intentionally left out career growth. ServiceRocket career growth is available for both the EM and IC. That’s the beauty of being in tech.</p><p>A career as an Engineering Manager offers a unique set of challenges and opportunities for Software Engineers. If you’re interested in broadening your skillset, having a greater impact on the success of projects, and advancing your career.</p><p>If you’re prepared for it, we welcome you. We provide coaching and a learning platform to grow even if you’re new to the management role. Dear senior ICs, this is for you. 🙂</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5d0298a349be" width="1" height="1" alt=""><hr><p><a href="https://medium.com/servicerocket-eng/role-and-responsibilities-of-an-engineering-manager-at-servicerocket-5d0298a349be">Role and responsibilities of an Engineering Manager at ServiceRocket</a> was originally published in <a href="https://medium.com/servicerocket-eng">ServiceRocket Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Self-hosted runner vs. GitHub-hosted runner]]></title>
            <link>https://medium.com/servicerocket-eng/self-hosted-runner-vs-github-hosted-runner-43f23bfe78bb?source=rss----c567919ded3f---4</link>
            <guid isPermaLink="false">https://medium.com/p/43f23bfe78bb</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[self-hosted-runner]]></category>
            <dc:creator><![CDATA[mogavenasan]]></dc:creator>
            <pubDate>Fri, 23 Dec 2022 02:02:18 GMT</pubDate>
            <atom:updated>2022-12-23T02:02:17.959Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oBZyNx61LEjGwieD1SXv3A.jpeg" /></figure><h3>Background</h3><p>I’m Moga, I’m a Software Engineer at ServiceRocket and I’m part of the Developer Experience squad. The Developer Experience squad is a Platform type team — our Vision is to help Stream-Aligned teams move faster by defining Principles, Practices and Patterns, removing redundancy and providing psychological safety for Software Engineering here in ServiceRocket.</p><p>One of the major decisions that we took quite some time ago is that we will decommission our Jenkins and replace it with GitHub Actions. The maintenance cost of Jenkins was slowly chirping away our engineers’ time and GitHub Actions was the answer we were looking for — fully managed, secure and it’s already included within our GitHub subscription.</p><p>Along the way, while all the squads are slowly migrating their pipeline to GitHub Actions, one of our squads that supports one of the chunkiest apps had a problem with their integration tests and E2E tests in GitHub Actions. After looking into the problem, we discovered that the default GitHub Actions runner machine is not powerful enough to run our integration tests and E2E tests. The standard GitHub Actions runner machine (for Linux) comes with 2-core CPU (x86_64), 7 GB of RAM and 14 GB of SSD space; <a href="https://docs.github.com/en/enterprise-cloud@latest/actions/using-github-hosted-runners/about-github-hosted-runners#supported-runners-and-hardware-resources">Supported runners and hardware resources</a>.</p><p>Coincidently, at the same time, GitHub announced the <a href="https://docs.github.com/en/enterprise-cloud@latest/actions/using-github-hosted-runners/using-larger-runners">GitHub-hosted larger runner</a>. Currently, this feature is in beta and you will need to send a request to GitHub to enable this feature for your GitHub organization.</p><p>For comparison, we took a job from our current Jenkins and perform some estimation on how it would look in GitHub Actions.</p><ul><li>Machine specs:<br>- CPU: 4 cores<br>- Memory: 16GB<br>- OS: Ubuntu<br>- Instance type: m6i.xlarge (Spot instance)</li><li>Job:<br>- Execution duration: ~2h (~1h for each job that runs in parallel)<br>- Frequency (in a month): 12–15 (on the <em>main </em>branch)<br>- Triggered based on: push to any branch</li></ul><p>For simplicity&#39;s sake, we will just look at the <em>main</em> branch to have an idea of how it would look like.</p><h3>Pricing comparison (AWS vs. GHA larger runners)</h3><ul><li>Based on 15 runs on the <em>main</em> branch. (15 x 2h = 30h)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*19og_wpz9Z8UiV8C9Old1A.png" /><figcaption>Pricing comparison (AWS vs. GHA larger runner)</figcaption></figure><p>The idea behind the <em>AWS (Spot)</em> and <em>AWS (On-demand) (spin for use)</em> is that we will have custom shared GitHub Actions that will provision the resources in AWS and once we are done with the runner, we will destroy the resources.</p><h3>Pros and cons</h3><p>The pros and cons of each approach are documented:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/998/1*4OlMCg35c-GaW53Zhfk8mQ.png" /><figcaption>Pros and cons</figcaption></figure><h3>Decision</h3><p>Well, we went with <em>AWS (Spot)</em> for obvious reasons. It’s already the existing design and we just need to implement something very minimal to get this to work with GitHub Actions — we need a custom shared GitHub Actions.</p><p>The idea was taken from <a href="https://github.com/machulav/ec2-github-runner">ec2-github-runner</a>, but we want it to be more templatized and automated so that the EC2 gets the latest AMI, running in a specific AWS account, in a specific VPC and subnet and we are very sure that all the runners are running in the architecture that we designed so that we can have a peace of mind that they all are configured securely. By templatizing, we also removed the cognitive load from all the squads — they do not have to worry about the AMI ID, how should the network be configured and etc. — it’s very close to plug-and-play manner to provision and destroys the runners.</p><h3>Custom GitHub Action</h3><p>The usage will look something like the following — you will have a job that will provision the runner and then, you will also have a job to destroy it once it’s not needed and they all can exist in the same GitHub Actions workflow.</p><pre>- name: Start runner/ Destroy runner<br>  id: start-runner/ destroy-runner<br>  uses: servicerocket/actions/self-hosted-runner@{ref}<br>  with:<br>    # AWS access key id (do not change the value)<br>    aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}<br>    # AWS secret access key (do not change the value)<br>    aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}<br>    # Robot GitHub token (do not change the value)<br>    robot-token: ${{ secrets.ROBOT_TOKEN }}<br>    # Squad identifier for AWS resources<br>    team:<br>    # Operation mode; start/stop<br>    mode: <br>    # Number of runner machines (optional, only for mode: start, default 1)<br>    capacity:<br>    # Indicates that this is a test; true/false (optional, only for mode: start, default false)<br>    # By default (test: false), the action will provision m6i.xlarge instance(s).<br>    # If test: true, the action will provision t2.micro instance(s).<br>    test:</pre><p>In the background, the custom action will do the following:</p><pre>name: &#39;Manage Self Hosted Runner&#39;<br>description: &quot;A shared action to create/destroy AWS Self Hosted GitHub Action runner&quot;<br>author: mogavenasan, raeveen<br>inputs:<br>  aws-access-key-id:<br>    description: &quot;The aws-access-key-id used to authenticate with AWS&quot;<br>    required: true<br>  aws-secret-access-key:<br>    description: &quot;The aws-secret-access-key used to authenticate with AWS&quot;<br>    required: true<br>  robot-token:<br>    description: &quot;ROBOT GitHub token&quot;<br>    required: true<br>  team:<br>    description: &quot;Team tag for AWS resources&quot;<br>    required: true<br>  mode:<br>    description: &#39;Operation type; start/stop&#39;<br>    required: true<br>  capacity:<br>    description: &quot;Number of nodes to provision&quot;<br>    default: &quot;1&quot;<br>    required: false<br>  test:<br>    description: &quot;To provision smaller instance(s) for test&quot;<br>    default: &quot;false&quot;<br>    required: false<br>outputs:<br>  runner-name:<br>    description: &quot;Self hosted runner name&quot;<br>    value: ${{ steps.set-env.outputs.runner-name }}<br>runs:<br>  using: &quot;composite&quot;<br>  steps:<br>    - name: Set environment variables<br>      id: set-env<br>      run: |<br>        echo &quot;run_id=${{ github.run_id }}&quot; &gt;&gt; $GITHUB_ENV<br>        echo &quot;repo_owner=${{ github.repository_owner }}&quot; &gt;&gt; $GITHUB_ENV<br>        echo &quot;repo_name=${{ github.event.repository.name }}&quot; &gt;&gt; $GITHUB_ENV<br>        stack_name=${{ github.repository_owner }}-${{ github.event.repository.name }}-${{ github.run_id }}<br>        echo &quot;stack_name=$stack_name&quot; &gt;&gt; $GITHUB_ENV<br>        echo &quot;::set-output name=runner-name::$stack_name&quot;<br>      shell: bash<br>    - name: Configure AWS credentials<br>      uses: aws-actions/configure-aws-credentials@v1<br>      with:<br>        aws-access-key-id: ${{ inputs.aws-access-key-id }}<br>        aws-secret-access-key: ${{ inputs.aws-secret-access-key }}<br>        aws-region: us-west-2<br>    - name: Get latest version of AMI ID<br>      if: ${{ inputs.mode == &#39;start&#39; }}<br>      run: |<br>        ubuntu_release_url=&quot;https://changelogs.ubuntu.com/meta-release-lts&quot;<br>        ubuntu_release_info=$(curl -s &quot;$ubuntu_release_url&quot;)<br>        ubuntu_name=$(echo &quot;$ubuntu_release_info&quot; \<br>          | grep Dist: \<br>          | tail -n1 \<br>          | sed &#39;s/Dist: //&#39;<br>        )<br>        ubuntu_version=$(echo &quot;$ubuntu_release_info&quot; \<br>          | grep Version: \<br>          | tail -n1 \<br>          | sed &#39;s/Version: //;s/ LTS//&#39; \<br>          | awk -F \. {&#39;print $1&quot;.&quot;$2&#39;}<br>        )<br>        if [[ -z &quot;$ubuntu_name&quot; ]] || [[ -z &quot;$ubuntu_version&quot; ]]<br>        then<br>          echo &quot;Unable to find the latest Ubuntu LTS version.&quot;<br>          echo &quot;Please check if $ubuntu_release_url returns the metadata correctly.&quot;<br>        else<br>          id=$(aws ec2 describe-images \<br>            --owners 099720109477 \<br>            --filters &quot;Name=name,Values=ubuntu/images/hvm-ssd/ubuntu-$ubuntu_name-$ubuntu_version-amd64-server-*&quot; \<br>            --query &#39;sort_by(Images,&amp;CreationDate)[-1].ImageId&#39; \<br>            --output text<br>          )<br>        echo &quot;ami_id=$id&quot; &gt;&gt; $GITHUB_ENV<br>        fi<br>        # Uncomment the next line as a fallback method if the script is not able to get the latest Ubuntu version<br>        # echo &quot;ami_id=ami-08df94af6199f15b6&quot; &gt;&gt; $GITHUB_ENV<br>      shell: bash<br>    - name: Create runner<br>      if: ${{ inputs.mode == &#39;start&#39; }}<br>      run: |<br>        aws cloudformation create-stack \<br>          --stack-name ${{ env.stack_name }} \<br>          --template-body file://${{ github.action_path }}/spot-fleet.yml \<br>          --capabilities CAPABILITY_NAMED_IAM \<br>          --parameters \<br>          ParameterKey=GHARunID,ParameterValue=${{ env.run_id }} \<br>          ParameterKey=RepoOwner,ParameterValue=${{ env.repo_owner }} \<br>          ParameterKey=RepoName,ParameterValue=${{ env.repo_name }} \<br>          ParameterKey=RobotToken,ParameterValue=${{ inputs.robot-token }} \<br>          ParameterKey=AmiId,ParameterValue=${{ env.ami_id }} \<br>          ParameterKey=Origin,ParameterValue=${{ env.stack_name }} \<br>          ParameterKey=Team,ParameterValue=${{ inputs.team }} \<br>          ParameterKey=Capacity,ParameterValue=${{ inputs.capacity }} \<br>          ParameterKey=Test,ParameterValue=${{ inputs.test }}<br>      shell: bash<br>    - name: Destroy runner<br>      if: ${{ inputs.mode == &#39;stop&#39; }}<br>      run: |<br>        aws cloudformation delete-stack --stack-name &quot;${{ env.stack_name }}&quot;<br>        sleep 30<br>        offline_runners=$(curl -s \<br>          -H &quot;Accept: application/vnd.github+json&quot; \<br>          -H &quot;Authorization: Bearer ${{ inputs.robot-token }}&quot; \<br>          https://api.github.com/repos/${{ env.repo_owner }}/${{ env.repo_name }}/actions/runners \<br>          | jq -r &quot;.runners[] | select((.status == \&quot;offline\&quot;) and (.labels[].name == \&quot;${{ env.stack_name }}\&quot;)) | .name&quot;<br>        )<br>        export RUNNER_CFG_PAT=${{ inputs.robot-token }}<br>        for runner in $offline_runners<br>        do<br>          curl -s https://raw.githubusercontent.com/actions/runner/main/scripts/delete.sh \<br>            | bash -s ${{ env.repo_owner }}/${{ env.repo_name }} $runner<br>        done<br>      shell: bash</pre><p>And then, there is the CloudFormation YAML file; <em>spot-fleet.yml</em>. In this file, you will define the AWS resources and the architecture of the EC2 machine. We went with <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet.html">Spot Fleet</a> since there are possibilities that we will need to request more than one EC2 instance. The stacks are created/destroyed using the <a href="https://docs.aws.amazon.com/cli/latest/reference/cloudformation/index.html">AWS CLI | cloudformation</a>.</p><p>To register the GitHub runner, we are using the scripts from <a href="https://github.com/actions/runner/blob/main/docs/automate.md">Automate Configuring Self-Hosted Runners</a>. To register a runner, this script is embedded within the <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html">EC2 UserData</a> and to de-register a runner, this script is used within the custom action itself.</p><p>In order for this to work, you will need a <a href="https://docs.github.com/en/enterprise-cloud@latest/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token">PAT (Personal Access Token)</a> from a GitHub account that has an Admin privilege on the GitHub repository. To make it clear, we have designed the custom action in a way that it will register the runner to the repository instead of the organization — this gives us some auditability and visibility when it’s needed.</p><h3>Future work</h3><p>We are continuously improving the custom action to make it work seamlessly in squads’ CI/CD pipeline in GitHub Actions.</p><p>There are a few different ongoing efforts right now such as how to make this custom action work with <a href="https://docs.github.com/en/enterprise-cloud@latest/actions/using-jobs/using-a-matrix-for-your-jobs">matrix strategy</a> and how to compute the capacity automatically instead of hardcoding in the action’s input.</p><p>For time being, this solution works for us and helps us with the migration. We will revisit this solution again sometime in the future to re-evaluate the design. We are excited to see what the future holds for us!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=43f23bfe78bb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/servicerocket-eng/self-hosted-runner-vs-github-hosted-runner-43f23bfe78bb">Self-hosted runner vs. GitHub-hosted runner</a> was originally published in <a href="https://medium.com/servicerocket-eng">ServiceRocket Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>